@juspay/neurolink 12.35.5 → 12.36.0

package/CHANGELOG.md

@@ -1,8 +1,8 @@
-## [12.35.5](https://github.com/juspay/neurolink/compare/v12.35.4...v12.35.5) (2026-09-27)
+## [12.36.0](https://github.com/juspay/neurolink/compare/v12.35.5...v12.36.0) (2026-09-28)
 
-### Bug Fixes
+### Features
 
-- **(proxy):** lazily require the OTel logs bridge's heavy SDK packages ([e52815d](https://github.com/juspay/neurolink/commit/e52815dce8f891415d2114acd42613da8481a6b1))
+- **(proxy):** translate native Codex requests to Anthropic Messages shape ([70c11ea](https://github.com/juspay/neurolink/commit/70c11eaec4f2c792b401d1f1d70d6b24cfe57610))
 
 ## [11.2.3](https://github.com/juspay/neurolink/compare/v11.2.2...v11.2.3) (2026-08-19)
 

package/dist/proxy/codexOutboundFallback.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Codex-outbound fallback: request translation, Codex Responses -> ClaudeRequest.
+ *
+ * Named to mirror the existing asymmetry: `codexFallback.ts` is the Claude
+ * engine's fallback _into_ Codex; this file is the Codex engine's fallback
+ * _out_ to the Anthropic OAuth pool or Vertex-Claude. Owns one thing:
+ * untrusted inbound Codex Responses JSON -> a typed `ClaudeRequest`. Does not
+ * own target/model selection, response/stream translation back to Codex wire
+ * format, tool execution, or dispatch/HTTP.
+ *
+ * `parallel_tool_calls` is parsed and validated but not yet consumed here —
+ * `mapCodexToolChoiceToClaude` stays the base bijection this PR ships.
+ * Threading it into `tool_choice.disable_parallel_tool_use` (and the matching
+ * `ClaudeRequest.tool_choice` type change) is the tool-call-fidelity build-order
+ * PR's explicit modification to this same function, not a gap in this one.
+ */
+import type { ClaudeRequest } from "../types/index.js";
+import type { CodexNativeRequest, CodexTranslationError } from "../types/index.js";
+export declare function parseCodexNativeRequest(raw: unknown): {
+    ok: true;
+    value: CodexNativeRequest;
+} | {
+    ok: false;
+    error: CodexTranslationError;
+};
+export declare function translateCodexRequestToClaude(request: CodexNativeRequest, target: {
+    provider: "anthropic" | "vertex";
+    model: string;
+}): {
+    ok: true;
+    value: ClaudeRequest;
+} | {
+    ok: false;
+    error: CodexTranslationError;
+};

package/dist/proxy/codexOutboundFallback.js

@@ -0,0 +1,515 @@
+import { resolveClaudeMaxTokens } from "../utils/tokenLimits.js";
+// ---------------------------------------------------------------------------
+// §3.1 parseCodexNativeRequest — the untrusted-JSON -> typed boundary.
+// ---------------------------------------------------------------------------
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCodexContentPart(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.type === "input_text" || value.type === "output_text") {
+        return typeof value.text === "string";
+    }
+    if (value.type === "input_image") {
+        return typeof value.image_url === "string";
+    }
+    return false;
+}
+function isCodexNativeToolDeclaration(value) {
+    if (!isRecord(value) || typeof value.name !== "string") {
+        return false;
+    }
+    if (value.type === "function") {
+        return (typeof value.strict === "boolean" &&
+            isRecord(value.parameters) &&
+            (value.description === undefined || typeof value.description === "string"));
+    }
+    if (value.type === "custom") {
+        return (isRecord(value.format) &&
+            value.format.type === "grammar" &&
+            (value.format.syntax === "lark" || value.format.syntax === "regex") &&
+            typeof value.format.definition === "string" &&
+            (value.description === undefined || typeof value.description === "string"));
+    }
+    return false;
+}
+function isCodexNativeToolNamespace(value) {
+    return (isRecord(value) &&
+        value.type === "namespace" &&
+        typeof value.name === "string" &&
+        typeof value.description === "string" &&
+        Array.isArray(value.tools) &&
+        value.tools.every(isCodexNativeToolDeclaration));
+}
+function isCodexNativeInputItem(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    switch (value.type) {
+        case "message":
+            return ((value.role === "user" ||
+                value.role === "assistant" ||
+                value.role === "developer") &&
+                Array.isArray(value.content) &&
+                value.content.every(isCodexContentPart));
+        case "function_call":
+            return (typeof value.call_id === "string" &&
+                typeof value.name === "string" &&
+                typeof value.arguments === "string");
+        case "function_call_output":
+        case "custom_tool_call_output":
+            return (typeof value.call_id === "string" && typeof value.output === "string");
+        case "custom_tool_call":
+            return (typeof value.call_id === "string" &&
+                typeof value.name === "string" &&
+                typeof value.input === "string");
+        case "reasoning":
+            return true;
+        case "additional_tools":
+            return (value.role === "developer" &&
+                Array.isArray(value.tools) &&
+                value.tools.every(isCodexNativeToolNamespace));
+        default:
+            return false;
+    }
+}
+function isCodexNativeToolChoice(value) {
+    if (value === "auto" || value === "required" || value === "none") {
+        return true;
+    }
+    return (isRecord(value) &&
+        value.type === "function" &&
+        typeof value.name === "string");
+}
+const CODEX_REASONING_EFFORTS = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+function isCodexNativeReasoning(value) {
+    return (isRecord(value) &&
+        CODEX_REASONING_EFFORTS.includes(value.effort) &&
+        (value.context === undefined || typeof value.context === "string"));
+}
+export function parseCodexNativeRequest(raw) {
+    if (!isRecord(raw) ||
+        typeof raw.model !== "string" ||
+        typeof raw.stream !== "boolean" ||
+        typeof raw.store !== "boolean" ||
+        !Array.isArray(raw.input) ||
+        !raw.input.every(isCodexNativeInputItem) ||
+        (raw.tool_choice !== undefined &&
+            !isCodexNativeToolChoice(raw.tool_choice)) ||
+        (raw.reasoning !== undefined && !isCodexNativeReasoning(raw.reasoning)) ||
+        (raw.parallel_tool_calls !== undefined &&
+            typeof raw.parallel_tool_calls !== "boolean")) {
+        return {
+            ok: false,
+            error: {
+                code: "MALFORMED_REQUEST",
+                message: "inbound body does not match CodexNativeRequest",
+            },
+        };
+    }
+    return { ok: true, value: raw };
+}
+// ---------------------------------------------------------------------------
+// §3.3 tool_choice — exact inversion of codexFallback.ts's convertClaudeRequestToCodex.
+// ---------------------------------------------------------------------------
+function mapCodexToolChoiceToClaude(choice) {
+    if (choice === undefined) {
+        return undefined;
+    }
+    if (choice === "required") {
+        return { type: "any" };
+    }
+    if (choice === "auto") {
+        return { type: "auto" };
+    }
+    if (choice === "none") {
+        return { type: "none" };
+    }
+    return { type: "tool", name: choice.name };
+}
+// ---------------------------------------------------------------------------
+// §3.4 Tools: flattened across namespaces, split by each declaration's own type.
+// ---------------------------------------------------------------------------
+function mapCodexFunctionToolToClaude(tool) {
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        input_schema: tool.parameters,
+    };
+}
+function mapCodexCustomToolToClaude(tool) {
+    // Lossy, explicitly flagged: no JSON Schema exists for a Lark/regex grammar.
+    // The model is no longer grammar-constrained after this mapping — needs
+    // product sign-off before shipping (§10 of the design).
+    return {
+        name: tool.name,
+        description: [
+            tool.description,
+            `Grammar (${tool.format.syntax}):\n${tool.format.definition}`,
+        ]
+            .filter((s) => Boolean(s))
+            .join("\n\n"),
+        input_schema: {
+            type: "object",
+            properties: {
+                input: {
+                    type: "string",
+                    description: "Raw command text, constrained by the grammar in this tool's description.",
+                },
+            },
+            required: ["input"],
+        },
+    };
+}
+function mapCodexToolDeclarationToClaude(tool) {
+    // Discriminate on the declaration's own `type`, never on which namespace it
+    // came from — the real capture disproves the namespace-implies-kind
+    // assumption (`exec` is `type:"custom"` inside a `type:"function"`-heavy
+    // namespace).
+    return tool.type === "custom"
+        ? mapCodexCustomToolToClaude(tool)
+        : mapCodexFunctionToolToClaude(tool);
+}
+function buildClaudeTools(additionalTools) {
+    if (!additionalTools) {
+        return undefined;
+    }
+    const tools = additionalTools.tools.flatMap((namespace) => namespace.tools.map(mapCodexToolDeclarationToClaude));
+    return tools.length > 0 ? tools : undefined;
+}
+// ---------------------------------------------------------------------------
+// §3.5 Reasoning: reasoning.effort -> thinking.
+// ---------------------------------------------------------------------------
+const REASONING_BUDGET = {
+    low: 4096,
+    medium: 8192,
+    high: 16384,
+    xhigh: 24576,
+    max: 32768,
+};
+function mapCodexReasoningToThinking(reasoning, resolvedMaxTokens) {
+    if (!reasoning ||
+        reasoning.effort === "none" ||
+        reasoning.effort === "minimal") {
+        return undefined;
+    }
+    const table = REASONING_BUDGET[reasoning.effort];
+    // Explicit floor: makes the ">= 1024" invariant correct by construction
+    // rather than an accident of today's model-table minimums.
+    const budget_tokens = Math.max(1024, Math.min(table, resolvedMaxTokens - 1024));
+    return { type: "enabled", budget_tokens };
+}
+// ---------------------------------------------------------------------------
+// §3.6 Non-JSON function_call.arguments — never throws.
+// ---------------------------------------------------------------------------
+function parseInboundToolArguments(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (isRecord(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through — not JSON at all (e.g. exec's raw shell command)
+    }
+    return { input: raw };
+}
+// ---------------------------------------------------------------------------
+// §3.7 Content parts, with the image data-URI fix.
+// ---------------------------------------------------------------------------
+const DATA_URI_RE = /^data:([^;,]+);base64,(.+)$/s;
+// The four image types the Messages API accepts (mirrors
+// SUPPORTED_IMAGE_MEDIA_TYPES in providers/anthropicImageBlocks.ts).
+const ANTHROPIC_IMAGE_MEDIA_TYPES = new Set([
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]);
+const ANTHROPIC_TOOL_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+function normalizeImageMediaType(mediaType) {
+    const lower = mediaType.toLowerCase();
+    return lower === "image/jpg" ? "image/jpeg" : lower;
+}
+function toClaudeContentPart(part) {
+    if (part.type === "input_image") {
+        const match = DATA_URI_RE.exec(part.image_url);
+        if (match) {
+            return {
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: normalizeImageMediaType(match[1]),
+                    data: match[2],
+                },
+            };
+        }
+        return { type: "image", source: { type: "url", url: part.image_url } };
+    }
+    return { type: "text", text: part.text };
+}
+// ---------------------------------------------------------------------------
+// §4 Role-alternation coalescing.
+// ---------------------------------------------------------------------------
+function coalesceCodexInputToClaudeMessages(items) {
+    const groups = [];
+    let current;
+    const open = (role) => {
+        if (current?.role === role) {
+            return current;
+        }
+        if (current) {
+            groups.push(current);
+        }
+        current = { role, blocks: [] };
+        return current;
+    };
+    for (const item of items) {
+        // additional_tools is handled out-of-band (§3.4). A reasoning item carries
+        // OpenAI-encrypted chain of thought that only the OpenAI backend can read;
+        // Anthropic has no way to consume it, so it is dropped by rule, not by
+        // accident (unknown item types still fail parsing, per A.1).
+        if (item.type === "additional_tools" || item.type === "reasoning") {
+            continue;
+        }
+        if (item.type === "message") {
+            // Developer messages become system blocks (below). An empty message
+            // adds nothing, and on its own would become a content-less turn.
+            if (item.role === "developer" || item.content.length === 0) {
+                continue;
+            }
+            open(item.role).blocks.push(...item.content.map(toClaudeContentPart));
+            continue;
+        }
+        if (item.type === "function_call" || item.type === "custom_tool_call") {
+            open("assistant").blocks.push({
+                type: "tool_use",
+                id: item.call_id,
+                name: item.name,
+                // A custom tool is declared with a single `input` string (§3.4), so
+                // its raw call text maps onto that field unchanged.
+                input: item.type === "function_call"
+                    ? parseInboundToolArguments(item.arguments)
+                    : { input: item.input },
+            });
+            continue;
+        }
+        open("user").blocks.push({
+            type: "tool_result",
+            tool_use_id: item.call_id,
+            content: item.output,
+        });
+    }
+    if (current) {
+        groups.push(current);
+    }
+    // In a user turn the Messages API wants tool_result blocks before any other
+    // content, so a user message that arrives between a call and its output is
+    // moved after the result rather than sent in an order the API rejects.
+    return groups.map((g) => ({
+        role: g.role,
+        content: g.role === "user"
+            ? [
+                ...g.blocks.filter((block) => block.type === "tool_result"),
+                ...g.blocks.filter((block) => block.type !== "tool_result"),
+            ]
+            : g.blocks,
+    }));
+}
+function buildSystemBlocksFromDeveloperMessages(items) {
+    return items
+        .filter((i) => i.type === "message" && i.role === "developer")
+        .flatMap((i) => i.content.map(toClaudeContentPart))
+        .filter((b) => b.type === "text");
+}
+// ---------------------------------------------------------------------------
+// §5 Resumed-session history contract — fail loud, never guess.
+// ---------------------------------------------------------------------------
+// Detects only a missing tools preamble. A client-side prune that drops turns
+// from the middle while resending the preamble passes this check; nothing in
+// the wire format marks such a gap (spec Q6, still open).
+function hasFreshSessionPreamble(items) {
+    return items[0]?.type === "additional_tools";
+}
+// ---------------------------------------------------------------------------
+// Inputs Codex accepts but the Messages API rejects — fail loud, never guess.
+// ---------------------------------------------------------------------------
+function describeUntranslatableItem(item, provider) {
+    if (item.type === "additional_tools") {
+        const badTool = item.tools
+            .flatMap((namespace) => namespace.tools)
+            .find((tool) => !ANTHROPIC_TOOL_NAME_RE.test(tool.name));
+        return badTool
+            ? `tool name ${JSON.stringify(badTool.name)} does not match the Messages API's ${String(ANTHROPIC_TOOL_NAME_RE)}`
+            : undefined;
+    }
+    if (item.type !== "message") {
+        return undefined;
+    }
+    return item.content
+        .map((part) => {
+        if (part.type !== "input_image") {
+            return undefined;
+        }
+        if (item.role === "developer") {
+            return "a developer message carries an image, which a text-only system prompt cannot hold";
+        }
+        if (!part.image_url.startsWith("data:")) {
+            // Claude on Vertex takes only inline (base64) image sources; the
+            // Vertex client in providers/googleVertex fetches URLs for the same reason.
+            return provider === "vertex"
+                ? "Claude on Vertex accepts only base64 image sources, not an image URL"
+                : undefined;
+        }
+        const match = DATA_URI_RE.exec(part.image_url);
+        if (!match) {
+            return "an image data URI is not base64-encoded";
+        }
+        const mediaType = normalizeImageMediaType(match[1]);
+        return ANTHROPIC_IMAGE_MEDIA_TYPES.has(mediaType)
+            ? undefined
+            : `image media type ${mediaType} is not one the Messages API accepts (jpeg, png, gif, webp)`;
+    })
+        .find((reason) => reason !== undefined);
+}
+function toolUseIds(message) {
+    return message?.role === "assistant" && Array.isArray(message.content)
+        ? message.content.flatMap((block) => block.type === "tool_use" ? [block.id] : [])
+        : [];
+}
+function toolResultIds(message) {
+    return message?.role === "user" && Array.isArray(message.content)
+        ? message.content.flatMap((block) => block.type === "tool_result" ? [block.tool_use_id] : [])
+        : [];
+}
+// The Messages API requires every tool call to be answered in the very next
+// user turn, and every tool result to answer a call in the turn before it.
+// History pruned on the client side can break either; this catches it here
+// instead of as an upstream 400.
+function describeToolPairingGap(messages) {
+    return messages
+        .map((message, index) => {
+        const answered = toolResultIds(messages[index + 1]);
+        const unanswered = toolUseIds(message).find((id) => !answered.includes(id));
+        if (unanswered) {
+            return `tool call ${unanswered} has no result in the next user turn`;
+        }
+        const called = toolUseIds(messages[index - 1]);
+        const orphaned = toolResultIds(message).find((id) => !called.includes(id));
+        return orphaned
+            ? `tool result for ${orphaned} answers no call in the preceding assistant turn`
+            : undefined;
+    })
+        .find((reason) => reason !== undefined);
+}
+function lastAssistantMessageUsesTool(messages) {
+    const lastAssistant = [...messages]
+        .reverse()
+        .find((message) => message.role === "assistant");
+    return (Array.isArray(lastAssistant?.content) &&
+        lastAssistant.content.some((block) => block.type === "tool_use"));
+}
+// ---------------------------------------------------------------------------
+// §3.2 translateCodexRequestToClaude — the full field-by-field mapping.
+// ---------------------------------------------------------------------------
+export function translateCodexRequestToClaude(request, target) {
+    // Read from client_metadata, not top-level session_id/thread_id: the real
+    // capture carries neither at top level (only nested in client_metadata),
+    // which is why CodexNativeRequest has no top-level fields for them.
+    if ((request.client_metadata?.session_id !== undefined ||
+        request.client_metadata?.thread_id !== undefined) &&
+        !hasFreshSessionPreamble(request.input)) {
+        return {
+            ok: false,
+            error: {
+                code: "SUSPECTED_PARTIAL_HISTORY",
+                message: "a request with session metadata does not open with the additional_tools preamble; refusing to translate what may be an incremental history as if it were complete",
+            },
+        };
+    }
+    const untranslatable = request.input
+        .map((item) => describeUntranslatableItem(item, target.provider))
+        .find((reason) => reason !== undefined);
+    if (untranslatable) {
+        return {
+            ok: false,
+            error: { code: "UNTRANSLATABLE_REQUEST", message: untranslatable },
+        };
+    }
+    // The spec's cardinality rule: when more than one additional_tools item
+    // appears, the last one wins.
+    const additionalTools = request.input
+        .filter((item) => item.type === "additional_tools")
+        .at(-1);
+    const tools = buildClaudeTools(additionalTools);
+    const toolChoice = mapCodexToolChoiceToClaude(request.tool_choice);
+    const forcesTool = toolChoice?.type === "any" || toolChoice?.type === "tool";
+    if (forcesTool && !tools) {
+        return {
+            ok: false,
+            error: {
+                code: "MALFORMED_REQUEST",
+                message: "tool_choice forces a tool call but the request declares no tools",
+            },
+        };
+    }
+    if (toolChoice?.type === "tool" &&
+        !tools?.some((tool) => tool.name === toolChoice.name)) {
+        return {
+            ok: false,
+            error: {
+                code: "MALFORMED_REQUEST",
+                message: `tool_choice names ${JSON.stringify(toolChoice.name)}, which the request does not declare`,
+            },
+        };
+    }
+    const messages = coalesceCodexInputToClaudeMessages(request.input);
+    if (messages[0]?.role !== "user") {
+        return {
+            ok: false,
+            error: {
+                code: "UNTRANSLATABLE_REQUEST",
+                message: "the translated history does not open with a user turn, which the Messages API requires",
+            },
+        };
+    }
+    const pairingGap = describeToolPairingGap(messages);
+    if (pairingGap) {
+        return {
+            ok: false,
+            error: { code: "UNTRANSLATABLE_REQUEST", message: pairingGap },
+        };
+    }
+    const maxTokens = resolveClaudeMaxTokens(target.model, undefined);
+    const systemBlocks = buildSystemBlocksFromDeveloperMessages(request.input);
+    // Thinking is left off in two cases the Messages API would reject: a forced
+    // tool_choice (the same rule oauthFetch.ts applies), and a history whose
+    // final assistant turn calls a tool, which with thinking on must open with a
+    // thinking block. Codex history carries none that can be translated, since
+    // its reasoning is OpenAI ciphertext.
+    const thinking = forcesTool || lastAssistantMessageUsesTool(messages)
+        ? undefined
+        : mapCodexReasoningToThinking(request.reasoning, maxTokens);
+    const claudeRequest = {
+        model: target.model,
+        messages,
+        max_tokens: maxTokens,
+        ...(systemBlocks.length > 0 ? { system: systemBlocks } : {}),
+        ...(tools ? { tools } : {}),
+        // The Messages API accepts tool_choice only alongside tools.
+        ...(toolChoice && tools ? { tool_choice: toolChoice } : {}),
+        ...(thinking ? { thinking } : {}),
+        stream: request.stream ?? true,
+    };
+    return { ok: true, value: claudeRequest };
+}

package/dist/types/codex.d.ts

@@ -11,7 +11,7 @@
  * stored through the same AccountQuota shape as Anthropic — its primary window
  * maps onto the session fields and its secondary window onto the weekly fields.
  */
-import type { AccountCoolingReason, AccountQuota, InternalResult } from "./proxy.js";
+import type { AccountCoolingReason, AccountQuota, ClaudeContentBlock, InternalResult } from "./proxy.js";
 /** Token block inside `~/.codex/auth.json`. */
 export type CodexAuthFileTokens = {
     id_token?: string;
@@ -194,3 +194,139 @@ export type CodexFallbackStream = {
     frames: AsyncGenerator<string, CodexFallbackResult>;
     cancel: (reason?: unknown) => Promise<void>;
 };
+/** Role a native Codex `input` message item can carry. */
+export type CodexNativeRole = "developer" | "user" | "assistant";
+/** A plain message item in a native Codex request's `input` array. */
+export type CodexNativeMessageInputItem = {
+    type: "message";
+    id?: string;
+    role: CodexNativeRole;
+    content: CodexContentPart[];
+};
+/** A tool declaration backed by a JSON Schema, dispatched as a function call. */
+export type CodexNativeFunctionToolDeclaration = {
+    type: "function";
+    name: string;
+    description?: string;
+    strict: boolean;
+    parameters: Record<string, unknown>;
+};
+/** Grammar constraining a custom tool's argument text. */
+export type CodexNativeCustomToolFormat = {
+    type: "grammar";
+    syntax: "lark" | "regex";
+    definition: string;
+};
+/** A tool declaration whose arguments are grammar-constrained free text. */
+export type CodexNativeCustomToolDeclaration = {
+    type: "custom";
+    name: string;
+    description?: string;
+    format: CodexNativeCustomToolFormat;
+};
+/** A single tool declaration, discriminated by its own `type` field. */
+export type CodexNativeToolDeclaration = CodexNativeFunctionToolDeclaration | CodexNativeCustomToolDeclaration;
+/** A named group of tool declarations inside one `additional_tools` item. */
+export type CodexNativeToolNamespace = {
+    type: "namespace";
+    name: string;
+    description: string;
+    tools: CodexNativeToolDeclaration[];
+};
+/** The `input` item carrying every tool declaration for a native Codex request. */
+export type CodexNativeAdditionalToolsInputItem = {
+    type: "additional_tools";
+    id?: string;
+    role: "developer";
+    tools: CodexNativeToolNamespace[];
+};
+/** A model-emitted tool call replayed in a native Codex request's history. */
+export type CodexNativeFunctionCallInputItem = {
+    type: "function_call";
+    call_id: string;
+    name: string;
+    arguments: string;
+};
+/** A client-supplied tool result replayed in a native Codex request's history. */
+export type CodexNativeFunctionCallOutputInputItem = {
+    type: "function_call_output";
+    call_id: string;
+    output: string;
+};
+/** A call to a grammar-constrained (`type:"custom"`) tool, replayed in history. */
+export type CodexNativeCustomToolCallInputItem = {
+    type: "custom_tool_call";
+    id?: string;
+    call_id: string;
+    name: string;
+    input: string;
+};
+/** A client-supplied result for a `custom_tool_call`, replayed in history. */
+export type CodexNativeCustomToolCallOutputInputItem = {
+    type: "custom_tool_call_output";
+    call_id: string;
+    output: string;
+};
+/**
+ * A reasoning item the client echoes back with `store:false`. Its content is
+ * opaque (`encrypted_content` is readable only by the OpenAI backend), so its
+ * shape is deliberately loose beyond the discriminator.
+ */
+export type CodexNativeReasoningInputItem = {
+    type: "reasoning";
+    id?: string;
+    encrypted_content?: string | null;
+    summary?: unknown[];
+};
+/** A single item in a native Codex request's `input` array. */
+export type CodexNativeInputItem = CodexNativeMessageInputItem | CodexNativeAdditionalToolsInputItem | CodexNativeFunctionCallInputItem | CodexNativeFunctionCallOutputInputItem | CodexNativeCustomToolCallInputItem | CodexNativeCustomToolCallOutputInputItem | CodexNativeReasoningInputItem;
+/** How a native Codex request constrains which tool the model may call. */
+export type CodexNativeToolChoice = "auto" | "required" | "none" | {
+    type: "function";
+    name: string;
+};
+/**
+ * A native Codex Responses request, as sent by the real Codex CLI.
+ *
+ * No top-level `session_id`/`thread_id` — real traffic carries neither at
+ * top level, only inside `client_metadata`, which the existing
+ * `Record<string, unknown>` field already covers.
+ */
+export type CodexNativeRequest = {
+    model: string;
+    input: CodexNativeInputItem[];
+    stream: boolean;
+    store: boolean;
+    tool_choice?: CodexNativeToolChoice;
+    parallel_tool_calls?: boolean;
+    reasoning?: {
+        effort: CodexReasoningEffort;
+        context?: string;
+    };
+    include?: string[];
+    text?: {
+        verbosity?: string;
+    };
+    prompt_cache_key?: string;
+    client_metadata?: Record<string, unknown>;
+};
+/**
+ * A `parseCodexNativeRequest`/`translateCodexRequestToClaude` failure. Never thrown.
+ * `UNTRANSLATABLE_REQUEST` is a request Codex itself accepts but Anthropic would
+ * reject, as opposed to one that is invalid on the Codex wire.
+ */
+export type CodexTranslationError = {
+    code: "MALFORMED_REQUEST";
+    message: string;
+} | {
+    code: "SUSPECTED_PARTIAL_HISTORY";
+    message: string;
+} | {
+    code: "UNTRANSLATABLE_REQUEST";
+    message: string;
+};
+/** One coalesced run of same-role content while flattening a native Codex `input` array. */
+export type CodexOutboundMessageGroup = {
+    role: "user" | "assistant";
+    blocks: ClaudeContentBlock[];
+};

package/docs-site/static/search-index.json

@@ -10772,12 +10772,12 @@
 {"objectID":"25e1ac265c89596a09bce35c4ba7b8d82ccf92f016708d1f6f4826b290af00ae","title":"Delivery","url":"/docs/superpowers/specs/2026-09-23-proxy-account-routing-policies-design#delivery","content":"juspay/neurolink merges one commit per PR, so two PRs:\nRefactor, no behaviour change: extract the comparator into accountRanking.ts and count in-flight on the unlimited lease. Proven by the replay and the existing route tests.\nPolicies: headroom-first, prefer-primary, session affinity, spill, config, telemetry, /status, and the documentation correction below.","hierarchy":{"lvl0":"Superpowers","lvl1":"Proxy Account Routing Policies Design","lvl2":"Delivery","lvl3":""}},
 {"objectID":"06eb4e8ea79a4077f7cb445c1ec17985516046ab28d49d3c87b85ade0155f2c1","title":"Documentation","url":"/docs/superpowers/specs/2026-09-23-proxy-account-routing-policies-design#documentation","content":"docs/features/claude-proxy-config-reference.md gains the five keys. The primary-account text and source comments that still say the primary is \"tried first under fill-first\" are corrected: with quota routing the primary is the final tiebreaker unless prefer-primary is set.","hierarchy":{"lvl0":"Superpowers","lvl1":"Proxy Account Routing Policies Design","lvl2":"Documentation","lvl3":""}},
 {"objectID":"1cf022d6f43b961b6fd1c13d8a5677077f9109584a3a5e67d837c4d5f6e613da","title":"Out of scope","url":"/docs/superpowers/specs/2026-09-23-proxy-account-routing-policies-design#out-of-scope","content":"Per-model policies, weighted scoring, persisting affinity across restarts, an account reserve, and changes to cooldown classification, in-stream rate-limit handling or state persistence. Those last three are separate designs.","hierarchy":{"lvl0":"Superpowers","lvl1":"Proxy Account Routing Policies Design","lvl2":"Out of scope","lvl3":""}},
-{"objectID":"f0109d9239beed7372578f5d0ad41b745b321c526407db0d3bbb32adced24e2e","title":"Codex Outbound Fallback — Design","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design","content":"Codex Outbound Fallback — Design\n\nStatus: design complete, implementation not started. Produced by 22 parallel agents\n(6 grounding, 8 design, 8 adversarial review) plus 8 resolution passes; every design\nclaim below was checked against the code by a reviewer whose brief was to refute it.\n\nGoal\n\nA native Codex client request that its own account pool cannot serve currently fails to the\nclient. This design gives the Codex engine an outbound fallback chain to the Anthropic OAuth\npool and to Vertex, so the request is served instead — with prompt caching preserved across\nthe hop, tool calls translated faithfully in both directions, and no client-visible protocol\nanomaly.\n\nEvidence\nsrc/lib/server/routes/codexProxyRoutes.ts has no outbound fallback. Its only fallback\n  references are a string-default helper (line 138) and code recognising when the Codex engine\n  is itself invoked as an inner Anthropic fallback (lines 666, 817, CODEX_FALLBACK_METADATA_KEY\n  at 109). On pool exhaustion it returns a terminal error: buildCodexErrorResponse\n  (1458-1462), or buildCodexQuotaExhaustedResponse (909-914) when every account is already\n  cooling.\nThree directions exist and work: Claude Code → Anthropic pool; Claude/Anthropic → Codex\n  (executeClaudeCodexFallback, claudeProxyRoutes.ts:5499, called at 6131, in-process — no\n  HTTP hop); Claude/Anthropic → Vertex (vertexAnthropicFallback.ts:611, gated on\n  isVertexAnthropicModel, 576).\nThree do not exist: Vertex → Anthropic, native Codex → Anthropic, native Codex →\n  Vertex. PR #1782 fixed translation defects in the existing Claude → Vertex direction; it\n  did not add a reverse path.\nCodex prompt caching is live but partial. proxy_tokens_cache_read by model:\n  gpt-5.6-sol 566,657,536; gpt-6-astra 3,285,888; gpt-5.6-terra 490,752;\n  gpt-5.6-luna 5,888. proxy_tokens_cache_creation is 0 for every Codex series, which is\n  correct — OpenAI caching is automatic and has no explicit write.\nThe caching asymmetry is the central design constraint. Anthropic caching is explicit:\n  up to 4 cache_control breakpoints over a tools → system → messages prefix, write at\n  1.25x base input (5-minute TTL) or 2x (1-hour), read at 0.1x, and each account holds its\n  own cache. A Codex request translated to Anthropic arrives with no breakpoints at all,\n  so it would be cached not at all unless the translator inserts them deliberately.\nSince Claude-on-Vertex speaks the Anthropic Messages wire format, one Codex→Anthropic\n  translator covers both targets. There is no smaller Vertex-only variant of this work.\n\nBuild order\n\nDependency-ordered; each step is one reviewable PR under the one-commit-per-PR policy. Default\noff at every step, so behaviour is byte-for-byte unchanged until the final enable.\n\n| #   | PR                                                                  | Depends on | Gate                                         |\n| --- | ------------------------------------------------------------------- | ---------- | -------------------------------------------- |\n| 1   | IR types + codec contract (src/lib/types/proxyIR.ts)              | —          | typecheck; exhaustiveness is a compile error |\n| 2   | Request codec Codex → Anthropic (codexOutboundFallback.ts)        | 1          | offline shape suite                          |\n| 3   | Response/stream codec Anthropic → Codex                             | 1          | offline event-order suite                    |\n| 4   | Tool fidelity + id correlation                                      | 2, 3       | offline round-trip suite                     |\n| 5   | Cache breakpoints + prefix byte-stability (codexOutboundCache.ts) | 2          | byte-stability assertion across two turns    |\n| 6   | Trigger policy, commitment rule, loop prevention, accounting        | 2-4        | totality + commitment suites                 |\n| 7   | Config keys, kill switch, metrics                                   | 6          | config validation suite                      |\n| 8   | Enable + live model matrix                                          | all        | live pass criteria                           |\n\nOpen questions gating the build\n\nEvery one needs the same thing: real captured native Codex traffic. The repo has 4 synthetic\nfixtures, one real single-turn capture (~/.neurolink/reference/codex-cli-wire-sample.json,\ncaptured 2026-09-21), a real usage-frame capture (test/fixtures/codex-response-usage.sse,\ncaptured 2026-08-21), and one real controlled bisection experiment against the actual\ncodex_exec/0.155.1 binary (scripts/codex-replay-listener.ts, test/fixtures/sse-bisection-findings.md,\nrun 2026-09-27). Two questions are now settled; the rest are listed here because they can still\ninvalidate a whole section, so they should be settled before the PRs that depend on them are\nwritten.\n\n| Question                                                                                       | Blocks  | Settled by                                                    |\n| ---------","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"","lvl3":""}},
+{"objectID":"f0109d9239beed7372578f5d0ad41b745b321c526407db0d3bbb32adced24e2e","title":"Codex Outbound Fallback — Design","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design","content":"Codex Outbound Fallback — Design\n\nStatus: design complete, implementation not started. Produced by 22 parallel agents\n(6 grounding, 8 design, 8 adversarial review) plus 8 resolution passes; every design\nclaim below was checked against the code by a reviewer whose brief was to refute it.\n\nGoal\n\nA native Codex client request that its own account pool cannot serve currently fails to the\nclient. This design gives the Codex engine an outbound fallback chain to the Anthropic OAuth\npool and to Vertex, so the request is served instead — with prompt caching preserved across\nthe hop, tool calls translated faithfully in both directions, and no client-visible protocol\nanomaly.\n\nEvidence\nsrc/lib/server/routes/codexProxyRoutes.ts has no outbound fallback. Its only fallback\n  references are a string-default helper (line 138) and code recognising when the Codex engine\n  is itself invoked as an inner Anthropic fallback (lines 666, 817, CODEX_FALLBACK_METADATA_KEY\n  at 109). On pool exhaustion it returns a terminal error: buildCodexErrorResponse\n  (1458-1462), or buildCodexQuotaExhaustedResponse (909-914) when every account is already\n  cooling.\nThree directions exist and work: Claude Code → Anthropic pool; Claude/Anthropic → Codex\n  (executeClaudeCodexFallback, claudeProxyRoutes.ts:5499, called at 6131, in-process — no\n  HTTP hop); Claude/Anthropic → Vertex (vertexAnthropicFallback.ts:611, gated on\n  isVertexAnthropicModel, 576).\nThree do not exist: Vertex → Anthropic, native Codex → Anthropic, native Codex →\n  Vertex. PR #1782 fixed translation defects in the existing Claude → Vertex direction; it\n  did not add a reverse path.\nCodex prompt caching is live but partial. proxy_tokens_cache_read by model:\n  gpt-5.6-sol 566,657,536; gpt-6-astra 3,285,888; gpt-5.6-terra 490,752;\n  gpt-5.6-luna 5,888. proxy_tokens_cache_creation is 0 for every Codex series, which is\n  correct — OpenAI caching is automatic and has no explicit write.\nThe caching asymmetry is the central design constraint. Anthropic caching is explicit:\n  up to 4 cache_control breakpoints over a tools → system → messages prefix, write at\n  1.25x base input (5-minute TTL) or 2x (1-hour), read at 0.1x, and each account holds its\n  own cache. A Codex request translated to Anthropic arrives with no breakpoints at all,\n  so it would be cached not at all unless the translator inserts them deliberately.\nSince Claude-on-Vertex speaks the Anthropic Messages wire format, one Codex→Anthropic\n  translator covers both targets. There is no smaller Vertex-only variant of this work.\n\nBuild order\n\nDependency-ordered; each step is one reviewable PR under the one-commit-per-PR policy. Default\noff at every step, so behaviour is byte-for-byte unchanged until the final enable.\n\n| #   | PR                                                                  | Depends on | Gate                                         |\n| --- | ------------------------------------------------------------------- | ---------- | -------------------------------------------- |\n| 1   | IR types + codec contract (src/lib/types/proxyIR.ts)              | —          | typecheck; exhaustiveness is a compile error |\n| 2   | Request codec Codex → Anthropic (codexOutboundFallback.ts)        | 1          | offline shape suite                          |\n| 3   | Response/stream codec Anthropic → Codex                             | 1          | offline event-order suite                    |\n| 4   | Tool fidelity + id correlation                                      | 2, 3       | offline round-trip suite                     |\n| 5   | Cache breakpoints + prefix byte-stability (codexOutboundCache.ts) | 2          | byte-stability assertion across two turns    |\n| 6   | Trigger policy, commitment rule, loop prevention, accounting        | 2-4        | totality + commitment suites                 |\n| 7   | Config keys, kill switch, metrics                                   | 6          | config validation suite                      |\n| 8   | Enable + live model matrix                                          | all        | live pass criteria                           |\n\nOpen questions gating the build\n\nEvery one needs the same thing: real captured native Codex traffic. The repo has 4 synthetic\nfixtures, one real single-turn capture (~/.neurolink/reference/codex-cli-wire-sample.json,\ncaptured 2026-09-21), a real usage-frame capture (test/fixtures/codex-response-usage.sse,\ncaptured 2026-08-21), and one real controlled bisection experiment against the actual\ncodex_exec/0.155.1 binary (scripts/codex-replay-listener.ts, test/fixtures/sse-bisection-findings.md,\nrun 2026-09-27). Two questions are now settled; the rest are listed here because they can still\ninvalidate a whole section, so they should be settled before the PRs that depend on them are\nwritten.\n\n| Question                                                                                       | Blocks  | Settled by                                                                 ","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"","lvl3":""}},
 {"objectID":"6034ef59cb5b3d2520fa92f2f181aca534a58aa28338f3411aa9d28d998e487e","title":"Codex Outbound Fallback — Design","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#codex-outbound-fallback-design","content":"Status: design complete, implementation not started. Produced by 22 parallel agents\n(6 grounding, 8 design, 8 adversarial review) plus 8 resolution passes; every design\nclaim below was checked against the code by a reviewer whose brief was to refute it.","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Codex Outbound Fallback — Design","lvl3":""}},
 {"objectID":"580c5a06163d1e603bb34f5f3b51c78e4efa36e12426cf22b63706680af0ea56","title":"Goal","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#goal","content":"A native Codex client request that its own account pool cannot serve currently fails to the\nclient. This design gives the Codex engine an outbound fallback chain to the Anthropic OAuth\npool and to Vertex, so the request is served instead — with prompt caching preserved across\nthe hop, tool calls translated faithfully in both directions, and no client-visible protocol\nanomaly.","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Goal","lvl3":""}},
 {"objectID":"ed180fb4ca61ad0027c4359503ac6ea54b391281020d32b2a9b498cd6c83abeb","title":"Evidence","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#evidence","content":"src/lib/server/routes/codexProxyRoutes.ts has no outbound fallback. Its only fallback\n  references are a string-default helper (line 138) and code recognising when the Codex engine\n  is itself invoked as an inner Anthropic fallback (lines 666, 817, CODEX_FALLBACK_METADATA_KEY\n  at 109). On pool exhaustion it returns a terminal error: buildCodexErrorResponse\n  (1458-1462), or buildCodexQuotaExhaustedResponse (909-914) when every account is already\n  cooling.\nThree directions exist and work: Claude Code → Anthropic pool; Claude/Anthropic → Codex\n  (executeClaudeCodexFallback, claudeProxyRoutes.ts:5499, called at 6131, in-process — no\n  HTTP hop); Claude/Anthropic → Vertex (vertexAnthropicFallback.ts:611, gated on\n  isVertexAnthropicModel, 576).\nThree do not exist: Vertex → Anthropic, native Codex → Anthropic, native Codex →\n  Vertex. PR #1782 fixed translation defects in the existing Claude → Vertex direction; it\n  did not add a reverse path.\nCodex prompt caching is live but partial. proxy_tokens_cache_read by model:\n  gpt-5.6-sol 566,657,536; gpt-6-astra 3,285,888; gpt-5.6-terra 490,752;\n  gpt-5.6-luna 5,888. proxy_tokens_cache_creation is 0 for every Codex series, which is\n  correct — OpenAI caching is automatic and has no explicit write.\nThe caching asymmetry is the central design constraint. Anthropic caching is explicit:\n  up to 4 cache_control breakpoints over a tools → system → messages prefix, write at\n  1.25x base input (5-minute TTL) or 2x (1-hour), read at 0.1x, and each account holds its\n  own cache. A Codex request translated to Anthropic arrives with no breakpoints at all,\n  so it would be cached not at all unless the translator inserts them deliberately.\nSince Claude-on-Vertex speaks the Anthropic Messages wire format, one Codex→Anthropic\n  translator covers both targets. There is no smaller Vertex-only variant of this work.","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Evidence","lvl3":""}},
 {"objectID":"a5aa19ce68fa1175c4bade50ae303cc0a954bf1128588e294af993c049e2f466","title":"Build order","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#build-order","content":"Dependency-ordered; each step is one reviewable PR under the one-commit-per-PR policy. Default\noff at every step, so behaviour is byte-for-byte unchanged until the final enable.\n\n| #   | PR                                                                  | Depends on | Gate                                         |\n| --- | ------------------------------------------------------------------- | ---------- | -------------------------------------------- |\n| 1   | IR types + codec contract (src/lib/types/proxyIR.ts)              | —          | typecheck; exhaustiveness is a compile error |\n| 2   | Request codec Codex → Anthropic (codexOutboundFallback.ts)        | 1          | offline shape suite                          |\n| 3   | Response/stream codec Anthropic → Codex                             | 1          | offline event-order suite                    |\n| 4   | Tool fidelity + id correlation                                      | 2, 3       | offline round-trip suite                     |\n| 5   | Cache breakpoints + prefix byte-stability (codexOutboundCache.ts) | 2          | byte-stability assertion across two turns    |\n| 6   | Trigger policy, commitment rule, loop prevention, accounting        | 2-4        | totality + commitment suites                 |\n| 7   | Config keys, kill switch, metrics                                   | 6          | config validation suite                      |\n| 8   | Enable + live model matrix                                          | all        | live pass criteria                           |","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Build order","lvl3":""}},
-{"objectID":"db4fcb5c145b85c8e756be096fdda4d88c5f6fc576ec62653a8545735ff1a653","title":"Open questions gating the build","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#open-questions-gating-the-build","content":"Every one needs the same thing: real captured native Codex traffic. The repo has 4 synthetic\nfixtures, one real single-turn capture (~/.neurolink/reference/codex-cli-wire-sample.json,\ncaptured 2026-09-21), a real usage-frame capture (test/fixtures/codex-response-usage.sse,\ncaptured 2026-08-21), and one real controlled bisection experiment against the actual\ncodex_exec/0.155.1 binary (scripts/codex-replay-listener.ts, test/fixtures/sse-bisection-findings.md,\nrun 2026-09-27). Two questions are now settled; the rest are listed here because they can still\ninvalidate a whole section, so they should be settled before the PRs that depend on them are\nwritten.\n\n| Question                                                                                       | Blocks  | Settled by                                                    |\n| ---------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------- |\n| Does the real Codex CLI accept a call_id it did not mint (a toolu_-shaped id)?             | PR 4    | SETTLED (2026-09-27) — yes, verbatim. codex-replay-listener.ts --script tool-call against real codex_exec/0.155.1: the CLI's follow-up function_call_output carried call_id: \"toolu_replay0000000000000000\" unmodified (own id field is CLI-minted fco_-prefixed; call_id is untouched). See test/fixtures/sse-bisection-findings.md, \"tool-call script — real result\". |\n| Does Anthropic/Vertex accept a non-toolu_-shaped tool_use.id in history?                   | PR 4    | one live call with such an id in history — still open; the bisection listener above can't test this direction (it stands in for the Codex backend, not Anthropic's) |\n| Are the developer-role prefix blocks byte-identical turn to turn?                              | PR 5    | capture 2 turns of one session, diff input[0..4] — still open; the 2026-09-21 capture is single-turn |\n| Does a genuine first-turn request omit al","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Open questions gating the build","lvl3":""}},
+{"objectID":"db4fcb5c145b85c8e756be096fdda4d88c5f6fc576ec62653a8545735ff1a653","title":"Open questions gating the build","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#open-questions-gating-the-build","content":"Every one needs the same thing: real captured native Codex traffic. The repo has 4 synthetic\nfixtures, one real single-turn capture (~/.neurolink/reference/codex-cli-wire-sample.json,\ncaptured 2026-09-21), a real usage-frame capture (test/fixtures/codex-response-usage.sse,\ncaptured 2026-08-21), and one real controlled bisection experiment against the actual\ncodex_exec/0.155.1 binary (scripts/codex-replay-listener.ts, test/fixtures/sse-bisection-findings.md,\nrun 2026-09-27). Two questions are now settled; the rest are listed here because they can still\ninvalidate a whole section, so they should be settled before the PRs that depend on them are\nwritten.\n\n| Question                                                                                       | Blocks  | Settled by                                                                                                                                                                                                                                                                                                                                                                                    |\n| ---------------------------------------------------------------------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Does the real Codex CLI accept a call_id it did not mint (a toolu_-shaped id)?             | PR 4    | SETTLED (2026-09-27) — yes, verbatim. codex-replay-listener.ts --script tool-call against real codex_exec/0.155.1: the CLI's follow-up function_call_output carried call_id: \"toolu_replay0000000000000000\" unmodified (own id field is CLI-minted fco_-","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Open questions gating the build","lvl3":""}},
 {"objectID":"a85c34c0265b0c27d696611075427124ef72062ef3e1248bf75ddc2f859229d0","title":"Contents","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#contents","content":"Translation layer: canonical IR and codec contract\nRequest translation: Codex Responses → Anthropic Messages\nResponse translation: Anthropic → Codex wire format\nTool-call fidelity in both directions\nPreserving prompt caching across the hop\nTrigger policy, commitment safety, loop prevention, accounting\nConfiguration surface and staged rollout\nValidation plan","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Contents","lvl3":""}},
 {"objectID":"62546125e30c54bebd2104e396943d1fb60478f7d22873e75792c81c408d2791","title":"Consolidated unresolved items","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#consolidated-unresolved-items","content":"ir-and-types — whether native Codex ever sends top-level reasoning/tools on a genuine inbound request — the one check that would settle it is a live-captured native Codex CLI request with non-default reasoning effort set.\nir-and-types — whether Anthropic's live API ever rejects consecutive same-role messages in some edge case — the one check that would settle it is a probe request against the real API with two consecutive user messages.\nir-and-types — the storage/lifetime contract for a resumed session's id map spanning multiple proxy requests — the one check that would settle it is reading how originSessionId/originThreadId are persisted by the session-affinity\nir-and-types — above.\nrequest-translation — in §10. It converts an unknown into a loud, caller-visible failure instead of a silent one, which is what the \"nothing may break silently\" requirement demands even without live traffic.\nrequest-translation — whether additional_tools/developer items can appear anywhere other than before the first user item in real traffic — the one check that would settle it: capture one real Codex CLI multi-turn session with a mid-conv\nrequest-translation — whether a resumed-session request's input is genuinely full-history or incremental — the one check that would settle it: capture one real resumed-session Codex Responses request (the referenced ~/.neurolink/reference/\n- **request-translation** — whether toolchoice or reasoning ever appear on genuine inbound requests at all (absent from all 4 fixtures) — the one check that would settle it: grep captured production Codex traffic logs (once available) for eith\n- **request-translation** — whether more than one additionaltools item can appear in one request — the one check that would settle it: same real-traffic capture as (1).\n- **response-translation** — a genuine live-captured native Codex Responses SSE transcript (text, tool-call, incomplete/error cases) — the check that would settle it is running a real Codex client through this","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Consolidated unresolved items","lvl3":""}},
 {"objectID":"b890fc666ae87c04302cb9122b852c6e394f3a6eb3ad2c2a3b90aed60a49e057","title":"Decision (kept)","url":"/docs/superpowers/specs/2026-09-27-codex-outbound-fallback-design#decision-kept","content":"Single canonical IR, not ClaudeRequest-as-hub, not pairwise codecs. Verified: openaiFormat.ts/geminiFormat.ts already use ClaudeRequest as an implicit hub only because it is also the literal Anthropic wire type; codexFallback.ts already needs a role cast ((message.role as string) !== \"system\", line 154) to special-case Claude Code's inline-system convention inside a converter meant to be neutral. A new file, src/lib/types/proxyIR.ts, holds a real wire-neutral IR. ClaudeRequest/ClaudeResponse (proxy.ts:154, :187) stay untouched — the Anthropic hot path (claudeProxyRoutes.ts) never changes.\n\nVertex needs no separate codec. Confirmed: executeVertexAnthropicFallback (vertexAnthropicFallback.ts:605-665) forwards the upstream body/stream untouched with a code comment that it is \"already Anthropic-shaped\"; buildVertexAnthropicPayload (line 399) only strips UNSUPPORTED_FIELDS = [\"model\", \"context_management\"] (line 42). Vertex reuses anthropicMessagesIRCodec.buildRequest's output as-is.","hierarchy":{"lvl0":"Superpowers","lvl1":"Codex Outbound Fallback — Design","lvl2":"Decision (kept)","lvl3":""}},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.35.5",
+  "version": "12.36.0",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {