Skip to content
Python

Replay reasoning on the OpenAI-compatible path (OPE-178)

Devika Verma4caf7564a87d
diff --git a/coworker/providers/openai_provider.py b/coworker/providers/openai_provider.py
index 3203981c..72636ff1 100644
--- a/coworker/providers/openai_provider.py
+++ b/coworker/providers/openai_provider.py
@@ -59,6 +59,42 @@ def _pin_reasoning_effort(kwargs: dict[str, Any]) -> None:
kwargs.setdefault("reasoning_effort", "none")
+def _reasoning_field(obj: Any) -> Optional[str]:
+ """Which field the thinking arrived in: `reasoning_content` (Together, Moonshot,
+ DeepSeek, GLM) or `reasoning` (OpenRouter, xAI). The same name is used to send it
+ back (OPE-178)."""
+ for name in ("reasoning_content", "reasoning"):
+ value = getattr(obj, name, None)
+ if isinstance(value, str) and value:
+ return name
+ return None
+
+
+def _reasoning_extras(field: Optional[str], text: Optional[str]) -> dict[str, Any]:
+ """The `_openai_compat` sidecar persisted on the assistant message: the thinking text
+ and the field it arrived in, replayed verbatim by `replay_reasoning`. Kimi K3 requires
+ the complete assistant message — reasoning included — back on later turns; other
+ reasoning models on this path document the same. Empty when nothing arrived."""
+ if field and text:
+ return {"_openai_compat": {"field": field, "text": text}}
+ return {}
+
+
+def replay_reasoning(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+ """Re-attach each assistant message's persisted thinking under the field name it
+ arrived in (OPE-178). Messages without the sidecar are returned untouched, so models
+ that never send reasoning see byte-identical requests. Call before
+ `_strip_foreign_sidecars`, which then removes the underscore key itself."""
+ out: list[dict[str, Any]] = []
+ for m in messages:
+ sidecar = m.get("_openai_compat") if m.get("role") == "assistant" else None
+ if isinstance(sidecar, dict) and sidecar.get("text") and sidecar.get("field"):
+ out.append({**m, str(sidecar["field"]): str(sidecar["text"])})
+ else:
+ out.append(m)
+ return out
+
+
def _delta_reasoning(obj: Any) -> Optional[str]:
"""Thinking text off a delta/message: `reasoning_content` (DeepSeek, GLM, Kimi, and
most compat vendors) or `reasoning` (xAI, OpenRouter). Extra response fields survive
@@ -231,7 +267,7 @@ class OpenAIProvider(ProviderClient):
plan = self._effort_plan(model, settings)
kwargs: dict[str, Any] = {
"model": model,
- "messages": _strip_foreign_sidecars(messages),
+ "messages": _strip_foreign_sidecars(replay_reasoning(messages)),
**settings,
}
if tools:
@@ -257,12 +293,14 @@ class OpenAIProvider(ProviderClient):
text = getattr(message, "content", None)
tool_calls = _parse_tool_calls(getattr(message, "tool_calls", None))
text, tool_calls = _maybe_salvage_tool_calls(text, tool_calls, tools=tools)
+ reasoning_text = _delta_reasoning(message)
return AssistantTurn(
text=text,
tool_calls=tool_calls,
finish_reason=getattr(choice, "finish_reason", None),
raw=response,
- reasoning=_delta_reasoning(message),
+ reasoning=reasoning_text,
+ extras=_reasoning_extras(_reasoning_field(message), reasoning_text),
usage=_usage_from(getattr(response, "usage", None)),
output_limit=_output_limit(kwargs),
effort=self._note_effort(model, plan, kwargs),
@@ -306,7 +344,7 @@ class OpenAIProvider(ProviderClient):
plan = self._effort_plan(model, settings)
kwargs: dict[str, Any] = {
"model": model,
- "messages": _strip_foreign_sidecars(messages),
+ "messages": _strip_foreign_sidecars(replay_reasoning(messages)),
"stream": True,
# Usage on the final chunk (empty `choices`). Compat servers that reject
# the option get a one-shot retry without it (_param_fix_retry).
@@ -323,6 +361,7 @@ class OpenAIProvider(ProviderClient):
text_parts: list[str] = []
reasoning_parts: list[str] = []
+ reasoning_field: Optional[str] = None
tool_accum: dict[int, dict[str, str]] = {}
finish_reason = None
usage: Optional[TokenUsage] = None
@@ -351,6 +390,7 @@ class OpenAIProvider(ProviderClient):
if delta is not None:
reasoning = _delta_reasoning(delta)
if reasoning:
+ reasoning_field = reasoning_field or _reasoning_field(delta)
reasoning_parts.append(reasoning)
yield StreamChunk(reasoning_delta=reasoning)
content = getattr(delta, "content", None)
@@ -392,6 +432,7 @@ class OpenAIProvider(ProviderClient):
tool_calls=tool_calls,
finish_reason=finish_reason,
reasoning="".join(reasoning_parts) or None,
+ extras=_reasoning_extras(reasoning_field, "".join(reasoning_parts) or None),
usage=usage,
output_limit=_output_limit(kwargs),
effort=self._note_effort(model, plan, kwargs),
diff --git a/tests/test_reasoning_replay.py b/tests/test_reasoning_replay.py
new file mode 100644
index 00000000..d3bb0201
--- /dev/null
+++ b/tests/test_reasoning_replay.py
@@ -0,0 +1,178 @@
+"""OPE-178: reasoning models on the OpenAI-compatible path get their thinking back.
+
+Kimi K3 (Together / Moonshot / OpenRouter), DeepSeek, GLM… return thinking in a message
+field (`reasoning_content`, or `reasoning` via OpenRouter) and — Kimi K3 explicitly —
+require it passed back as-is on later turns. The client keeps what it received in the
+`_openai_compat` sidecar and re-attaches it under the same field name on every request;
+messages that carried no reasoning are byte-identical to before.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+
+import aisuite as ai
+from coworker.engine import TurnEngine
+from coworker.events import EventType
+from coworker.permissions import PermissionEngine
+from coworker.providers import OpenAIProvider
+from coworker.providers.openai_provider import _strip_foreign_sidecars, replay_reasoning
+from coworker.tools import ToolRegistry
+
+
+class _FakeOpenAI:
+ def __init__(self, *, response=None, stream_chunks=None):
+ self.calls: list[dict] = []
+
+ def create(**kwargs):
+ self.calls.append(kwargs)
+ return stream_chunks if kwargs.get("stream") else response
+
+ self.chat = SimpleNamespace(completions=SimpleNamespace(create=create))
+
+
+def _response(**message_fields):
+ message = SimpleNamespace(content="ok", tool_calls=None, **message_fields)
+ return SimpleNamespace(choices=[SimpleNamespace(message=message, finish_reason="stop")], usage=None)
+
+
+def _chunks(field, parts):
+ out = []
+ for p in parts:
+ delta = SimpleNamespace(content=None, tool_calls=None, **{field: p})
+ out.append(SimpleNamespace(choices=[SimpleNamespace(delta=delta, finish_reason=None)], usage=None))
+ out.append(SimpleNamespace(choices=[SimpleNamespace(delta=SimpleNamespace(content="ok", tool_calls=None), finish_reason="stop")], usage=None))
+ return out
+
+
+# -- capture ------------------------------------------------------------------------
+
+
+def test_complete_keeps_reasoning_content_in_the_sidecar():
+ turn = OpenAIProvider(client=_FakeOpenAI(response=_response(reasoning_content="think A"))).complete(
+ model="moonshotai/Kimi-K3", messages=[{"role": "user", "content": "x"}]
+ )
+ assert turn.reasoning == "think A"
+ assert turn.extras == {"_openai_compat": {"field": "reasoning_content", "text": "think A"}}
+
+
+def test_complete_keeps_openrouter_reasoning_field_name():
+ turn = OpenAIProvider(client=_FakeOpenAI(response=_response(reasoning="think B"))).complete(
+ model="moonshotai/kimi-k3", messages=[{"role": "user", "content": "x"}]
+ )
+ assert turn.extras == {"_openai_compat": {"field": "reasoning", "text": "think B"}}
+
+
+def test_stream_joins_deltas_under_the_field_they_arrived_in():
+ provider = OpenAIProvider(client=_FakeOpenAI(stream_chunks=_chunks("reasoning_content", ["th", "ink"])))
+ chunks = list(provider.stream(model="moonshotai/Kimi-K3", messages=[{"role": "user", "content": "x"}]))
+ turn = chunks[-1].turn
+ assert turn.reasoning == "think"
+ assert turn.extras == {"_openai_compat": {"field": "reasoning_content", "text": "think"}}
+ provider = OpenAIProvider(client=_FakeOpenAI(stream_chunks=_chunks("reasoning", ["a", "b"])))
+ turn = list(provider.stream(model="m", messages=[{"role": "user", "content": "x"}]))[-1].turn
+ assert turn.extras["_openai_compat"]["field"] == "reasoning"
+
+
+def test_no_reasoning_means_no_sidecar():
+ turn = OpenAIProvider(client=_FakeOpenAI(response=_response())).complete(
+ model="gpt-5.5", messages=[{"role": "user", "content": "x"}]
+ )
+ assert turn.reasoning is None and turn.extras == {}
+
+
+# -- replay -------------------------------------------------------------------------
+
+
+def _history():
+ return [
+ {"role": "user", "content": "do it"},
+ {
+ "role": "assistant",
+ "content": "",
+ "tool_calls": [{"id": "c1", "type": "function", "function": {"name": "run_shell", "arguments": "{}"}}],
+ "_openai_compat": {"field": "reasoning_content", "text": "plan: run ls"},
+ },
+ {"role": "tool", "tool_call_id": "c1", "content": "file.txt"},
+ {"role": "assistant", "content": "plain reply, no thinking"},
+ {"role": "assistant", "content": "foreign sidecar", "_anthropic": {"blocks": []}},
+ ]
+
+
+def test_replay_reattaches_under_the_original_field_and_strips_sidecars():
+ wire = _strip_foreign_sidecars(replay_reasoning(_history()))
+ assert wire[1]["reasoning_content"] == "plan: run ls"
+ assert wire[1]["tool_calls"][0]["id"] == "c1"
+ assert "_openai_compat" not in wire[1]
+ assert "reasoning_content" not in wire[3] and "reasoning" not in wire[3]
+ assert "_anthropic" not in wire[4] and "reasoning_content" not in wire[4]
+ assert wire[0] == {"role": "user", "content": "do it"}
+
+
+def test_replay_uses_openrouter_field_when_that_is_what_arrived():
+ history = _history()
+ history[1]["_openai_compat"] = {"field": "reasoning", "text": "plan"}
+ wire = _strip_foreign_sidecars(replay_reasoning(history))
+ assert wire[1]["reasoning"] == "plan" and "reasoning_content" not in wire[1]
+
+
+def test_replay_is_a_no_op_without_sidecars():
+ plain = [{"role": "user", "content": "x"}, {"role": "assistant", "content": "y"}]
+ assert replay_reasoning(plain) == plain
+
+
+def test_the_wire_request_carries_the_reasoning_on_the_next_call():
+ fake = _FakeOpenAI(response=_response(reasoning_content="second"))
+ OpenAIProvider(client=fake).complete(model="moonshotai/Kimi-K3", messages=_history())
+ sent = fake.calls[-1]["messages"]
+ assert sent[1]["reasoning_content"] == "plan: run ls"
+ assert all(not k.startswith("_") for m in sent for k in m)
+
+
+# -- engine round trip --------------------------------------------------------------
+
+
+def test_engine_persists_the_sidecar_and_the_provider_gets_it_back(tmp_path):
+ (tmp_path / "a.txt").write_text("hello", encoding="utf-8")
+
+ def _delta(**fields):
+ base = {"content": None, "tool_calls": None}
+ base.update(fields)
+ return SimpleNamespace(choices=[SimpleNamespace(delta=SimpleNamespace(**base), finish_reason=fields.pop("finish", None))], usage=None)
+
+ # The engine streams: turn 1 thinks then calls read_file; turn 2 thinks then answers.
+ call = SimpleNamespace(index=0, id="c1", function=SimpleNamespace(name="read_file", arguments='{"path": "a.txt"}'))
+ first = [
+ _delta(reasoning_content="I should read the file"),
+ SimpleNamespace(choices=[SimpleNamespace(delta=SimpleNamespace(content=None, tool_calls=[call]), finish_reason="tool_calls")], usage=None),
+ ]
+ second = [
+ _delta(reasoning_content="it said hello"),
+ SimpleNamespace(choices=[SimpleNamespace(delta=SimpleNamespace(content="ok", tool_calls=None), finish_reason="stop")], usage=None),
+ ]
+ responses = [first, second]
+ fake = _FakeOpenAI()
+ fake.chat.completions.create = lambda **kwargs: (fake.calls.append(kwargs), responses.pop(0))[1]
+ registry = ToolRegistry()
+ registry.register_all(ai.toolkits.files(root=str(tmp_path), allow_write=True))
+ engine = TurnEngine(
+ provider=OpenAIProvider(client=fake),
+ registry=registry,
+ permissions=PermissionEngine(workspace_root=tmp_path),
+ model="moonshotai/Kimi-K3",
+ )
+
+ async def _collect():
+ return [ev async for ev in engine.run("read a.txt")]
+
+ events = asyncio.run(_collect())
+ assert events[-1].type == EventType.TURN_END and events[-1].data["status"] == "completed"
+ persisted = [m for m in engine.messages if m.get("role") == "assistant"]
+ assert persisted[0]["_openai_compat"] == {"field": "reasoning_content", "text": "I should read the file"}
+ assert persisted[0]["reasoning"] == "I should read the file" # display sidecar still there
+ # The second request carried the first reply's thinking under the original field.
+ second_call = fake.calls[1]["messages"]
+ replayed = [m for m in second_call if m.get("role") == "assistant"]
+ assert replayed[0]["reasoning_content"] == "I should read the file"
+ assert "_openai_compat" not in replayed[0] and "reasoning" not in replayed[0]