@@ -12,21 +12,53 @@
 """
 
 import asyncio
+import logging
 from contextlib import suppress
 from dataclasses import dataclass, field
+from typing import get_args
 
 from ag_ui.core import EventType, RunErrorEvent, RunFinishedEvent, RunStartedEvent
 from ag_ui_claude_sdk import ClaudeAgentAdapter
-from claude_agent_sdk import AssistantMessage, HookMatcher, ToolResultBlock, UserMessage
+from claude_agent_sdk import (
+    AssistantMessage,
+    EffortLevel,
+    HookMatcher,
+    ToolResultBlock,
+    UserMessage,
+)
 from claude_agent_sdk.types import StreamEvent
 
 from .replay import run_replayed_query, system_instructions
 
+logger = logging.getLogger(__name__)
+
+# The efforts `ClaudeAgentOptions.effort` takes (the CLI's `--effort`), read from the SDK itself.
+SDK_EFFORTS = frozenset(get_args(EffortLevel))
+
 
 class ModelAuthenticationError(Exception):
     pass
 
 
+def run_model(forwarded_props):
+    """The `(model, effort)` the server chose for this run, or `None` when it chose none.
+
+    The server sends `openbotModel: {"model": ..., "reasoningEffort": ...}` on both of this
+    harness's paths and strips any a browser supplied, so it is the deployment's decision. A value
+    of another shape is ignored. An effort the SDK does not take is not sent, and no effort means
+    the model's own default.
+    """
+    props = forwarded_props if isinstance(forwarded_props, dict) else {}
+    choice = props.get("openbotModel")
+    if not isinstance(choice, dict):
+        return None
+    model = choice.get("model")
+    if not isinstance(model, str) or not model.strip():
+        return None
+    effort = choice.get("reasoningEffort")
+    return model.strip(), effort if effort in SDK_EFFORTS else None
+
+
 @dataclass
 class _ClientBoundary:
     tool_ids: set[str]
@@ -47,6 +79,8 @@ class _Turn:
     # Tool calls Claude Code reported as failed, and the result the turn streamed for each.
     failed: set[str] = field(default_factory=set)
     failed_results: dict[str, str] = field(default_factory=dict)
+    # The model the server chose when this query started, or that it was switched to since.
+    model: str | None = None
 
     def result(self, tool_id):
         if tool_id not in self.results:
@@ -73,13 +107,20 @@ def __init__(self, *args, model_only=False, **kwargs):
         self._segment_locks: dict[str, asyncio.Lock] = {}
 
     def build_options(self, input_data=None, thread_id=None):
+        # Read before the model endpoint drops its forwarded props: the server's choice of model
+        # is the one prop it honours. Every query is built here, so a choice changed between runs
+        # starts the next query on it.
+        chosen = run_model(input_data.forwarded_props) if input_data else None
         if self._model_only and input_data:
             # The model endpoint accepts prompts and caller-owned tools, never SDK
             # configuration or an ungoverned state-management tool.
             input_data = input_data.model_copy(
                 update={"state": None, "forwarded_props": {}}
             )
         options = super().build_options(input_data, thread_id)
+        if chosen:
+            # After the upstream merge, so the server's choice wins over a forwarded `model`.
+            options.model, options.effort = chosen
         if not self._model_only and input_data:
             # The model endpoint gets its instructions in context. A full Bot gets its standing
             # role only as a system message, which a user prompt cannot carry.
@@ -313,6 +354,7 @@ async def run(self, input_data):
                         message="This Claude query is waiting for its client tool result; no matching tool-use ID was supplied."
                     )
                     return
+                await self._follow_model_choice(thread_id, turn, input_data)
                 for tool_id, content in incoming.items():
                     turn.result(tool_id).set_result(content)
                 # Parallel client tools may return in separate HTTP requests.
@@ -329,7 +371,11 @@ async def run(self, input_data):
                         message="The Claude query for this tool result is no longer running. Start a new message."
                     )
                     return
-                turn = _Turn(tool_names={tool.name for tool in input_data.tools})
+                chosen = run_model(input_data.forwarded_props)
+                turn = _Turn(
+                    tool_names={tool.name for tool in input_data.tools},
+                    model=chosen[0] if chosen else None,
+                )
                 self._turns[thread_id] = turn
                 turn.task = asyncio.create_task(self._pump(input_data, turn))
 
@@ -361,6 +407,29 @@ async def run(self, input_data):
                 if not released:
                     await self.interrupt(thread_id)
 
+    async def _follow_model_choice(self, thread_id, turn, input_data):
+        """Move a running query to the model a tool result's run was sent with.
+
+        A tool result continues the SDK query that asked for it, so its options are the ones that
+        query started with. A person can pick another model while a call waits on them, and the
+        rest of that turn should answer on it: the SDK changes a running query's model
+        (`ClaudeSDKClient.set_model`). It has no such call for effort, so a changed effort applies
+        from the next query, which `build_options` starts on it.
+        """
+        chosen = run_model(input_data.forwarded_props)
+        if not chosen or chosen[0] == turn.model:
+            return
+        worker = (self._workers.get(thread_id) or {}).get("worker")
+        client = getattr(worker, "_client", None)
+        if client is None:
+            return
+        try:
+            await client.set_model(chosen[0])
+        except Exception as error:  # The turn finishes on the model it has rather than failing.
+            logger.warning("The running Claude query kept its model: %s", type(error).__name__)
+            return
+        turn.model = chosen[0]
+
     async def interrupt(self, thread_id=None):
         threads = [thread_id] if thread_id else list(self._turns)
         for current in threads:
 
@@ -0,0 +1,159 @@
+"""The server's choice of model and effort reaches the Claude Code process, on both paths.
+
+The server sends `forwardedProps.openbotModel` on every run: to `/model` for its built-in Bots on a
+Claude plan, and to `/` when this harness is the Bot a person chats with. What the choice must
+reach is the command the SDK starts Claude Code with (`--model`, `--effort`), so that is what is
+checked, built by the SDK's own transport from the options this adapter makes. Queries run against
+the controlled SDK client in `test_tool_continuation`, which runs the adapter's real hooks.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+import pytest
+from ag_ui.core import RunAgentInput
+from claude_agent_sdk._internal.transport.subprocess_cli import SubprocessCLITransport
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from src.adapter import OpenBotClaudeAgentAdapter
+from test_tool_continuation import events, request, sdk, tool_name  # noqa: F401  (fixtures)
+
+
+def run_input(forwarded_props):
+    return RunAgentInput.model_validate(
+        {
+            "threadId": "thread",
+            "runId": "run",
+            "state": None,
+            "messages": [{"id": "user", "role": "user", "content": "Plan my week"}],
+            "tools": [],
+            "context": [],
+            "forwardedProps": forwarded_props,
+        }
+    )
+
+
+def command(options):
+    """The Claude Code command line the SDK builds from these options."""
+    options.cli_path = "/not-executed/claude"
+    return SubprocessCLITransport(prompt="contract only", options=options)._build_command()
+
+
+def flag(cmd, name):
+    return cmd[cmd.index(name) + 1] if name in cmd else None
+
+
+@pytest.mark.parametrize("model_only", [True, False])
+@pytest.mark.parametrize(
+    ("choice", "model", "effort"),
+    [
+        ({"model": "claude-opus-5-5", "reasoningEffort": "xhigh"}, "claude-opus-5-5", "xhigh"),
+        ({"model": "claude-sonnet-5", "reasoningEffort": "low"}, "claude-sonnet-5", "low"),
+        ({"model": "claude-haiku-4-5"}, "claude-haiku-4-5", None),
+        # Efforts Claude Code does not take are not sent: the model's own default applies.
+        ({"model": "claude-haiku-4-5", "reasoningEffort": "minimal"}, "claude-haiku-4-5", None),
+        ({"model": "claude-haiku-4-5", "reasoningEffort": "none"}, "claude-haiku-4-5", None),
+    ],
+)
+def test_the_servers_choice_reaches_claude_code(model_only, choice, model, effort):
+    adapter = OpenBotClaudeAgentAdapter(name="choice", model_only=model_only)
+    options = adapter.build_options(run_input({"openbotModel": choice}), "thread")
+
+    assert (options.model, options.effort) == (model, effort)
+    cmd = command(options)
+    assert flag(cmd, "--model") == model
+    assert flag(cmd, "--effort") == effort
+    asyncio.run(adapter.shutdown())
+
+
+@pytest.mark.parametrize("model_only", [True, False])
+@pytest.mark.parametrize(
+    "props", [{}, {"openbotModel": {"model": 5}}, {"openbotModel": "claude-opus-5-5"}]
+)
+def test_without_a_choice_claude_code_keeps_its_own_model(model_only, props):
+    adapter = OpenBotClaudeAgentAdapter(name="choice", model_only=model_only)
+    cmd = command(adapter.build_options(run_input(props), "thread"))
+
+    assert "--model" not in cmd
+    assert "--effort" not in cmd
+    asyncio.run(adapter.shutdown())
+
+
+def test_the_servers_choice_wins_over_a_forwarded_model():
+    adapter = OpenBotClaudeAgentAdapter(name="choice")
+    options = adapter.build_options(
+        run_input({"model": "claude-haiku-4-5", "openbotModel": {"model": "claude-opus-5-5"}}),
+        "thread",
+    )
+
+    assert options.model == "claude-opus-5-5"
+    asyncio.run(adapter.shutdown())
+
+
+@pytest.mark.parametrize("model_only", [True, False])
+def test_a_choice_changed_between_runs_starts_the_next_query_on_it(sdk, model_only):  # noqa: F811
+    async def scenario():
+        adapter = OpenBotClaudeAgentAdapter(name="choice", model_only=model_only)
+        try:
+            first = request(run="run-1", tool_count=0)
+            first.forwarded_props = {"openbotModel": {"model": "claude-sonnet-5", "reasoningEffort": "high"}}
+            assert (await events(adapter, first))[-1].type == "RUN_FINISHED"
+            second = request(run="run-2", tool_count=0)
+            second.forwarded_props = {"openbotModel": {"model": "claude-opus-5-5", "reasoningEffort": "low"}}
+            assert (await events(adapter, second))[-1].type == "RUN_FINISHED"
+            third = request(run="run-3", tool_count=0)
+            third.forwarded_props = {"openbotModel": {"model": "claude-opus-5-5"}}
+            assert (await events(adapter, third))[-1].type == "RUN_FINISHED"
+
+            assert [(client.options.model, client.options.effort) for client in sdk] == [
+                ("claude-sonnet-5", "high"),
+                ("claude-opus-5-5", "low"),
+                ("claude-opus-5-5", None),
+            ]
+        finally:
+            await adapter.shutdown()
+
+    asyncio.run(scenario())
+
+
+@pytest.mark.parametrize("model_only", [True, False])
+def test_a_tool_result_sent_with_another_model_moves_the_running_query_to_it(sdk, model_only):  # noqa: F811
+    async def scenario():
+        adapter = OpenBotClaudeAgentAdapter(name="choice", model_only=model_only)
+        try:
+            first = request(run="run-1")
+            first.forwarded_props = {"openbotModel": {"model": "claude-sonnet-5"}}
+            assert any(event.type == "TOOL_CALL_END" for event in await events(adapter, first))
+
+            same = request(run="run-2", results=[("thread-a-tool-0", "page title")])
+            same.forwarded_props = {"openbotModel": {"model": "claude-opus-5-5"}}
+            resumed = await events(adapter, same)
+
+            assert resumed[-1].type == "RUN_FINISHED"
+            assert len(sdk) == 1, "the tool result continues the query that asked for it"
+            assert sdk[0].models_set == ["claude-opus-5-5"]
+            assert sdk[0].results["thread-a-tool-0"] == [{"type": "text", "text": "page title"}]
+        finally:
+            await adapter.shutdown()
+
+    asyncio.run(scenario())
+
+
+@pytest.mark.parametrize("model_only", [True, False])
+def test_a_tool_result_on_the_same_model_leaves_the_query_alone(sdk, model_only):  # noqa: F811
+    async def scenario():
+        adapter = OpenBotClaudeAgentAdapter(name="choice", model_only=model_only)
+        try:
+            first = request(run="run-1")
+            first.forwarded_props = {"openbotModel": {"model": "claude-sonnet-5"}}
+            await events(adapter, first)
+            same = request(run="run-2", results=[("thread-a-tool-0", "page title")])
+            same.forwarded_props = {"openbotModel": {"model": "claude-sonnet-5"}}
+            assert (await events(adapter, same))[-1].type == "RUN_FINISHED"
+
+            assert sdk[0].models_set == []
+        finally:
+            await adapter.shutdown()
+
+    asyncio.run(scenario())
@@ -73,6 +73,7 @@ def __init__(self, options):
             self.queries = []
             self.results = {}
             self.interrupted = False
+            self.models_set = []
             self.disconnected = False
             self.disconnected_event = asyncio.Event()
             self.hooks_entered = asyncio.Event()
@@ -88,6 +89,10 @@ async def disconnect(self):
         async def interrupt(self):
             self.interrupted = True
 
+        async def set_model(self, model=None):
+            # `ClaudeSDKClient.set_model`: the running query's next request uses `model`.
+            self.models_set.append(model)
+
         async def query(self, prompt, session_id):
             if not isinstance(prompt, str):
                 self.input_messages = [message async for message in prompt]