fix(web-search): carry raw reasoning into the replayed web_search turn

Closes #688.

DeepSeek V4 thinking mode requires the assistant reasoning that preceded a tool
call to come back with it. extractIterationThinking() only accumulated
thinking_delta, so for OpenAI-compatible providers — which emit
reasoning_raw_delta instead (openai-chat.ts:743) — it returned null and the
replayed turn went upstream as a bare tool call. DeepSeek rejected it with a
400; that surfaced downstream as a 502 only because the loop drops
LoopError.status once the SSE is already open (loop.ts:564), so the reported
symptom and the real upstream status differ. The status-mapping gap is left
alone here: a successful replay never reaches it.

The serializer side already worked — openai-chat.ts:185 emits reasoning_content
from thinking parts for models in preserveReasoningContentModels, and DeepSeek
V4 is registered. It was simply never handed any part.

Raw reasoning becomes a SEPARATE UNSIGNED part rather than joining the signed
block. A signature authenticates the exact text it closed, so appending raw text
to it would invalidate the pairing and, worse, dress unrelated chain-of-thought
as an authenticated provider block. Unsigned parts are skipped by the anthropic
serializer and serialized by openai-chat, so both contracts hold at once.

The extractor also ports the per-block flush from src/images/loop.ts: the old
single-signature accumulator collapsed `thinking(a), sig1, thinking(b), sig2`
into "ab" under sig2, which is the exact 400-on-replay bug that file already
guards against. Redacted blocks now keep their stream position instead of being
aggregated ahead of all visible thinking.

Three regression tests: the replay shape for a raw-only stream (asserting the
part carries no signature), exact part order and per-block signatures for a
mixed redacted/signed/raw stream, and a real createOpenAIChatAdapter test that
reads the second routed request body to prove reasoning_content actually lands
beside tool_calls. The last one matters because the shape tests would pass while
the wire contract regressed.

Author: lidge-jun

src/web-search/loop.ts

@@ -103,23 +103,63 @@ async function* replay(events: AdapterEvent[]): AsyncGenerator<AdapterEvent> {
  * replaying a bare toolCall 400s ("Expected `thinking` or `redacted_thinking`, but found
  * `tool_use`"). The signature validity gate stays in the anthropic adapter; other adapters
  * ignore or serialize the part harmlessly.
+ *
+ * Each signed block keeps its OWN signature and text, mirroring src/images/loop.ts: a signature
+ * authenticates the exact block it closed, so flattening two blocks under the last signature
+ * 400s on replay just as it does there.
+ *
+ * Raw reasoning (`reasoning_raw_delta`, what OpenAI-compatible providers emit instead of signed
+ * thinking) accumulates into a SEPARATE UNSIGNED part. It must never join a signed block: the
+ * anthropic serializer skips signature-less parts, while openai-chat serializes their text as
+ * `reasoning_content` — which DeepSeek V4 thinking mode requires back alongside the replayed
+ * tool_calls, and whose absence ended the turn as a provider 400 (issue #688).
+ *
+ * This assumes raw reasoning never interleaves INSIDE an unfinished signed block: Anthropic-family
+ * adapters emit thinking_delta/signature and OpenAI-compatible ones emit reasoning_raw_delta, and
+ * the two never share a stream. Honoring a genuinely mixed stream would need per-segment state,
+ * not another accumulator.
  */
-function extractIterationThinking(events: AdapterEvent[]): OcxThinkingContent | null {
+function extractIterationThinking(events: AdapterEvent[]): OcxThinkingContent[] {
+  const parts: OcxThinkingContent[] = [];
   let thinking = "";
   let signature: string | undefined;
-  const redacted: string[] = [];
+  let rawReasoning = "";
+
+  const flushVisible = () => {
+    if (!thinking && !signature) return;
+    parts.push({
+      type: "thinking",
+      thinking,
+      ...(signature ? { signature } : {}),
+    });
+    thinking = "";
+    signature = undefined;
+  };
+  const flushRaw = () => {
+    if (!rawReasoning) return;
+    parts.push({ type: "thinking", thinking: rawReasoning });
+    rawReasoning = "";
+  };
+
   for (const e of events) {
-    if (e.type === "thinking_delta") thinking += e.thinking;
-    else if (e.type === "thinking_signature") signature = e.signature;
-    else if (e.type === "redacted_thinking") redacted.push(e.data);
+    if (e.type === "thinking_delta") {
+      flushRaw();
+      thinking += e.thinking;
+    } else if (e.type === "reasoning_raw_delta") {
+      flushVisible();
+      rawReasoning += e.text;
+    } else if (e.type === "thinking_signature") {
+      signature = e.signature;
+      flushVisible();
+    } else if (e.type === "redacted_thinking") {
+      flushVisible();
+      flushRaw();
+      parts.push({ type: "thinking", thinking: "", redacted: [e.data] });
+    }
   }
-  if (!thinking && !signature && redacted.length === 0) return null;
-  return {
-    type: "thinking",
-    thinking,
-    ...(signature ? { signature } : {}),
-    ...(redacted.length > 0 ? { redacted } : {}),
-  };
+  flushVisible();
+  flushRaw();
+  return parts;
 }
 
 /** Normalize a query for failed-query de-duplication (case/whitespace-insensitive). */
@@ -406,7 +446,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
   // valid, and surface as ONE search cell carrying every attempted query. A real search (one that
   // hits the sidecar) shows the spinner WHILE the batch runs. Empty/limit/repeat placeholders never
   // emit a cell (matching the prior single-query behavior).
-  async function* runSearchCall(call: WebSearchCall, precedingThinking?: OcxThinkingContent | null): AsyncGenerator<AdapterEvent> {
+  async function* runSearchCall(call: WebSearchCall, precedingThinking: OcxThinkingContent[] = []): AsyncGenerator<AdapterEvent> {
     const results: { query: string; outcome: SidecarOutcome }[] = [];
     let beganCell = false;
     if (call.queries.length === 0) {
@@ -465,8 +505,9 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     messages.push({
       role: "assistant",
       content: [
-        // Signed thinking must precede tool_use on replay (Anthropic extended thinking).
-        ...(precedingThinking ? [precedingThinking] : []),
+        // Signed thinking must precede tool_use on replay (Anthropic extended thinking), and
+        // unsigned raw reasoning has to ride along for providers that require it back (#688).
+        ...precedingThinking,
         { type: "toolCall" as const, id: call.id, name: WEB_SEARCH_TOOL_NAME, arguments: callArgs },
       ],
       timestamp: now,
@@ -559,7 +600,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
           // The thinking that led to the search belongs to the FIRST call's assistant replay turn.
           const iterationThinking = extractIterationThinking(split.passthrough);
           for (const [callIndex, call] of split.calls.entries()) {
-            yield* runSearchCall(call, callIndex === 0 ? iterationThinking : null);
+            yield* runSearchCall(call, callIndex === 0 ? iterationThinking : []);
           }
         } catch (e) {
           yield { type: "error", message: e instanceof LoopError ? e.message : (e instanceof Error ? e.message : String(e)) };

tests/web-search.test.ts

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { parseRequest } from "../src/responses/parser";
 import { planWebSearch, shouldResolveOpenAiWebSearchSidecar, webSearchStallTimeoutSec } from "../src/web-search";
 import { runWithWebSearch } from "../src/web-search/loop";
+import { createOpenAIChatAdapter } from "../src/adapters/openai-chat";
 import { headersForCodexAuthContext } from "../src/codex/auth-context";
 import { listOpenAiForwardSidecarCandidates, resolveFirstUsableOpenAiSidecar } from "../src/providers/openai-sidecar";
 import type { AdapterEvent, OcxConfig, OcxProviderConfig } from "../src/types";
@@ -759,6 +760,203 @@ describe("web-search sidecar native web_search_call emission", () => {
     expect(content[1].type).toBe("toolCall");
   });
 
+  // #688: DeepSeek V4 and other OpenAI-compatible providers emit reasoning_raw_delta rather than
+  // signed thinking. Dropping it left the replayed turn as a bare tool call, which the provider
+  // rejected — surfacing downstream as a 502 because the loop drops the LoopError status.
+  test("raw reasoning before a web_search call is replayed as an unsigned thinking part", async () => {
+    globalThis.fetch = ((input) => {
+      const url = String(input);
+      if (url.startsWith("https://routed.test/")) return Promise.resolve(new Response("{}", { status: 200 }));
+      return Promise.resolve(new Response(
+        'event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"docs say X"}\n\n' +
+          'event: response.completed\ndata: {"type":"response.completed"}\n\n',
+        { headers: { "Content-Type": "text/event-stream" } },
+      ));
+    }) as typeof fetch;
+
+    const seenBodies: OcxMessage[][] = [];
+    let pass = 0;
+    const adapter: ProviderAdapter = {
+      name: "mock",
+      buildRequest: (p: OcxParsedRequest) => {
+        seenBodies.push(p.context.messages);
+        return { url: "https://routed.test/v1/chat/completions", method: "POST", headers: {}, body: "{}" };
+      },
+      async *parseStream() {
+        pass++;
+        if (pass === 1) {
+          const events: AdapterEvent[] = [
+            { type: "reasoning_raw_delta", text: "I should " },
+            { type: "reasoning_raw_delta", text: "search the docs" },
+            { type: "tool_call_start", id: "call_raw", name: "web_search" },
+            { type: "tool_call_delta", arguments: JSON.stringify({ query: "docs" }) },
+            { type: "tool_call_end" },
+            { type: "done" },
+          ];
+          for (const event of events) yield event;
+          return;
+        }
+        yield { type: "text_delta", text: "final" };
+        yield { type: "done" };
+      },
+      async parseResponse() { throw new Error("parseResponse must be unreachable"); },
+    };
+
+    const response = await runWithWebSearch({
+      parsed: parseRequest({ model: "routed/model", input: "look up docs", stream: true, tools: [{ type: "web_search" }] }),
+      adapter,
+      forwardProvider,
+      hostedTool: { type: "web_search" },
+      selectedForwardHeaders: new Headers({ authorization: "Bearer token" }),
+      settings: { model: "gpt-5.4-mini", reasoning: "low", timeoutMs: 30_000 },
+      maxSearches: 2,
+    });
+    await collectSse(response.body!);
+
+    // Locate the replayed turn by its tool-call id so unrelated history cannot satisfy this.
+    const replayMessages = seenBodies.at(-1)!;
+    const assistant = replayMessages.find(m => m.role === "assistant"
+      && Array.isArray(m.content)
+      && (m.content as { type: string; id?: string }[]).some(c => c.type === "toolCall" && c.id === "call_raw"));
+    expect(assistant).toBeDefined();
+    const content = assistant!.content as { type: string; thinking?: string; signature?: string }[];
+    expect(content[0].type).toBe("thinking");
+    expect(content[0].thinking).toBe("I should search the docs");
+    // Raw reasoning is NOT signed: presenting it as signed would corrupt the Anthropic contract.
+    expect(content[0].signature).toBeUndefined();
+    expect(content[1].type).toBe("toolCall");
+  });
+
+  // A signature authenticates the exact block it closed, so each block must keep its own pairing.
+  // Flattening two blocks under the last signature is what src/images/loop.ts already guards.
+  test("multiple signed thinking blocks keep their own signatures across a web_search replay", async () => {
+    globalThis.fetch = ((input) => {
+      const url = String(input);
+      if (url.startsWith("https://routed.test/")) return Promise.resolve(new Response("{}", { status: 200 }));
+      return Promise.resolve(new Response(
+        'event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"docs say X"}\n\n' +
+          'event: response.completed\ndata: {"type":"response.completed"}\n\n',
+        { headers: { "Content-Type": "text/event-stream" } },
+      ));
+    }) as typeof fetch;
+
+    const seenBodies: OcxMessage[][] = [];
+    let pass = 0;
+    const adapter: ProviderAdapter = {
+      name: "mock",
+      buildRequest: (p: OcxParsedRequest) => {
+        seenBodies.push(p.context.messages);
+        return { url: "https://routed.test/v1/chat/completions", method: "POST", headers: {}, body: "{}" };
+      },
+      async *parseStream() {
+        pass++;
+        if (pass === 1) {
+          const events: AdapterEvent[] = [
+            { type: "redacted_thinking", data: "d1" },
+            { type: "thinking_delta", thinking: "first" },
+            { type: "thinking_signature", signature: "RealSigAAAAAAAAAA==" },
+            { type: "thinking_delta", thinking: "second" },
+            { type: "thinking_signature", signature: "RealSigBBBBBBBBBB==" },
+            { type: "reasoning_raw_delta", text: "raw" },
+            { type: "tool_call_start", id: "call_multi", name: "web_search" },
+            { type: "tool_call_delta", arguments: JSON.stringify({ query: "docs" }) },
+            { type: "tool_call_end" },
+            { type: "done" },
+          ];
+          for (const event of events) yield event;
+          return;
+        }
+        yield { type: "text_delta", text: "final" };
+        yield { type: "done" };
+      },
+      async parseResponse() { throw new Error("parseResponse must be unreachable"); },
+    };
+
+    const response = await runWithWebSearch({
+      parsed: parseRequest({ model: "routed/model", input: "look up docs", stream: true, tools: [{ type: "web_search" }] }),
+      adapter,
+      forwardProvider,
+      hostedTool: { type: "web_search" },
+      selectedForwardHeaders: new Headers({ authorization: "Bearer token" }),
+      settings: { model: "gpt-5.4-mini", reasoning: "low", timeoutMs: 30_000 },
+      maxSearches: 2,
+    });
+    await collectSse(response.body!);
+
+    const replayMessages = seenBodies.at(-1)!;
+    const assistant = replayMessages.find(m => m.role === "assistant"
+      && Array.isArray(m.content)
+      && (m.content as { type: string; id?: string }[]).some(c => c.type === "toolCall" && c.id === "call_multi"));
+    expect(assistant).toBeDefined();
+    const content = assistant!.content as { type: string; thinking?: string; signature?: string; redacted?: string[] }[];
+    expect(content).toHaveLength(5);
+    expect(content[0]).toEqual({ type: "thinking", thinking: "", redacted: ["d1"] });
+    expect(content[1]).toEqual({ type: "thinking", thinking: "first", signature: "RealSigAAAAAAAAAA==" });
+    expect(content[2]).toEqual({ type: "thinking", thinking: "second", signature: "RealSigBBBBBBBBBB==" });
+    expect(content[3]).toEqual({ type: "thinking", thinking: "raw" });
+    expect(content[4].type).toBe("toolCall");
+  });
+
+  // The user-visible failure lives at the SERIALIZER boundary: openai-chat only emits
+  // reasoning_content for models in preserveReasoningContentModels, and only from thinking parts.
+  // The mock-adapter tests above prove the replay SHAPE; this one proves the wire contract, so a
+  // regression that drops reasoning_content on the second request cannot pass unnoticed.
+  test("a reasoning_content provider receives raw reasoning beside the replayed tool_calls", async () => {
+    const routedBodies: Record<string, unknown>[] = [];
+    let routedPass = 0;
+    globalThis.fetch = ((input, init?: RequestInit) => {
+      const url = String(input);
+      if (url.startsWith("https://routed.test/")) {
+        routedBodies.push(JSON.parse(String(init?.body ?? "{}")) as Record<string, unknown>);
+        routedPass++;
+        const sse = routedPass === 1
+          ? 'data: {"choices":[{"delta":{"reasoning_content":"I should search the docs"}}]}\n\n'
+            + 'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_ds","type":"function","function":{"name":"web_search","arguments":"{\\"query\\":\\"docs\\"}"}}]}}]}\n\n'
+            + 'data: {"choices":[{"delta":{},"finish_reason":"tool_calls"}]}\n\n'
+            + "data: [DONE]\n\n"
+          : 'data: {"choices":[{"delta":{"content":"final"}}]}\n\n'
+            + 'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n'
+            + "data: [DONE]\n\n";
+        return Promise.resolve(new Response(sse, { headers: { "Content-Type": "text/event-stream" } }));
+      }
+      return Promise.resolve(new Response(
+        'event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"docs say X"}\n\n' +
+          'event: response.completed\ndata: {"type":"response.completed"}\n\n',
+        { headers: { "Content-Type": "text/event-stream" } },
+      ));
+    }) as typeof fetch;
+
+    // modelInList matches EXACTLY, so the provider list and the request model must agree verbatim.
+    const deepseekProvider: OcxProviderConfig = {
+      adapter: "openai-chat",
+      baseUrl: "https://routed.test/v1",
+      apiKey: "routed-key",
+      preserveReasoningContentModels: ["deepseek-v4-flash"],
+    };
+
+    const response = await runWithWebSearch({
+      parsed: parseRequest({ model: "deepseek-v4-flash", input: "look up docs", stream: true, tools: [{ type: "web_search" }] }),
+      adapter: createOpenAIChatAdapter(deepseekProvider),
+      forwardProvider,
+      hostedTool: { type: "web_search" },
+      selectedForwardHeaders: new Headers({ authorization: "Bearer token" }),
+      settings: { model: "gpt-5.4-mini", reasoning: "low", timeoutMs: 30_000 },
+      maxSearches: 2,
+    });
+    await collectSse(response.body!);
+
+    expect(routedBodies).toHaveLength(2);
+    const replay = routedBodies[1]!.messages as {
+      role: string; content?: unknown; reasoning_content?: string;
+      tool_calls?: { id: string; function: { name: string } }[];
+    }[];
+    const assistant = replay.find(m => m.role === "assistant" && m.tool_calls?.some(tc => tc.id === "call_ds"));
+    expect(assistant).toBeDefined();
+    expect(assistant!.reasoning_content).toBe("I should search the docs");
+    expect(assistant!.tool_calls).toHaveLength(1);
+    expect(assistant!.tool_calls![0]!.function.name).toBe("web_search");
+  });
+
   test("an executed search emits a web_search_call item ahead of the assistant message", async () => {
     globalThis.fetch = ((input) => {
       const url = String(input);