@bitkyc08/opencodex 2.90.0 → 2.92.0

package/src/adapters/openai-responses/request-strips.ts

@@ -24,6 +24,66 @@ export function stripProviderInputItemMetadata(body: unknown): unknown {
     input ??= [...body.input];
     input[index] = next;
   }
+  return repairUrlCitationAnnotations(input ? { ...body, input } : body);
+}
+
+function isUrlCitationIndex(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+/** Coerce a replayed citation index to a non-negative safe integer, falling back to 0. */
+function repairUrlCitationIndex(value: unknown): number {
+  if (isUrlCitationIndex(value)) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    const index = Number(value);
+    if (isUrlCitationIndex(index)) return index;
+  }
+  return 0;
+}
+
+/**
+ * OpenAI Responses requires `title` (string) and integer `start_index`/`end_index` on every
+ * `url_citation` annotation of a replayed `output_text` part. History written by an older bridge
+ * (title omitted when the search source had none) or a lossy client otherwise fails every later
+ * request carrying it, most visibly remote compaction, with a deterministic HTTP 400
+ * (`Missing required parameter: input[N].content[M].annotations[K].title`).
+ * Repair only those fields on `url_citation` annotations of assistant message content; other
+ * annotation types, unknown keys and every other item are untouched. Copy on write: an already
+ * valid body is returned by reference.
+ */
+export function repairUrlCitationAnnotations(body: unknown): unknown {
+  if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
+  let input: unknown[] | undefined;
+  for (let itemIndex = 0; itemIndex < body.input.length; itemIndex += 1) {
+    const item = body.input[itemIndex];
+    if (!isPlainObject(item) || !Array.isArray(item.content)) continue;
+    let content: unknown[] | undefined;
+    for (let partIndex = 0; partIndex < item.content.length; partIndex += 1) {
+      const part = item.content[partIndex];
+      if (!isPlainObject(part) || part.type !== "output_text" || !Array.isArray(part.annotations)) continue;
+      let annotations: unknown[] | undefined;
+      for (let annIndex = 0; annIndex < part.annotations.length; annIndex += 1) {
+        const ann = part.annotations[annIndex];
+        if (!isPlainObject(ann) || ann.type !== "url_citation") continue;
+        const titleOk = typeof ann.title === "string";
+        const startOk = isUrlCitationIndex(ann.start_index);
+        const endOk = isUrlCitationIndex(ann.end_index);
+        if (titleOk && startOk && endOk) continue;
+        const next: Record<string, unknown> = { ...ann };
+        if (!titleOk) next.title = typeof ann.url === "string" ? ann.url : "";
+        if (!startOk) next.start_index = repairUrlCitationIndex(ann.start_index);
+        if (!endOk) next.end_index = repairUrlCitationIndex(ann.end_index);
+        annotations ??= [...part.annotations];
+        annotations[annIndex] = next;
+      }
+      if (!annotations) continue;
+      content ??= [...item.content];
+      content[partIndex] = { ...part, annotations };
+    }
+    if (!content) continue;
+    input ??= [...body.input];
+    input[itemIndex] = { ...item, content };
+  }
   return input ? { ...body, input } : body;
 }
 
@@ -187,6 +247,38 @@ export function stripCanonicalOnlyTopLevelFields(body: unknown): unknown {
   return next;
 }
 
+/**
+ * OpenAI-private input item TYPES, the item-level sibling of the two tables above.
+ *
+ * Each one is a positional control the OpenAI Responses backend interprets where it sits in
+ * history, never a turn of the conversation, so dropping it leaves every message, call and output
+ * in place. Codex gates sending one on its own `is_openai` provider check, which loopback
+ * injection always satisfies, so a gateway this proxy does not operate can still receive one and
+ * reject the whole body as an unknown item type.
+ *
+ * Same rule as the top-level table: only types a client is OBSERVED to send.
+ */
+const CANONICAL_ONLY_INPUT_ITEM_TYPES: ReadonlySet<string> = new Set([
+  // Codex 0.164 `ResponseItem::ConfigurationUpdate` ({type, reasoning: {effort}}): a durable
+  // reasoning-effort change recorded at its position in history. codex-rs sends it only for a
+  // catalog row with `supports_reasoning_effort_updates`, and keeps it in saved history after a
+  // model switch. Mapping the effort onto another provider is out of scope (#6895).
+  "configuration_update",
+]);
+
+/**
+ * Remove OpenAI-private input items. The caller decides the boundary, exactly as for
+ * {@link stripCanonicalOnlyTopLevelFields}; the canonical and OpenAI-operated destinations keep
+ * the items verbatim and in order. Returns the input unchanged when none is present.
+ */
+export function stripCanonicalOnlyInputItems(body: unknown): unknown {
+  if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
+  const isPrivate = (item: unknown): boolean => isPlainObject(item)
+    && typeof item.type === "string" && CANONICAL_ONLY_INPUT_ITEM_TYPES.has(item.type);
+  if (!body.input.some(isPrivate)) return body;
+  return { ...body, input: body.input.filter(item => !isPrivate(item)) };
+}
+
 /**
  * Sampling fields a model on the provider's `noStopModels` / `noPenaltyModels` list rejects on
  * every wire. Claude inbound translates `stop_sequences` into a Responses `stop`

package/src/adapters/openai-responses/transport.ts

@@ -3,6 +3,7 @@ import type { OcxProviderConfig } from "../../types";
 import { CODEX_RESPONSES_LITE_HEADER } from "../../codex/forward-transport-headers";
 import { CODEX_FORWARD_BASE_URL, isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers-destination";
 import { normalizeForwardedClientHeaderName } from "../../lib/provider-client-headers";
+import { AGENT_ASSERTION_HEADER } from "../../lib/authorization-scheme";
 import { openaiResponsesUrl } from "../openai-responses-url";
 
 // Caller credentials are forwarded only to the canonical Codex destination, never by capability.
@@ -69,6 +70,11 @@ export function buildResponsesTransport(provider: OcxProviderConfig, incoming: P
     if (override && mayForwardCallerCredentials) {
       headers.authorization = `Bearer ${override.accessToken}`;
       headers["chatgpt-account-id"] = override.chatgptAccountId;
+    } else if (mayForwardCallerCredentials) {
+      // dual_header runtime assertion: first-party Direct only, beside the caller's own Bearer.
+      // A pool override above never carries it, and non-canonical transports never see it.
+      const assertion = incoming.headers.get(AGENT_ASSERTION_HEADER);
+      if (assertion) headers[AGENT_ASSERTION_HEADER] = assertion;
     }
   } else {
     url = provider.responsesPath === undefined

package/src/adapters/registry.ts

@@ -1,4 +1,5 @@
 import { createAnthropicAdapter } from "./anthropic";
+import { createWorkBuddyAdapter } from "./workbuddy";
 import { createDshAccountAdapter } from "./dsh-account";
 import { createAzureAdapter } from "./azure";
 import type { ProviderAdapter } from "./base";
@@ -74,6 +75,10 @@ type InheritedAdapterDefinition = {
 type AdapterDefinition = DirectAdapterDefinition | InheritedAdapterDefinition;
 
 export const ADAPTER_REGISTRY = {
+  "workbuddy-ai": {
+    contractParent: "openai-chat",
+    create: (provider: OcxProviderConfig) => withUniqueToolCallIds(createWorkBuddyAdapter(provider)),
+  },
   codebuddy: {
     wire: "codebuddy",
     mutation: "codex-owned",

package/src/adapters/workbuddy-schema.ts

@@ -0,0 +1,61 @@
+const schemaMaps = new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
+const schemaLists = new Set(["anyOf", "oneOf", "allOf", "prefixItems"]);
+const schemaValues = new Set(["items", "additionalProperties", "unevaluatedProperties", "contains", "not", "if", "then", "else", "propertyNames"]);
+const jsonTypes = new Set(["string", "number", "integer", "boolean", "object", "array", "null"]);
+
+/** Normalize schemas only; defaults, examples and property names are data, never schemas. */
+export function workBuddySchema(value: unknown, depth = 0): Record<string, unknown> {
+  if (depth > 64) throw new Error("WorkBuddy AI tool schema exceeds maximum depth");
+  if (value === false) return { not: {} };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const input = value as Record<string, unknown>, out = { ...input };
+  for (const [key, child] of Object.entries(input)) {
+    if (schemaMaps.has(key) && child && typeof child === "object" && !Array.isArray(child)) {
+      out[key] = Object.fromEntries(Object.entries(child).map(([name, schema]) => [name, workBuddySchema(schema, depth + 1)]));
+    } else if (schemaLists.has(key) && Array.isArray(child)) {
+      out[key] = child.map(schema => workBuddySchema(schema, depth + 1));
+    } else if (schemaValues.has(key)) {
+      if ((key === "additionalProperties" || key === "unevaluatedProperties") && typeof child === "boolean") continue;
+      out[key] = key === "items" && Array.isArray(child)
+        ? { anyOf: child.map(schema => workBuddySchema(schema, depth + 1)) } : workBuddySchema(child, depth + 1);
+    }
+  }
+  if (typeof out.pattern === "string") out.pattern = out.pattern.replace(/\\\\|\\0(?![0-9])/g, match => match === "\\0" ? "\\u0000" : match);
+  if (out.required !== undefined && !Array.isArray(out.required)) delete out.required;
+  if (typeof out.type === "string") {
+    out.type = out.type.toLowerCase();
+    if (!jsonTypes.has(out.type as string)) delete out.type;
+  }
+  if (Array.isArray(out.enum)) {
+    if (!out.enum.length) delete out.enum;
+    else if (out.type === undefined) {
+      const groups = new Map<string, unknown[]>();
+      for (const item of out.enum) {
+        const type = item === null ? "null" : Array.isArray(item) ? "array" : typeof item;
+        const values = groups.get(type) ?? []; values.push(item); groups.set(type, values);
+      }
+      if (groups.size === 1) out.type = groups.keys().next().value;
+      else {
+        const union = { anyOf: [...groups].map(([type, values]) => ({ type, enum: values })) };
+        out.allOf = [...(Array.isArray(out.allOf) ? out.allOf : []), union];
+        delete out.enum;
+      }
+    }
+  }
+  return out;
+}
+
+export function workBuddyToolParameters(value: unknown): Record<string, unknown> {
+  const out = workBuddySchema(value);
+  const properties: Record<string, unknown> = { ...(out.properties as Record<string, unknown> ?? {}) };
+  const required = new Set(Array.isArray(out.required) ? out.required.filter(x => typeof x === "string") : []);
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    for (const variant of Array.isArray(out[key]) ? out[key] : []) {
+      const row = variant as Record<string, unknown>;
+      Object.assign(properties, row.properties);
+      if (key === "allOf" && Array.isArray(row.required)) for (const field of row.required) if (typeof field === "string") required.add(field);
+    }
+    delete out[key];
+  }
+  return { ...out, type: "object", properties, ...(required.size ? { required: [...required] } : {}) };
+}

package/src/adapters/workbuddy.ts

@@ -0,0 +1,68 @@
+import { createHmac, randomBytes, randomUUID } from "node:crypto";
+import type { ProviderAdapter } from "./base";
+import { workBuddyToolParameters } from "./workbuddy-schema";
+import { retainTranslatedEvent, releaseTranslatedEvent } from "../lib/translator-budget";
+import { createOpenAIChatAdapter } from "./openai-chat";
+import type { AdapterEvent, OcxProviderConfig } from "../types";
+import { assertWorkBuddyDestination, WORKBUDDY_BASE_URL, workBuddyHeaders } from "../providers/workbuddy";
+
+const sessionSalt = randomBytes(32);
+const opaqueId = (value: unknown) => createHmac("sha256", sessionSalt).update(JSON.stringify(value)).digest("hex").slice(0, 32);
+
+export function createWorkBuddyAdapter(provider: OcxProviderConfig): ProviderAdapter {
+  const base = createOpenAIChatAdapter({ ...provider, adapter: "openai-chat", baseUrl: WORKBUDDY_BASE_URL, headers: undefined });
+  return {
+    ...base, name: "workbuddy-ai",
+    async buildRequest(parsed, incoming) {
+      assertWorkBuddyDestination(provider.baseUrl);
+      if (!provider.apiKey || !parsed._workbuddyAuthContext) throw new Error("WorkBuddy AI account unavailable; run ocx login workbuddy-ai");
+      const req = await base.buildRequest({ ...parsed, stream: true }, incoming);
+      const body = JSON.parse(req.body);
+      const messages = body.messages as Array<Record<string, unknown>>;
+      for (const message of messages) if (message.role === "developer") message.role = "system";
+      if (messages[0]?.role !== "system") messages.unshift({ role: "system", content: "You are a helpful assistant." });
+      if (body.max_completion_tokens !== undefined) { body.max_tokens = body.max_completion_tokens; delete body.max_completion_tokens; }
+      if (body.tool_choice === "none") { delete body.tools; delete body.tool_choice; }
+      else if (body.tool_choice?.type === "function") body.tool_choice = body.tool_choice.function.name;
+      for (const tool of body.tools ?? []) {
+        if (tool.type === "function") tool.function.parameters = workBuddyToolParameters(tool.function.parameters);
+      }
+      const users = messages.map((m, index) => ({ m, index })).filter(({ m }) => m.role === "user");
+      const session = parsed._codexOwnThreadId || parsed._clientThreadId
+        || (!parsed._promptCacheKeyIsSharedCohort ? parsed.options.promptCacheKey : undefined)
+        || incoming.headers.get("session_id") || incoming.headers.get("x-session-id");
+      const conversation = session || users[0]?.m.content;
+      const latest = users.at(-1);
+      const requestId = randomUUID().replaceAll("-", "");
+      const headers = {
+        "Content-Type": "application/json", Accept: "text/event-stream",
+        ...workBuddyHeaders(provider.apiKey, parsed._workbuddyAuthContext),
+        "X-Request-ID": requestId, "X-Conversation-Message-ID": requestId,
+        "X-Conversation-Request-ID": latest ? opaqueId([conversation, latest.index, latest.m.content]) : requestId,
+        ...(conversation ? { "X-Conversation-ID": opaqueId(conversation) } : {}),
+      };
+      return { ...req, url: `${WORKBUDDY_BASE_URL}/chat/completions`, headers, body: JSON.stringify(body), redirect: "error" as const };
+    },
+    async parseResponse(response, budget, tier) {
+      const events: AdapterEvent[] = [];
+      try {
+        for await (const event of base.parseStream(response, budget, tier)) {
+          retainTranslatedEvent(event, budget, events.at(-1));
+          events.push(event);
+        }
+        return events;
+      } catch (error) {
+        for (const event of events) releaseTranslatedEvent(event, budget);
+        throw error;
+      }
+    },
+    formatErrorBody(status, _headers, payload) {
+      let code: unknown;
+      try { code = JSON.parse(payload)?.code; } catch { /* Only structured numeric codes are public. */ }
+      if (Number(code) === 11128) return "WorkBuddy AI rejected this client channel (11128).";
+      if (Number(code) === 11140) return "WorkBuddy AI restricted this account (11140); contact WorkBuddy support.";
+      if (Number(code) === 14018) return "WorkBuddy AI credits exhausted (14018).";
+      return `WorkBuddy AI request failed (HTTP ${status}).`;
+    },
+  };
+}

package/src/bridge/response-json.ts

@@ -253,7 +253,7 @@ function buildResponseJSONWithBudget(
     const text = stripCitationMarkers(currentTextStr);
     const sourceBytes = pendingWebSources.reduce((sum, source) => sum + bytesOf(JSON.stringify(source)), 0);
     const annotations = pendingWebSources.map(s => ({
-      type: "url_citation", url: s.url, ...(s.title ? { title: s.title } : {}), start_index: 0, end_index: 0,
+      type: "url_citation", url: s.url, title: s.title || s.url, start_index: 0, end_index: 0,
     }));
     pendingWebSources = [];
     const item = {

package/src/bridge/sse.ts

@@ -488,7 +488,7 @@ export function bridgeToResponsesSSE(
       const takeWebAnnotations = (): { type: string; url: string; title?: string; start_index: number; end_index: number }[] => {
         if (pendingWebSources.length === 0) return [];
         const anns = pendingWebSources.map(s => ({
-          type: "url_citation", url: s.url, ...(s.title ? { title: s.title } : {}), start_index: 0, end_index: 0,
+          type: "url_citation", url: s.url, title: s.title || s.url, start_index: 0, end_index: 0,
         }));
         const annotationBytes = bytesOf(JSON.stringify(anns));
         const reservation = budget?.reserveTransient(annotationBytes, { kind: "retained_collectors" });

package/src/chat/inbound.ts

@@ -6,6 +6,7 @@
  * responsesRequestSchema so routing/OAuth/pool/sidecars are inherited unchanged.
  */
 import { chatImageUrlFromPart } from "./image-parts";
+import { signedReasoningInputItems } from "./reasoning-details";
 import { untranslatedChatInputMedia, untranslatedInputMediaMessage } from "../responses/input-media";
 
 export class ChatCompletionsRequestError extends Error {}
@@ -439,7 +440,16 @@ function resolveReasoningSummary(raw: Rec): string | undefined {
  * Translate an OpenAI Chat Completions request body into a /v1/responses request body.
  * Throws ChatCompletionsRequestError (-> 400) on malformed input.
  */
-export function chatCompletionsToResponsesBody(raw: unknown): Rec {
+export interface ChatResponsesProjectionOptions {
+  /**
+   * The route is one first-party Anthropic destination that cannot change credential domain, so
+   * signed thinking a client returns in `reasoning_details` may be replayed to it (#7429).
+   * Every other route keeps the plaintext projection.
+   */
+  acceptAnthropicReasoningSignatures?: boolean;
+}
+
+export function chatCompletionsToResponsesBody(raw: unknown, options: ChatResponsesProjectionOptions = {}): Rec {
   assertChatCompletionsRoutingBody(raw);
   // Only the translated path reaches this function. Native Chat can retain its
   // provider-specific file/audio blocks; projecting them here would discard them.
@@ -510,7 +520,13 @@ export function chatCompletionsToResponsesBody(raw: unknown): Rec {
         // is no attachment point on the message itself, and the parser buffers a
         // reasoning item and prepends it to the NEXT assistant message. Emitting it
         // here keeps that adjacency intact.
-        const reasoningText = assistantReasoningText(msg);
+        const signedReasoning = options.acceptAnthropicReasoningSignatures === true
+          ? signedReasoningInputItems(msg.reasoning_details)
+          : undefined;
+        const reasoningText = signedReasoning ? undefined : assistantReasoningText(msg);
+        // Signed entries carry their own text, so `reasoning_content` (the same text) is not
+        // projected a second time beside them.
+        if (signedReasoning) input.push(...signedReasoning);
         if (reasoningText !== undefined) {
           // `summary` is required on a reasoning input item by the OpenAI Responses API, and our
           // own responsesRequestSchema marks it optional, so a summary-less item validated locally
@@ -525,6 +541,8 @@ export function chatCompletionsToResponsesBody(raw: unknown): Rec {
             content: [{ type: "reasoning_text", text: reasoningText }],
           });
         }
+        // An Opus progress update also sits in `content`. The wire has no marker that tells it
+        // from answer text, so the content is replayed as sent, as it was before #7429.
         const blocks = assistantContentToBlocks(msg.content);
         if (blocks.length > 0) input.push({ type: "message", role: "assistant", content: blocks });
         if (msg.tool_calls !== undefined) {

package/src/chat/outbound.ts

@@ -22,7 +22,9 @@ import {
   UNDECLARED_TOOL_CALL_ERROR_CODE,
 } from "../lib/errors";
 import { redactSecretString } from "../lib/redact";
+import { truncationReasonFor } from "../responses/truncated-stop-reason";
 import { createSseBlockBuffer, sseDataPayload } from "../server/sse-payload-rewrite";
+import { reasoningDetailEntriesForItem } from "./reasoning-details";
 
 function isRec(v: unknown): v is Rec {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -149,7 +151,7 @@ export function chunkBase(id: string, model: string, created: number): Rec {
   };
 }
 
-function appendedUtf8Bytes(previous: string, previousBytes: number, fragment: string): number {
+export function appendedUtf8Bytes(previous: string, previousBytes: number, fragment: string): number {
   let nextBytes = previousBytes + Buffer.byteLength(fragment);
   const previousLast = previous.charCodeAt(previous.length - 1);
   const fragmentFirst = fragment.charCodeAt(0);
@@ -242,8 +244,14 @@ export function chatCompletionsIncompleteOutcome(
   reason: unknown,
   message: unknown,
 ): { finishReason: "length" | "content_filter" } | { failMessage: string } {
-  if (reason === "max_output_tokens") return { finishReason: "length" };
-  if (reason === "content_filter") return { finishReason: "content_filter" };
+  // Upstream Responses endpoints do not all use OpenAI's `max_output_tokens`: Volcengine Ark
+  // (Coding Plan `/responses`) sends `incomplete_details.reason: "length"` for a hit output cap.
+  // Read the reason through the shared truncation vocabulary so such a turn ends with
+  // finish_reason "length" instead of a 502. Proxy reasons (adapter_eof, upstream_stall_timeout,
+  // missing_terminal_event) are not in that vocabulary and still fail.
+  const truncation = typeof reason === "string" ? truncationReasonFor(reason) : undefined;
+  if (truncation === "max_output_tokens") return { finishReason: "length" };
+  if (truncation === "content_filter") return { finishReason: "content_filter" };
   const why = typeof reason === "string" ? reason : "unknown";
   return {
     failMessage: typeof message === "string" && message.length > 0
@@ -511,6 +519,17 @@ export function responsesSseToChatCompletionsSse(
         frame.choices = [{ index: 0, delta: { reasoning_content: text }, finish_reason: null }];
         emit(frame);
       };
+      // #7429: provider-issued thinking state, one complete frame per finished reasoning item.
+      let nextReasoningDetailIndex = 0;
+      const emitReasoningDetails = (item: Rec) => {
+        const entries = reasoningDetailEntriesForItem(item, nextReasoningDetailIndex, translatorBudget);
+        if (entries.length === 0) return;
+        nextReasoningDetailIndex += entries.length;
+        ensureRole();
+        const frame = chunkBase(id, model, created);
+        frame.choices = [{ index: 0, delta: { reasoning_details: entries }, finish_reason: null }];
+        emit(frame);
+      };
       const resolveFinalArguments = (candidate: unknown, streamed: string) => {
         if (typeof candidate !== "string") return streamed;
         // Some compatible providers send an empty final snapshot. Do not let that erase
@@ -717,6 +736,7 @@ export function responsesSseToChatCompletionsSse(
               && refusalItems.has(data.output_index)) {
               refusalItem(data.output_index, data, "item_id");
             }
+            if (item.type === "reasoning") emitReasoningDetails(item);
             if (item.type === "function_call") {
               sawToolUse = true;
               const callId = typeof item.call_id === "string" ? item.call_id : "";
@@ -858,8 +878,8 @@ export function responsesJsonToChatCompletion(json: unknown, model: string, tran
   const incomplete = isRec(body.incomplete_details) ? body.incomplete_details : {};
   let incompleteFinish: "length" | "content_filter" | undefined;
   if (body.status === "incomplete") {
-    if (incomplete.reason === "max_output_tokens") incompleteFinish = "length";
-    else if (incomplete.reason === "content_filter") incompleteFinish = "content_filter";
+    const outcome = chatCompletionsIncompleteOutcome(incomplete.reason, undefined);
+    if ("finishReason" in outcome) incompleteFinish = outcome.finishReason;
     else throw new ChatCompletionsStreamError("upstream response ended without a supported completion boundary", {
       code: "upstream_incomplete", type: "upstream_error",
     });
@@ -872,6 +892,7 @@ export function responsesJsonToChatCompletion(json: unknown, model: string, tran
   let contentBytes = 0;
   let reasoningBytes = 0;
   const toolCalls: Rec[] = [];
+  const reasoningDetails: Rec[] = [];
   const append = (previous: string, previousBytes: number, fragment: string): { text: string; bytes: number } => {
     if (!fragment) return { text: previous, bytes: previousBytes };
     const scope = { kind: "retained_collectors" as const };
@@ -902,6 +923,11 @@ export function responsesJsonToChatCompletion(json: unknown, model: string, tran
         }
       }
     } else if (raw.type === "reasoning") {
+      const entries = reasoningDetailEntriesForItem(raw, reasoningDetails.length, translatorBudget);
+      if (entries.length > 0) {
+        translatorBudget?.chargeRetained(Buffer.byteLength(JSON.stringify(entries)), { kind: "retained_collectors" });
+        reasoningDetails.push(...entries);
+      }
       if (Array.isArray(raw.summary)) {
         for (const part of raw.summary) {
           if (isRec(part) && part.type === "summary_text" && typeof part.text === "string") {
@@ -948,6 +974,7 @@ export function responsesJsonToChatCompletion(json: unknown, model: string, tran
     refusal,
   };
   if (reasoning) message.reasoning_content = reasoning;
+  if (reasoningDetails.length > 0) message.reasoning_details = reasoningDetails;
   if (toolCalls.length > 0) message.tool_calls = toolCalls;
 
   return {
@@ -981,7 +1008,8 @@ export async function collectChatCompletion(
   let content = "";
   let refusal: string | null = null;
   let reasoning = "";
-  const retainedBytes = { content: 0, refusal: 0, reasoning: 0 };
+  const reasoningDetails: Rec[] = [];
+  const retainedBytes = { content: 0, refusal: 0, reasoning: 0, reasoningDetails: 0 };
   const toolCalls = new Map<number, { id: string; name: string; arguments: string; argumentBytes: number }>();
   // Per-call budget scopes (2 MiB/call enforced by the budget): the map key is the
   // wire index, which is stable across deltas and present before the call id.
@@ -1005,8 +1033,8 @@ export async function collectChatCompletion(
     }
   };
   const releaseCollectors = () => {
-    translatorBudget.releaseRetained(retainedBytes.content + retainedBytes.refusal + retainedBytes.reasoning,
-      { kind: "retained_collectors" });
+    translatorBudget.releaseRetained(retainedBytes.content + retainedBytes.refusal + retainedBytes.reasoning
+      + retainedBytes.reasoningDetails, { kind: "retained_collectors" });
   };
   try {
     // Share native relay framing, while retaining the collector's existing admission
@@ -1055,6 +1083,16 @@ export async function collectChatCompletion(
           refusal = appendRetained("refusal", refusal ?? "", delta.refusal);
         }
         if (typeof delta.reasoning_content === "string") reasoning = appendRetained("reasoning", reasoning, delta.reasoning_content);
+        // Each entry arrives complete in one frame (#7429), so the fold is a concatenation.
+        if (Array.isArray(delta.reasoning_details)) {
+          for (const entry of delta.reasoning_details) {
+            if (!isRec(entry)) continue;
+            const entryBytes = Buffer.byteLength(JSON.stringify(entry));
+            translatorBudget.chargeRetained(entryBytes, { kind: "retained_collectors" });
+            retainedBytes.reasoningDetails += entryBytes;
+            reasoningDetails.push(entry);
+          }
+        }
         if (Array.isArray(delta.tool_calls)) {
           for (const tc of delta.tool_calls) {
             if (!isRec(tc)) continue;
@@ -1121,6 +1159,7 @@ export async function collectChatCompletion(
     refusal,
   };
   if (reasoning) message.reasoning_content = reasoning;
+  if (reasoningDetails.length > 0) message.reasoning_details = reasoningDetails;
   if (toolCalls.size > 0) {
     // Final owner transfer is itself a charging operation: if it overflows,
     // release every copy already charged in this loop and close every scope

package/src/chat/reasoning-details.ts

@@ -0,0 +1,137 @@
+/**
+ * Anthropic thinking state on the Chat Completions wire, as OpenRouter-style `reasoning_details`
+ * (#7429).
+ *
+ * Chat has no slot for a thinking block's signature, so a Chat client echoing `reasoning_content`
+ * gave Claude back unsigned text, which the Anthropic adapter must drop: every tool step lost its
+ * reasoning. The carrier is the one OpenRouter documents for Claude and Hermes and pi already round
+ * trip: an ordered array on the assistant message, `{type: "reasoning.text", text, signature}`
+ * for a signed thinking block and `{type: "reasoning.encrypted", data}` for a redacted one.
+ *
+ * Outbound, the entries are built from the signature and redacted payloads the provider issued,
+ * never from anything this proxy computes. A signature that signs text the client never saw
+ * (hidden thinking) is withheld, because pairing it with the visible text would attest to content
+ * Anthropic did not sign. Inbound, the entries are read only for a single-destination first-party
+ * Anthropic route (the caller decides that), only when every entry is well formed, and become the
+ * same `ocxr1` envelope the Responses wire already uses; anything else falls back to plaintext.
+ */
+import {
+  decodeReasoningEnvelope,
+  encodeReasoningEnvelope,
+  isLikelyRealAnthropicThinkingSignature,
+  type ReasoningEnvelope,
+} from "../responses/reasoning-envelope";
+import type { TranslatorBudget } from "../lib/translator-budget";
+
+type Rec = Record<string, unknown>;
+
+function isRec(value: unknown): value is Rec {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** OpenRouter's `format` for Anthropic thinking entries. */
+export const ANTHROPIC_REASONING_DETAIL_FORMAT = "anthropic-claude-v1";
+
+/** One closed reasoning item, as either outbound path sees it. */
+export interface ReasoningDetailSource {
+  /** The thinking text the client was shown for this item. */
+  text: string;
+  signature?: string;
+  redacted?: readonly string[];
+  /** The signature covers thinking text the client was not shown. */
+  hidden?: boolean;
+}
+
+/**
+ * The `reasoning_details` entries for one reasoning item, numbered from `firstIndex`. Redacted
+ * blocks come first: that is the order the adapter replays them in. Empty when the item carries no
+ * provider-issued state a Chat client can return.
+ */
+export function reasoningDetailEntries(source: ReasoningDetailSource, firstIndex: number): Rec[] {
+  const entries: Rec[] = [];
+  for (const data of source.redacted ?? []) {
+    if (typeof data !== "string" || data.length === 0) continue;
+    entries.push({
+      type: "reasoning.encrypted",
+      data,
+      format: ANTHROPIC_REASONING_DETAIL_FORMAT,
+      index: firstIndex + entries.length,
+    });
+  }
+  if (source.hidden !== true && isLikelyRealAnthropicThinkingSignature(source.signature)) {
+    entries.push({
+      type: "reasoning.text",
+      text: source.text,
+      signature: source.signature,
+      format: ANTHROPIC_REASONING_DETAIL_FORMAT,
+      index: firstIndex + entries.length,
+    });
+  }
+  return entries;
+}
+
+/** The visible text of a Responses reasoning item, read the way the parser reads it. */
+export function responsesReasoningItemText(item: Rec): string {
+  const pick = (parts: unknown, type: string): string => Array.isArray(parts)
+    ? parts.filter((part): part is Rec => isRec(part) && part.type === type && typeof part.text === "string")
+      .map(part => part.text as string).join("")
+    : "";
+  return pick(item.summary, "summary_text") || pick(item.content, "reasoning_text");
+}
+
+/**
+ * The entries for a finished Responses reasoning item from the internal bridge. Its `ocxr1`
+ * envelope holds what the provider issued. `txt` alone means the signed text was hidden; `txt`
+ * with `upd` is an Opus progress update, whose signed text the client received as `content`.
+ */
+export function reasoningDetailEntriesForItem(item: Rec, firstIndex: number, budget?: TranslatorBudget): Rec[] {
+  if (typeof item.encrypted_content !== "string") return [];
+  const envelope = decodeReasoningEnvelope(item.encrypted_content, budget);
+  if (!envelope || (!envelope.sig && !envelope.red)) return [];
+  const progress = envelope.upd !== undefined && typeof envelope.txt === "string";
+  return reasoningDetailEntries({
+    text: progress ? envelope.txt! : responsesReasoningItemText(item),
+    ...(envelope.sig ? { signature: envelope.sig } : {}),
+    ...(envelope.red ? { redacted: envelope.red } : {}),
+    hidden: !progress && envelope.txt !== undefined,
+  }, firstIndex);
+}
+
+function reasoningInputItem(text: string, envelope: ReasoningEnvelope): Rec {
+  return {
+    type: "reasoning",
+    summary: text ? [{ type: "summary_text", text }] : [],
+    ...(text ? { content: [{ type: "reasoning_text", text }] } : {}),
+    encrypted_content: encodeReasoningEnvelope(envelope),
+  };
+}
+
+/**
+ * Responses reasoning input items carrying the signatures a client returned in
+ * `reasoning_details`, or `undefined` when the array is absent, empty or holds anything this
+ * carrier did not issue — an unsigned or malformed signature, a summary entry, another provider's
+ * encrypted format. Undefined means the caller keeps its plaintext projection unchanged.
+ */
+export function signedReasoningInputItems(details: unknown): Rec[] | undefined {
+  if (!Array.isArray(details) || details.length === 0) return undefined;
+  const items: Rec[] = [];
+  let redacted: string[] = [];
+  for (const raw of details) {
+    if (!isRec(raw)) return undefined;
+    if (raw.type === "reasoning.encrypted") {
+      if (raw.format !== ANTHROPIC_REASONING_DETAIL_FORMAT || typeof raw.data !== "string" || raw.data.length === 0) {
+        return undefined;
+      }
+      redacted.push(raw.data);
+      continue;
+    }
+    if (raw.type !== "reasoning.text") return undefined;
+    if (raw.format !== undefined && raw.format !== ANTHROPIC_REASONING_DETAIL_FORMAT) return undefined;
+    const signature = typeof raw.signature === "string" ? raw.signature : undefined;
+    if (typeof raw.text !== "string" || !isLikelyRealAnthropicThinkingSignature(signature)) return undefined;
+    items.push(reasoningInputItem(raw.text, { sig: signature, ...(redacted.length > 0 ? { red: redacted } : {}) }));
+    redacted = [];
+  }
+  if (redacted.length > 0) items.push(reasoningInputItem("", { red: redacted }));
+  return items;
+}