fix(claude): preserve Devin answers with late reasoning signatures

docs-site/src/content/docs/guides/claude-code.md

@@ -7,6 +7,13 @@ opencodex serves `POST /v1/messages` (plus `count_tokens`) alongside `/v1/respon
 Code can use every routed provider — OAuth logins, account pools, key failover and sidecars
 included — with zero extra auth work.
 
+On Devin routes (including SWE-2) reached through the Messages API, text and tool calls wait
+for the upstream turn to complete so its late reasoning signature can precede the answer. This prevents Claude Code's final
+result from becoming empty; reasoning and keepalive progress still flow during generation.
+The buffer shares the request's 32 MiB translation limit and cancellation stops the producer.
+This output-order fix does not resolve Cognition's separate refusal of some generated system
+text. It preserves system instructions and safety constraints.
+
 For an Anthropic route on stored OAuth or an Anthropic API key, native Fast is available on
 `claude-opus-5-5`, `claude-opus-5`, and `claude-opus-4-8`: pick the model's `--fast` row (listed
 when Fast rows are enabled) or set `fastMode: true`. Claude Code's own `/fast` toggle is not

scripts/test-layout/layout.json

@@ -2,6 +2,7 @@
   "version": 1,
   "root": "tests",
   "explicit": {
+    "claude-devin-output-order.test.ts": "claude-integration",
     "codex-config-preservation.test.ts": "codex-integration",
     "codex-credits.test.ts": "codex-integration",
     "codex-credits-settings.test.ts": "codex-integration",

src/claude/devin-output-order.ts

@@ -0,0 +1,98 @@
+import type { AdapterEvent } from "../types";
+import {
+  isTranslatorBudgetExceededError,
+  releaseTranslatedEvent,
+  retainTranslatedEvent,
+  type TranslatorBudget,
+} from "../lib/translator-budget";
+
+/**
+ * Cognition signs reasoning after text/tools. Claude Code treats a trailing empty
+ * thinking block as its final result, so Messages needs reasoning before content.
+ * Consume after raw-event preflight and drain on demand, avoiding a queue burst.
+ */
+export async function* orderDevinMessagesOutput(
+  source: AsyncIterable<AdapterEvent>,
+  budget: TranslatorBudget,
+  signal: AbortSignal,
+  abortProducer: () => void,
+): AsyncGenerator<AdapterEvent> {
+  const held: Array<AdapterEvent | undefined> = [];
+  let cancelled = signal.aborted;
+  let terminalDelivered = false;
+  let delivering: AdapterEvent | undefined;
+  const release = () => {
+    for (const event of held) if (event) releaseTranslatedEvent(event, budget);
+    held.length = 0;
+    if (delivering) releaseTranslatedEvent(delivering, budget);
+  };
+  const cancel = () => { cancelled = true; release(); };
+  signal.addEventListener("abort", cancel, { once: true });
+  const cancelledTerminal = (event: AdapterEvent): AdapterEvent => {
+    if (event.type !== "done" && event.type !== "incomplete") return event;
+    return { type: "error", status: 499, message: "client closed request", retryable: false,
+      ...(event.usage ? { usage: event.usage } : {}) };
+  };
+  async function* drain() {
+    for (let index = 0; index < held.length && !cancelled; index++) {
+      delivering = held[index];
+      held[index] = undefined;
+      try {
+        if (delivering) {
+          terminalDelivered = delivering.type === "done" || delivering.type === "error" || delivering.type === "incomplete";
+          yield delivering;
+        }
+      }
+      finally {
+        if (delivering) releaseTranslatedEvent(delivering, budget);
+        delivering = undefined;
+      }
+    }
+    held.length = 0;
+  }
+  try {
+    for await (const event of source) {
+      const terminal = event.type === "done" || event.type === "error" || event.type === "incomplete";
+      if (cancelled) {
+        // The adapter's cancellation terminal retains its measured usage. Client
+        // stream cancellation instead returns this iterator and stops consumption.
+        if (terminal) { yield cancelledTerminal(event); return; }
+        continue;
+      }
+      if (event.type === "heartbeat" || event.type === "thinking_delta"
+        || event.type === "thinking_signature" || event.type === "redacted_thinking"
+        || event.type === "reasoning_raw_delta" || event.type === "kiro_redacted_reasoning") {
+        yield event;
+        continue;
+      }
+      // Retention owns a snapshot, including nested usage, so later producer or
+      // consumer mutations cannot change the bytes measured by the budget.
+      const copy = structuredClone(event);
+      try {
+        retainTranslatedEvent(copy, budget, held.at(-1));
+        held.push(copy);
+      } catch (error) {
+        if (!isTranslatorBudgetExceededError(error)) throw error;
+        release();
+        // Stop only the producer: aborting the request signal here would let the
+        // hosted-search loop replace the typed overflow with a client-cancel error.
+        abortProducer();
+        yield { type: "error", status: 413, errorType: "request_too_large",
+          code: "translation_buffer_limit", message: error.message };
+        return;
+      }
+      if (terminal) {
+        yield* drain();
+        if (cancelled && !terminalDelivered) yield cancelledTerminal(event);
+        return;
+      }
+      // Raw preflight already observed real output; feed the stream watchdog while
+      // the answer waits for its signature. Original heartbeats stay verbatim.
+      yield { type: "heartbeat" };
+    }
+    if (!cancelled) yield* drain();
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    release();
+  }
+}

src/server/responses/run-turn-execution.ts

@@ -50,6 +50,7 @@ import { undeclaredToolCallMessage } from "../responses-undeclared-tool-guard";
 import { planWebSearch } from "../../web-search";
 import { runTurnWebSearchInitialParsed, runTurnWebSearchLoop } from "../../web-search/run-turn-loop";
 import { WEB_SEARCH_TOOL_NAME } from "../../web-search/synthetic-tool";
+import { orderDevinMessagesOutput } from "../../claude/devin-output-order";
 
 // LOCAL PATCH (runturn-websearch): top-level fields route binding or the
 // adapter itself may write during a turn. Iteration-local `turnParsed` objects
@@ -181,6 +182,13 @@ export async function executeResponsesRunTurn(
 
     const runTurnAbort = new AbortController();
     const cleanupRunTurnAbort = linkAbortSignal(runTurnAbort, options.abortSignal);
+    const devinProducers = new Set<AbortController>();
+    const orderMessagesOutput = (source: AsyncIterable<AdapterEvent>): AsyncIterable<AdapterEvent> =>
+      inboundWire === "anthropic" && transportState.runTurnAdapter.name === "devin" && !routedCompaction
+        ? orderDevinMessagesOutput(source, translatorBudget, runTurnAbort.signal, () => {
+            for (const producer of devinProducers) producer.abort();
+          })
+        : source;
     const queue = createAdapterEventQueue({
       onBacklogExceeded: () => runTurnAbort.abort(),
     });
@@ -229,6 +237,8 @@ export async function executeResponsesRunTurn(
         options.onCompactionRecoveryAdapterEvent?.(event);
         targetQueue.push(event);
       };
+      let producerAbort = runTurnAbort;
+      let cleanupProducerAbort: (() => void) | undefined;
       try {
         if (!pacingSlotAcquired) {
           pacingSlot = await waitForProviderRequestSlot(route.providerName, route.provider, route.modelId, runTurnAbort.signal);
@@ -261,11 +271,16 @@ export async function executeResponsesRunTurn(
             turnScopedPacing: true,
           },
         );
+        if (inboundWire === "anthropic" && transportState.runTurnAdapter.name === "devin" && !routedCompaction) {
+          producerAbort = new AbortController();
+          cleanupProducerAbort = linkAbortSignal(producerAbort, runTurnAbort.signal);
+          devinProducers.add(producerAbort);
+        }
         await transportState.runTurnAdapter.runTurn?.(
           turnParsed,
           {
             headers: requestState.selectedForwardHeaders,
-            abortSignal: runTurnAbort.signal,
+            abortSignal: producerAbort.signal,
             comboAttempt: options.comboAttempt === true,
             translatorBudget,
             providerFetch: runTurnProviderFetch,
@@ -321,6 +336,8 @@ export async function executeResponsesRunTurn(
                 message: err instanceof Error ? err.message : String(err),
               });
       } finally {
+        devinProducers.delete(producerAbort);
+        cleanupProducerAbort?.();
         releaseProviderRequestSlot(pacingSlot);
         // Cursor assigns a stable conversation id inside runTurn on the first headerless
         // turn; backfill so Logs can filter/total that opening request (#330 / #522).
@@ -345,14 +362,14 @@ export async function executeResponsesRunTurn(
       });
       void runTurnAttempt(iterQueue, undefined, false, iterParsed);
       const stream = iterQueue.stream();
-      if (!runTurnFailoverArmed()) return stream;
+      if (!runTurnFailoverArmed()) return orderMessagesOutput(stream);
       // LOCAL PATCH (runturn-websearch): a post-search iteration can open on a
       // 429 too — the search cells already reached the client, so only this
       // answer call rotates. Preflight replays it on the next account with the
       // grown history intact; a mid-stream error still ends the turn as before.
-      return (async function* () {
+      return orderMessagesOutput((async function* () {
         yield* await preflightRunTurnFailover(stream, iterParsed);
-      })();
+      })());
     };
     // Rebind the turn to an admitted account. The failed attempt emitted no client-visible bytes,
     // so replay is safe, but a Cursor conversation/checkpoint is credential-scoped: carrying its
@@ -614,7 +631,7 @@ export async function executeResponsesRunTurn(
         onBacklogExceeded: () => runTurnAbort.abort(),
       });
       void runTurnAttempt(retryQueue, "empty-completion");
-      return retryQueue.stream();
+      return orderMessagesOutput(retryQueue.stream());
     };
 
     const { toolNsMap, declaredToolNames, toolParameterSchemas, freeformToolNames, bareCustomToolNames, toolSearchToolNames } = toolBridgeMaps;
@@ -651,6 +668,7 @@ export async function executeResponsesRunTurn(
         retryAfter: resolveClientRetryAfter({ status: httpStatus, message: error.message }),
       });
     };
+    // Messages ingress forces internal streaming, including buffered client requests.
     if (parsed.stream) {
       try {
       void runTurn();
@@ -699,6 +717,8 @@ export async function executeResponsesRunTurn(
         }
         eventSource = preflight.stream;
       }
+      // Preflight sees raw output before Messages delays text for the late signature.
+      eventSource = orderMessagesOutput(eventSource);
       // LOCAL PATCH (runturn-websearch): intercept web_search calls across
       // iterations; terminal output keeps flowing through the same queue/bridge.
       if (wsPlan) {

structure/clients/claude-desktop.md

@@ -29,6 +29,29 @@ Native OpenAI pool routing also accepts
 [Orca-linked accounts](../codex-home.md#orca-source-owned-account-import), whose source resolution
 belongs to the shared account store. The import CLI adds pool rows independently of Desktop profiles.
 
+## Devin Messages output ordering
+
+`src/claude/devin-output-order.ts` orders each physical Devin turn after raw-event preflight in
+`src/server/responses/run-turn-execution.ts` when the original inbound wire is Anthropic
+Messages. Provider names may be customized; the selected adapter determines applicability.
+Text and tool events wait for that turn's terminal so Cognition's late reasoning signature
+precedes them. Claude Code therefore receives a final text or tool block rather than an empty
+signature-only thinking block. Reasoning and transport progress remain live; answer text and
+tool dispatch incur turn-completion latency. Responses and Chat retain their original ordering,
+and routed compaction is excluded.
+
+Retained events own deep snapshots, including nested usage, so producer/consumer mutations
+cannot alter their measured payload. They share the request translator budget and drain on demand without a synchronous
+burst into the adapter queue. They are released on terminal, cancellation, overflow, or adapter
+EOF. Overflow emits one typed `translation_buffer_limit` error and aborts only active Devin
+producers, preserving error classification through hosted search. Cancellation drops held
+semantic output; this consumer preserves error terminals and maps cancelled success/incomplete
+terminals to a 499 with their original usage, so partial output cannot commit completed replay
+state. Hosted search retains its existing independent cancellation mapping.
+Adapter error and incomplete terminals retain partial output and their original usage.
+Ordering occurs before hosted-search interception, independently for each physical iteration,
+so one iteration's signature cannot be attached to another iteration's answer.
+
 ## Desktop modes: gateway and first-party
 
 `src/claude/desktop-first-party.ts` owns the Desktop mode contract. Two modes exist and are

structure/providers-and-adapters.md

@@ -1,7 +1,7 @@
 # Providers And Adapters
 
 Anthropic account pause, model routes, and quota labels follow the
-[Anthropic account-pool contract](providers/anthropic-account-pool.md).
+[Anthropic account-pool contract](providers/anthropic-account-pool.md). Devin Messages follows the [per-turn output ordering contract](clients/claude-desktop.md#devin-messages-output-ordering), preserving late signatures before text/tools without changing Responses or Chat ordering.
 
 Per-account usage thresholds follow the [Anthropic account thresholds contract](providers/anthropic-account-thresholds.md).
 An Anthropic 429 records the served account's cooldown even when the request has used its allowed retry sends. That final account remains excluded on the next request; combo target cooling is skipped only after the matching account cooldown is present.

structure/transports/byte-accounting.md

@@ -56,6 +56,10 @@ lifecycle, cancellation races, protocol envelopes, and the real HTTP admission b
 
 ## Stream-buffer accounting
 
+Devin's [Messages ordering buffer](../clients/claude-desktop.md#devin-messages-output-ordering) charges retained
+semantic events consumed from the independently bounded adapter queue to the shared translator
+budget until downstream delivery. Cancellation and overflow release held events before producer shutdown.
+
 `src/web-search/run-turn-loop.ts` charges retained iteration events and generated replay history to
 the request translator budget. Each owner releases its own reservations on completion, error,
 cancellation or consumer closure; a buffer-limit failure terminates without another search.