@askalf/dario 6.2.1 → 6.4.0

package/dist/proxy.js

@@ -24,9 +24,10 @@ import { loadAllAccounts, loadAccount, saveAccount, refreshAccountToken, resyncL
 import { handleAdminRequest } from './admin-api.js';
 import { createTokenBucket } from './rate-limit.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
-import { forwardToCodex, getCodexModelSlugs, peekCodexModelSlugs, isCodexModel, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
+import { forwardToCodex, forwardResponsesToCodex, getCodexModelSlugs, peekCodexModelSlugs, isCodexModel, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
 import { effortForCodex } from './effort.js';
 import { MidstreamGuard, guardFor, loopbackBaseFor, chaosCutFetch, chaosCutState, CONTINUATION_HEADER, MAX_CONTINUATION_DEPTH, continuationDepth } from './midstream.js';
+import { responsesRequestToAnthropic, unsupportedOnClaudeError, ResponsesRequestError, ResponsesOut, wrapResponsesClient } from './responses-inbound.js';
 import { isClaudeServableModel } from './claude-model.js';
 import { MODEL_UNROUTABLE } from './upstream-rejection.js';
 import { readCompareTarget, teeResponse, runCompare, writeCompareRecord, COMPARE_RESULT_HEADER } from './compare.js';
@@ -609,6 +610,9 @@ export function resolveProxyTarget(urlPath, isOpenAI) {
         return { target: `${ANTHROPIC_API}/v1/messages?beta=true`, thin: false };
     const allowed = {
         '/v1/messages': { target: `${ANTHROPIC_API}/v1/messages?beta=true`, thin: false },
+        // OpenAI Responses shape (v6.3, src/responses-inbound.ts): translated to
+        // a Messages body at the front door, served like any Anthropic request.
+        '/v1/responses': { target: `${ANTHROPIC_API}/v1/messages?beta=true`, thin: false },
         '/v1/messages/count_tokens': { target: `${ANTHROPIC_API}/v1/messages/count_tokens`, thin: true },
         '/v1/complete': { target: `${ANTHROPIC_API}/v1/complete`, thin: false },
     };
@@ -2602,6 +2606,17 @@ export async function startProxy(opts = {}) {
         }
         // Detect OpenAI-format requests
         const isOpenAI = urlPath === '/v1/chat/completions';
+        // A Responses-API client (Codex CLI, the OpenAI Agents SDK). Its request
+        // becomes an Anthropic Messages body below and everything written back to
+        // it is translated at the write boundary — from here on `res` IS that
+        // boundary, so even a pre-upstream error reaches the client in its shape.
+        const isResponses = urlPath === '/v1/responses';
+        const responsesOut = isResponses ? new ResponsesOut('') : null;
+        // The untranslated response, for the one path that answers a Responses
+        // client in its own shape without translation: the codex passthrough.
+        const rawRes = res;
+        if (responsesOut)
+            res = wrapResponsesClient(res, responsesOut);
         // Allowlisted API paths — only these are proxied (prevents SSRF).
         // count_tokens forwards thin (no template injection) — see resolveProxyTarget.
         const route = resolveProxyTarget(urlPath, isOpenAI);
@@ -2966,7 +2981,7 @@ export async function startProxy(opts = {}) {
             // (aliases, prefixes, the CC template); a mid-stream continuation
             // re-issues the CLIENT's request, not the rewritten one, so dario's own
             // rules apply to the resume the same way they applied to the original.
-            const clientBodyBytes = body;
+            let clientBodyBytes = body;
             // How deep in a continuation chain this request sits: 0 for a client
             // request, 1 for its resume, 2 for the resume of that resume — which is
             // never continued itself (MAX_CONTINUATION_DEPTH).
@@ -3084,6 +3099,45 @@ export async function startProxy(opts = {}) {
                     return;
                 }
             }
+            // Responses shape → Messages shape, once, before any routing peeks at
+            // the body. The translated body is what a continuation re-issues too:
+            // the loopback goes to /v1/messages, which is what this body now is.
+            // The client's Responses body as written — a ChatGPT-subscription model
+            // gets it verbatim (forwardResponsesToCodex), every other route gets the
+            // translation.
+            let responsesBodyRaw = null;
+            // NOTHING IS REFUSED HERE. Routing has not happened yet, so the
+            // translation only RECORDS what the Messages shape cannot carry
+            // (`t.unsupported`, e.g. previous_response_id). The route decides: the
+            // codex passthrough below forwards `responsesBodyRaw` untouched, so a
+            // stateful follow-up on a ChatGPT-subscription model reaches the backend
+            // that keeps state; only the Claude path, after the codex branch has
+            // passed on the request, answers a 400 naming the field. Both halves are
+            // asserted in test/responses-inbound-wiring.mjs ("previous_response_id
+            // on a ChatGPT-subscription model → forwarded untouched").
+            let responsesUnsupported = [];
+            if (isResponses && parsedBody !== null) {
+                try {
+                    responsesBodyRaw = parsedBody;
+                    const t = responsesRequestToAnthropic(parsedBody);
+                    if (verbose && t.warnings.length > 0)
+                        console.log(`[dario] #${requestCount} /v1/responses: ${t.warnings.join('; ')}`);
+                    responsesUnsupported = t.unsupported;
+                    parsedBody = t.body;
+                    body = Buffer.from(JSON.stringify(t.body));
+                    clientBodyBytes = body;
+                }
+                catch (err) {
+                    // Only the translator's own verdicts reach the client; anything else
+                    // is an internal failure and says so without its message.
+                    const known = err instanceof ResponsesRequestError;
+                    if (!known && verbose)
+                        console.error(`[dario] #${requestCount} /v1/responses translation failed: ${sanitizeError(err)}`);
+                    res.writeHead(400, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
+                    res.end(JSON.stringify({ error: { message: known ? err.message : 'request could not be translated', type: 'invalid_request_error', param: known ? err.param ?? null : null, code: null } }));
+                    return;
+                }
+            }
             // Provider prefix (v3.10.0). If the body's model field is `<provider>:<model>`
             // with a recognized prefix, strip the prefix and force routing regardless of
             // regex. CLI-level `--model=<provider>:<name>` applies the same override
@@ -3412,14 +3466,13 @@ export async function startProxy(opts = {}) {
                                 },
                             })
                             : null;
-                        const served = codexAvailable && await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic', codexFetch, canDefer, 
                         // Before this hook a codex request left no trace: nothing in
                         // /analytics, nothing in the request log, no per-account count.
                         // The dock (and anyone reading /analytics) saw a proxy that
                         // served GPT all day and reported zero of it. A decline (the
                         // request handed to the Claude pool) reports nothing here; the
                         // Claude path records what it then serves.
-                        (o) => {
+                        const codexOnDone = (o) => {
                             codexRequestCounts.set(o.alias, (codexRequestCounts.get(o.alias) ?? 0) + 1);
                             analytics.record({
                                 timestamp: Date.now(),
@@ -3448,16 +3501,25 @@ export async function startProxy(opts = {}) {
                                     inputTokens: o.inputTokens, outputTokens: o.outputTokens,
                                     cacheReadTokens: o.cacheReadTokens, cacheCreateTokens: o.cacheCreateTokens,
                                 }, consumer));
-                        }, 
-                        // Cool codex on a rate limit only — a 5xx or an unreachable backend
-                        // is an outage, and parking a provider for that would keep it out
-                        // of the chain while it was already coming back.
-                        (d) => { if (d.status === 429)
-                            providerCooldowns.note('codex', d.retryAfterMs); }, 
-                        // dario#1260 — the effort named by the model-name suffix stripped
-                        // above. Undefined for every request that did not name one, which
-                        // leaves the outbound body exactly as it was.
-                        effortForCodex(requestEffort), codexGuard);
+                        };
+                        // A Responses client on a ChatGPT-subscription model: the backend
+                        // speaks that shape natively, so the body goes through as written
+                        // (model resolved) and the SSE comes back untouched — no round
+                        // trip through the Messages shape, which cannot carry the newest
+                        // Codex CLI request features. Answers on the raw response: these
+                        // bytes are already in the client's shape.
+                        const served = codexAvailable && (isResponses && responsesBodyRaw
+                            ? await forwardResponsesToCodex(rawRes, { ...responsesBodyRaw, model: rawModel }, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, codexFetch, codexOnDone)
+                            : await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic', codexFetch, canDefer, codexOnDone, 
+                            // Cool codex on a rate limit only — a 5xx or an unreachable backend
+                            // is an outage, and parking a provider for that would keep it out
+                            // of the chain while it was already coming back.
+                            (d) => { if (d.status === 429)
+                                providerCooldowns.note('codex', d.retryAfterMs); }, 
+                            // dario#1260 — the effort named by the model-name suffix stripped
+                            // above. Undefined for every request that did not name one, which
+                            // leaves the outbound body exactly as it was.
+                            effortForCodex(requestEffort), codexGuard));
                         if (served) {
                             // A provider that just served is not rate-limited.
                             providerCooldowns.clear('codex');
@@ -3547,6 +3609,16 @@ export async function startProxy(opts = {}) {
                 }
                 catch { /* not JSON — fall through to existing path */ }
             }
+            // A Responses feature only the codex passthrough can honour, on a
+            // request the Claude pool is about to serve: refuse it by name here,
+            // after routing, so the same field on a ChatGPT-subscription model was
+            // forwarded untouched above.
+            if (isResponses && responsesUnsupported.length > 0) {
+                requestCount++;
+                res.writeHead(400, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
+                res.end(JSON.stringify(unsupportedOnClaudeError(responsesUnsupported[0])));
+                return;
+            }
             // Claude's turn: the routing block above declined this request, so it
             // needs a pool account. Selecting HERE and not before the body read is
             // the fix for dario#1137 — a ChatGPT-subscription-only user has a

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;