@askalf/dario 6.2.0 → 6.3.0

package/dist/responses-inbound.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Inbound OpenAI Responses API (v6.3) — `POST /v1/responses` on dario.
+ *
+ * Codex CLI 0.154 dropped `wire_api = "chat"` (openai/codex discussion 7782):
+ * a custom provider must speak the Responses API or it cannot be used at all.
+ * The OpenAI Agents SDK and everything newer from OpenAI speak the same shape.
+ * This module makes dario a Responses endpoint, so those clients run on a
+ * Claude subscription — and on a ChatGPT one, through the codex leg.
+ *
+ * Shape of the work: the request is translated ONCE at the front door into
+ * the Anthropic Messages body every other dario path already understands
+ * (`responsesRequestToAnthropic`), the request then runs as an ordinary
+ * Anthropic-shape request — pool, template, codex leg, mid-stream
+ * continuation, all of it — and every byte written back to the client passes
+ * through `ResponsesOut`, which turns Anthropic SSE (or a buffered Anthropic
+ * message, or an Anthropic error body) into the Responses wire shape. Nothing
+ * downstream of the front door knows the client is a Responses client.
+ *
+ * The reverse direction — an Anthropic-shape request served by the codex
+ * backend — has lived in anthropic-responses-translate.ts since 5.5.87. The
+ * two translators share types and nothing else on purpose: each direction is
+ * read against the wire captures that motivated it.
+ *
+ * What is dropped, and said so once per process at verbose: hosted tool types
+ * the pool cannot run (`web_search`, `file_search`, `mcp`, …), `reasoning`
+ * items on the way in (the encrypted content is OpenAI's, and the pool does
+ * not need them back), `text.format`, `previous_response_id` (dario is
+ * stateless; a 400, not a silent ignore).
+ */
+import type { ServerResponse } from 'node:http';
+export interface InboundTranslation {
+    body: Record<string, unknown>;
+    /** Things that did not survive the translation, one line each. */
+    warnings: string[];
+    /**
+     * Request features the Messages shape has no honest answer for — the
+     * route that serves the request decides what to do: the codex passthrough
+     * forwards the original body and never sees this; the Claude pool answers
+     * a 400 naming the field rather than silently ignoring it.
+     */
+    unsupported: string[];
+}
+export declare class ResponsesRequestError extends Error {
+    readonly param?: string | undefined;
+    constructor(message: string, param?: string | undefined);
+}
+/**
+ * The Responses request as the Anthropic Messages body the rest of dario
+ * serves. Throws ResponsesRequestError for shapes that cannot be served
+ * honestly (no model, no input, `previous_response_id`).
+ */
+export declare function responsesRequestToAnthropic(req: Record<string, unknown>): InboundTranslation;
+/** The 400 the Claude pool answers for a Responses feature it cannot serve. */
+export declare function unsupportedOnClaudeError(field: string): Record<string, unknown>;
+/** A buffered Anthropic message → a Responses response object. */
+export declare function anthropicMessageToResponses(msg: Record<string, unknown>, createdAt?: number): Record<string, unknown>;
+/** An Anthropic error body → the OpenAI error envelope. */
+export declare function anthropicErrorToResponses(body: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Anthropic SSE → Responses SSE, incrementally. One instance per response.
+ * Comments (`: dario continuation …`) ride through untouched; `ping` is
+ * dropped; `error` becomes `response.failed` + an `error` event.
+ */
+export declare class ResponsesOutStream {
+    private seq;
+    private id;
+    private createdAt;
+    private model;
+    private started;
+    private readonly output;
+    private readonly open;
+    private usage;
+    private stopReason;
+    private done;
+    private readonly splitter;
+    constructor(requestModel: string);
+    private ev;
+    private snapshot;
+    feed(chunk: string | Uint8Array): string;
+    /** Whatever is still buffered (a partial frame) — nothing a Responses client can use. */
+    end(): string;
+    get finished(): boolean;
+    private frame;
+    private blockStart;
+    private blockDelta;
+    private blockStop;
+}
+/**
+ * Everything dario writes to a Responses client passes through here. The
+ * first bytes decide the mode: SSE frames are translated as they arrive; a
+ * JSON body (a buffered message, or an error) is held and translated at end().
+ */
+export declare class ResponsesOut {
+    private mode;
+    private json;
+    private readonly stream;
+    private readonly decoder;
+    constructor(requestModel: string);
+    write(chunk: string | Uint8Array): string;
+    end(): string;
+}
+/**
+ * The ServerResponse a Responses client is served through: every write is
+ * translated, everything else reaches the real response untouched (headers,
+ * events, `writableEnded`, `destroyed`). Bound methods, so `res.on('close')`
+ * and friends keep working on the real object.
+ */
+export declare function wrapResponsesClient(res: ServerResponse, out: ResponsesOut): ServerResponse;