@juspay/neurolink 12.36.1 → 12.37.1

package/dist/proxy/codexResponsesFormat.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Wire-format translation: Anthropic `ClaudeResponse` shape -> the Codex
+ * Responses shape a native Codex client expects.
+ *
+ * Pure wire-format only — no account selection, retry policy, or transport.
+ * Mirrors `claudeFormat.ts`'s role for the opposite direction: that module
+ * serializes NeuroLink's internal result into Claude SSE, this one serializes
+ * an already-Claude-shaped result into Codex SSE (or one JSON envelope).
+ */
+import type { ClaudeContentBlock, ClaudeResponse, ClaudeUsage, CodexNativeToolKind, CodexResponseEnvelope, CodexResponseItem, CodexResponseUsage } from "../types/index.js";
+/** Same idiom as `generateToolUseId` (`claudeFormat.ts`), Codex's own prefix. */
+export declare function generateCodexResponseId(): string;
+/** Item ids are prefixed by kind so a client can tell message/tool items apart at a glance. */
+export declare function generateCodexItemId(kind: "message" | "function_call" | "custom_tool_call"): string;
+/**
+ * Reuse the Anthropic `tool_use.id` (`toolu_...`) verbatim as the Codex `call_id`.
+ * No id-mapping table exists anywhere in this codebase's translation modules, and
+ * nothing on the way in validates `call_id` format — see the design doc's §5 for
+ * the full reasoning and its one unresolved edge (a real, non-fallback Codex
+ * backend rejecting a non-`call_`-prefixed id on a later turn).
+ */
+export declare function codexCallIdFromToolUseId(toolUseId: string): string;
+/**
+ * Absent cache fields are omitted rather than zeroed (never conflate "not
+ * observed" with "observed as zero" — the field's own doc comment on
+ * `CodexResponseUsage` states this contract).
+ */
+export declare function synthesizeCodexUsage(usage: ClaudeUsage): CodexResponseUsage;
+/**
+ * Shared by the streaming serializer's non-failure item close and the
+ * non-streaming path (`serializeCodexResponse`), so item shape is defined
+ * once. Always produces a "completed" item — the streaming failure path
+ * (an item closed "incomplete" mid-turn) builds its item directly, since it
+ * must preserve the raw accumulated text/argument bytes rather than a value
+ * reconstructed through this function.
+ */
+export declare function buildCodexResponseItem(block: ClaudeContentBlock, itemId: string, toolKindByName?: ReadonlyMap<string, CodexNativeToolKind>): CodexResponseItem | null;
+/** Non-streaming path: `§7` of the design — the document root IS a `CodexResponseEnvelope`. */
+export declare function serializeCodexResponse(result: ClaudeResponse, requestModel: string, toolKindByName?: ReadonlyMap<string, CodexNativeToolKind>): CodexResponseEnvelope;
+/**
+ * Push-based streaming serializer. A genuinely incremental tool-call-argument
+ * path (`openToolCall`/`pushToolCallArgsDelta`/`closeToolCall`) forwards each
+ * raw `input_json_delta` chunk as it arrives rather than buffering the whole
+ * call before emitting anything — `partial_json` is not individually valid
+ * JSON, so a serializer that validated per-chunk could not do this.
+ */
+export declare class CodexResponsesStreamSerializer {
+    private readonly model;
+    private readonly toolKindByName;
+    private state;
+    private readonly responseId;
+    private outputIndex;
+    private openKind;
+    private openItemId;
+    private textAccum;
+    private argsAccum;
+    private toolCallId;
+    private toolName;
+    private readonly closedItems;
+    private terminalEnvelope;
+    constructor(model: string, toolKindByName?: ReadonlyMap<string, CodexNativeToolKind>);
+    start(): Generator<string>;
+    pushDelta(text: string): Generator<string>;
+    /** Opens the tool-call item header at content_block_start, before any argument text
+     *  is known — mirrors what content_block_start already gives us (id, name). A tool
+     *  the request declared `custom` opens as a `custom_tool_call` item. */
+    openToolCall(toolUseId: string, name: string): Generator<string>;
+    /** Forwards one raw partial_json fragment as-is — no JSON.parse here, because a lone
+     *  fragment is not required to be valid JSON on its own. A custom call's fragments
+     *  are the `{"input":"..."}` wrapper, not client text, so they are only buffered;
+     *  `closeToolCall` emits the unwrapped input once the whole wrapper is known. */
+    pushToolCallArgsDelta(rawChunk: string): Generator<string>;
+    /**
+     * Public close for a tool-use block at `content_block_stop`. A no-op when no
+     * tool-call item is open, so a driver can call it unconditionally.
+     * Validates the accumulated arguments once, here — the one place validity
+     * is required. Throws on malformed JSON; the caller must catch and route to
+     * `emitFailure` (never swallowed, never retried after this point).
+     */
+    closeToolCall(): Generator<string>;
+    /**
+     * Public close for a text block at `content_block_stop`, mirroring
+     * `closeToolCall`'s role for the message item. A no-op when no message item
+     * is open, so a driver can call it unconditionally alongside `closeToolCall`
+     * without first inspecting which kind is currently open.
+     */
+    closeTextBlock(): Generator<string>;
+    finish(stopReason: string | null, usage: ClaudeUsage): Generator<string, CodexResponseEnvelope>;
+    /**
+     * Post-commit terminal path. Closes any open item as "incomplete" — now
+     * representable via `CodexResponseItemStatus` — then emits a single
+     * `response.failed`. Idempotent: a second call after this one already ran
+     * returns the same envelope without emitting further frames, so a driver
+     * that reaches it defensively from more than one place never double-emits.
+     */
+    emitFailure(_status: number, message: string, code?: string): Generator<string, CodexResponseEnvelope>;
+    private assertNotTerminal;
+    /**
+     * The custom-kind close: nothing was streamed live, so one input delta
+     * carries the whole unwrapped input, then its done event. Lenient where the
+     * function path throws: the wrapper is Claude's own output for the
+     * single-field schema `mapCodexCustomToolToClaude` declared, so a parse
+     * failure is an internal bug, and the raw accumulated text is emitted rather
+     * than failing the turn over it.
+     */
+    private closeCustomToolCall;
+    private openMessage;
+    /** Closes whichever item is currently open, as "incomplete" when `failed`. */
+    private closeOpenItem;
+    /**
+     * The failure-close counterpart to `closeToolCall`. Arguments are carried
+     * verbatim from `argsAccum` and never re-validated — `JSON.parse` is not
+     * called on the failure path, and no `function_call_arguments.done` is
+     * emitted, since the arguments never reached a validated, complete state.
+     */
+    private closeFailedFunctionCall;
+    /**
+     * The failure close for a custom call. Its accumulated bytes are Anthropic's
+     * JSON wrapper, not the client's grammar text, so `input` is the unwrapped
+     * string when the wrapper already parses and "" otherwise — an incomplete
+     * item is never executed. No input done event, as on the function path.
+     */
+    private closeFailedCustomToolCall;
+    private closeMessageItem;
+}