@askalf/dario 6.2.1 → 6.3.0

package/README.md

@@ -27,7 +27,7 @@
 
 <p><strong>One local endpoint. Every AI tool you own. The subscriptions you already pay for.</strong></p>
 
-<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~34k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
+<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~35k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
 
 <sub><a href="#start-in-60-seconds">Start</a> · <a href="#point-your-tools-at-it">Your tools</a> · <a href="#what-it-does-with-a-request">Routing</a> · <a href="#two-plans-one-endpoint">Two plans</a> · <a href="#many-seats-one-endpoint">Pool</a> · <a href="#it-tracks-a-moving-target">Drift</a> · <a href="#trust--transparency">Trust</a> · <a href="#will-my-account-get-suspended">Risk</a> · <a href="#commands">Commands</a> · <a href="#faq">FAQ</a> · <a href="docs/returning.md">Coming back after a while?</a></sub>
 
@@ -69,7 +69,25 @@ Prefer Docker? `ghcr.io/askalf/dario:latest` — multi-arch (`amd64` + `arm64`),
 
 ## Point your tools at it
 
-Two base URLs, one key. Anthropic-shaped clients talk to `http://localhost:3456`; OpenAI-shaped clients talk to `http://localhost:3456/v1`. The key is `dario` (any value works until you set `DARIO_API_KEY`, which then has to match).
+Two base URLs, one key. Anthropic-shaped clients talk to `http://localhost:3456`; OpenAI-shaped clients — chat/completions and, since 6.3, the Responses API — talk to `http://localhost:3456/v1`. The key is `dario` (any value works until you set `DARIO_API_KEY`, which then has to match).
+
+<details>
+<summary><strong>Codex CLI</strong> — OpenAI's agent, on your Claude plan</summary>
+
+```toml
+# ~/.codex/config.toml
+model = "claude-opus-5"
+model_provider = "dario"
+
+[model_providers.dario]
+name = "dario"
+base_url = "http://127.0.0.1:3456/v1"
+env_key = "DARIO_API_KEY"
+wire_api = "responses"
+```
+
+Codex CLI 0.154 dropped the chat wire for custom providers, so dario speaks the Responses API: the request is translated once at the front door and served like any Claude request — pool, failover, mid-stream continuation, the 17 KB Codex system prompt cached on the Claude side. The full agent loop runs: Claude calls `exec_command`, Codex executes it, the result goes back, Claude answers from it. Add a ChatGPT account too and `-m gpt-5.6-sol` on the same block goes to that plan through the same proxy. [Walkthrough and what is dropped](./docs/integrations/codex-cli.md).
+</details>
 
 <details>
 <summary><strong>Claude Code</strong> — forwarded verbatim</summary>
@@ -249,7 +267,7 @@ The tool doesn't know. The backend doesn't know. dario is the seam.
 
 ### Your ChatGPT plan, on both endpoints
 
-A ChatGPT Plus or Pro plan is served on **both** of dario's endpoints: any client that speaks `/v1/chat/completions` can use it (Codex CLI, the OpenAI SDKs, your scripts), and so can any client that speaks `/v1/messages` (Claude Code, the Anthropic SDKs, agent runtimes). The harness never needs to know which subscription is behind it.
+A ChatGPT Plus or Pro plan is served on **all three** of dario's endpoints: any client that speaks `/v1/chat/completions` or `/v1/responses` can use it (Codex CLI, the OpenAI SDKs, the Agents SDK, your scripts), and so can any client that speaks `/v1/messages` (Claude Code, the Anthropic SDKs, agent runtimes). The harness never needs to know which subscription is behind it — and the symmetry holds: Codex CLI runs on a Claude plan the same way.
 
 ```bash
 dario add altman            # prints an authorize URL; paste the redirect URL back
@@ -556,6 +574,8 @@ Full FAQ, including per-tool 401s and Team/Enterprise plans: [faq.md](./docs/faq
 
 ## Deep dives
 
+- [Claude Code wire drift](https://askalf.github.io/dario/drift-feed/) — every change to what Claude Code sends on the wire, as the template watcher observed it; [RSS](https://askalf.github.io/dario/drift-feed/feed.xml) · [JSON Feed](https://askalf.github.io/dario/drift-feed/feed.json)
+
 - [#183 — Modifying Claude Code's system prompt doesn't change billing; stripping its constraints recovers 1.2–2.8× output](https://github.com/askalf/dario/discussions/183)
 - [#68 — dario vs LiteLLM / OpenRouter / Kong AI Gateway (when each wins)](https://github.com/askalf/dario/discussions/68)
 - [#14 — Template replay: why we replay the shape instead of matching signals](https://github.com/askalf/dario/discussions/14)

package/dist/codex-backend.d.ts

@@ -262,6 +262,20 @@ export declare const CODEX_SUPPORTED_FIELDS: readonly string[];
 /** Drop every field this backend does not accept. Pure; exported for tests. */
 export declare function toCodexSupportedBody(body: Record<string, unknown>): Record<string, unknown>;
 export declare function buildCodexHeaders(creds: CodexAccountCredentials): Record<string, string>;
+/**
+ * Serve a Responses-shape request (`POST /v1/responses`) from a stored Codex
+ * account with NO translation: the ChatGPT backend speaks this shape natively,
+ * so the body goes through as the client wrote it (only `stream` forced) and
+ * the backend's SSE goes back byte for byte. This is what
+ * keeps the newest Codex CLI features working on a ChatGPT plan through dario
+ * — `additional_tools` input items, `custom` tools, `reasoning.context`,
+ * `include` — none of which survive a round trip through the Messages shape.
+ *
+ * Streaming only: the backend always streams, and folding a Responses stream
+ * into a buffered response object is not built yet. A non-streaming client
+ * gets a 400 saying so.
+ */
+export declare function forwardResponsesToCodex(res: ServerResponse, body: Record<string, unknown>, creds: CodexAccountCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean, fetchImpl?: typeof fetch, onDone?: (outcome: CodexForwardOutcome) => void): Promise<boolean>;
 /**
  * Serve a request from a stored Codex account, in either client wire shape.
  *

package/dist/codex-backend.js

@@ -743,6 +743,148 @@ export function buildCodexHeaders(creds) {
         headers['ChatGPT-Account-ID'] = accountId;
     return headers;
 }
+/**
+ * Serve a Responses-shape request (`POST /v1/responses`) from a stored Codex
+ * account with NO translation: the ChatGPT backend speaks this shape natively,
+ * so the body goes through as the client wrote it (only `stream` forced) and
+ * the backend's SSE goes back byte for byte. This is what
+ * keeps the newest Codex CLI features working on a ChatGPT plan through dario
+ * — `additional_tools` input items, `custom` tools, `reasoning.context`,
+ * `include` — none of which survive a round trip through the Messages shape.
+ *
+ * Streaming only: the backend always streams, and folding a Responses stream
+ * into a buffered response object is not built yet. A non-streaming client
+ * gets a 400 saying so.
+ */
+export async function forwardResponsesToCodex(res, body, creds, corsOrigin, securityHeaders, upstreamTimeoutMs, verbose, fetchImpl = fetch, onDone) {
+    const startedAt = Date.now();
+    const model = String(body.model ?? '');
+    let reported = false;
+    const report = (status, usage) => {
+        if (reported || !onDone)
+            return;
+        reported = true;
+        try {
+            onDone({ status, latencyMs: Date.now() - startedAt, inputTokens: usage?.input ?? 0, outputTokens: usage?.output ?? 0,
+                cacheReadTokens: usage?.cacheRead ?? 0, cacheCreateTokens: usage?.cacheCreate ?? 0, stream: true, model, alias: creds.alias });
+        }
+        catch { /* never break a served request */ }
+    };
+    if (body.stream !== true) {
+        res.writeHead(400, { 'Content-Type': 'application/json', ...securityHeaders });
+        res.end(JSON.stringify({ error: { message: 'stream: true is required on /v1/responses for a ChatGPT-subscription model (the backend streams; buffering is not built)', type: 'invalid_request_error', param: 'stream', code: null } }));
+        report(400, null);
+        return true;
+    }
+    // Only `stream` is forced. `store` is the client's — sent, or omitted so
+    // the backend applies its own default: a stateful client relies on that
+    // default to make its next turn's previous_response_id resolvable, and
+    // Codex CLI sends false itself.
+    const upstreamBody = { ...body, stream: true };
+    const target = `${CODEX_BACKEND_BASE_URL.replace(/\/$/, '')}/responses`;
+    const abort = new AbortController();
+    let clientGone = false;
+    let finished = false;
+    const onClientClose = () => { if (!finished && !clientGone) {
+        clientGone = true;
+        if (!abort.signal.aborted)
+            abort.abort();
+    } };
+    res.on('close', onClientClose);
+    const timeout = setTimeout(() => abort.abort(), upstreamTimeoutMs);
+    let usage = null;
+    try {
+        if (verbose)
+            console.log(`[dario] → codex backend (responses passthrough): ${target} (model: ${model})`);
+        const upstream = await fetchImpl(target, { method: 'POST', headers: buildCodexHeaders(creds), body: JSON.stringify(upstreamBody), signal: abort.signal });
+        if (!upstream.ok || !upstream.body) {
+            const detail = await upstream.text().catch(() => '');
+            if (verbose)
+                console.error(`[dario] codex backend ${upstream.status}: ${detail.slice(0, 300)}`);
+            if (!clientGone) {
+                res.writeHead(upstream.status, { 'Content-Type': 'application/json', ...securityHeaders });
+                // The backend's own error body, already in the client's shape.
+                res.end(detail || JSON.stringify({ error: { message: 'Upstream Codex backend error', type: 'server_error', code: null, param: null } }));
+            }
+            report(clientGone ? 499 : upstream.status, null);
+            return true;
+        }
+        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Access-Control-Allow-Origin': corsOrigin, ...securityHeaders });
+        const reader = upstream.body.getReader();
+        const decoder = new TextDecoder();
+        let tail = '';
+        let terminal = false;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (clientGone)
+                    break;
+                res.write(value);
+                // Usage rides the terminal event; read it off the wire as it passes.
+                // The terminal event also ENDS the response here: Codex CLI closes
+                // its side the moment it has `response.completed`, and waiting for the
+                // backend's EOF instead turned every finished turn into a "client
+                // disconnected" abort in the log.
+                tail += decoder.decode(value, { stream: true });
+                const frames = tail.split('\n\n');
+                tail = frames.pop() ?? '';
+                for (const f of frames) {
+                    const line = f.split('\n').find((l) => l.startsWith('data:'));
+                    if (!line)
+                        continue;
+                    let ev;
+                    try {
+                        ev = JSON.parse(line.slice(5));
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!isTerminalResponsesEvent(ev.type ?? ''))
+                        continue;
+                    terminal = true;
+                    usage = splitResponsesUsage(ev.response?.usage) ?? usage;
+                }
+                if (terminal)
+                    break;
+            }
+        }
+        finally {
+            reader.releaseLock();
+            if (terminal && !abort.signal.aborted)
+                abort.abort();
+        }
+        finished = true;
+        if (!clientGone)
+            res.end();
+        report(clientGone ? 499 : 200, usage);
+        return true;
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        if (verbose)
+            console.error(`[dario] codex backend (${creds.alias}) responses passthrough error: ${detail}`);
+        if (!clientGone) {
+            if (!res.headersSent) {
+                res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
+                res.end(JSON.stringify({ error: { message: 'Upstream Codex backend error', type: 'server_error', code: null, param: null } }));
+            }
+            else {
+                try {
+                    res.end();
+                }
+                catch { /* already closed */ }
+            }
+        }
+        report(clientGone ? 499 : 502, usage);
+        return true;
+    }
+    finally {
+        clearTimeout(timeout);
+        res.removeListener('close', onClientClose);
+    }
+}
 /**
  * Serve a request from a stored Codex account, in either client wire shape.
  *

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;

package/dist/responses-inbound.js

@@ -0,0 +1,616 @@
+/**
+ * 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 { SseFrameSplitter } from './midstream.js';
+export class ResponsesRequestError extends Error {
+    param;
+    constructor(message, param) {
+        super(message);
+        this.param = param;
+    }
+}
+const DEFAULT_MAX_OUTPUT_TOKENS = 32000;
+const EFFORTS = {
+    none: 'low', minimal: 'low', low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max',
+};
+function textPart(text) { return { type: 'text', text }; }
+function imagePart(url, warnings) {
+    const m = /^data:([^;,]+);base64,(.+)$/s.exec(url);
+    if (m)
+        return { type: 'image', source: { type: 'base64', media_type: m[1], data: m[2] } };
+    if (/^https?:\/\//.test(url))
+        return { type: 'image', source: { type: 'url', url } };
+    warnings.push(`input_image with an unsupported image_url dropped (${url.slice(0, 24)}…)`);
+    return null;
+}
+/** Content of a Responses message → Anthropic content blocks. */
+function contentParts(content, warnings) {
+    if (typeof content === 'string')
+        return content.length > 0 ? [textPart(content)] : [];
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const p of content) {
+        switch (p?.type) {
+            case 'input_text':
+            case 'output_text':
+            case 'text':
+                if (typeof p.text === 'string' && p.text.length > 0)
+                    out.push(textPart(p.text));
+                break;
+            case 'refusal':
+                if (typeof p.refusal === 'string')
+                    out.push(textPart(p.refusal));
+                break;
+            case 'input_image': {
+                const url = typeof p.image_url === 'string' ? p.image_url : p.image_url?.url;
+                if (typeof url === 'string') {
+                    const img = imagePart(url, warnings);
+                    if (img)
+                        out.push(img);
+                }
+                else
+                    warnings.push('input_image without image_url dropped (file_id images are not supported)');
+                break;
+            }
+            default:
+                warnings.push(`content part ${String(p?.type)} dropped`);
+        }
+    }
+    return out;
+}
+/** A tool's output as a tool_result `content` — string when it is only text. */
+function toolOutput(output, warnings) {
+    if (typeof output === 'string')
+        return output;
+    if (Array.isArray(output)) {
+        const parts = contentParts(output, warnings);
+        return parts.every((p) => p.type === 'text') ? parts.map((p) => p.text).join('') : parts;
+    }
+    return output === undefined || output === null ? '' : JSON.stringify(output);
+}
+function parseArguments(args, name, warnings) {
+    if (typeof args !== 'string' || args.trim() === '')
+        return {};
+    try {
+        const v = JSON.parse(args);
+        if (v !== null && typeof v === 'object' && !Array.isArray(v))
+            return v;
+        warnings.push(`function_call ${name}: arguments is not a JSON object, sent as {}`);
+    }
+    catch {
+        warnings.push(`function_call ${name}: arguments is not valid JSON, sent as {}`);
+    }
+    return {};
+}
+/** Function tools, with `namespace` groups flattened; hosted tool types dropped. */
+function translateTools(tools, warnings) {
+    if (!Array.isArray(tools))
+        return [];
+    const out = [];
+    const add = (t) => {
+        switch (t?.type) {
+            case 'function': {
+                if (typeof t.name !== 'string' || t.name.length === 0) {
+                    warnings.push('function tool without a name dropped');
+                    break;
+                }
+                const tool = { name: t.name, input_schema: (t.parameters && typeof t.parameters === 'object') ? t.parameters : { type: 'object', properties: {} } };
+                if (typeof t.description === 'string')
+                    tool.description = t.description;
+                out.push(tool);
+                break;
+            }
+            case 'namespace':
+                for (const inner of (Array.isArray(t.tools) ? t.tools : []))
+                    add(inner);
+                break;
+            case 'custom':
+                warnings.push(`custom tool ${String(t.name)} dropped (freeform tools have no Anthropic equivalent)`);
+                break;
+            default:
+                warnings.push(`${String(t?.type)} tool dropped (hosted tools do not run on the Claude pool)`);
+        }
+    };
+    for (const t of tools)
+        add(t);
+    return out;
+}
+function translateToolChoice(choice, parallel) {
+    let out;
+    if (choice === undefined || choice === 'auto')
+        out = { type: 'auto' };
+    else if (choice === 'required')
+        out = { type: 'any' };
+    else if (choice === 'none')
+        out = { type: 'none' };
+    else if (choice && typeof choice === 'object') {
+        const c = choice;
+        if (c.type === 'function' && typeof c.name === 'string')
+            out = { type: 'tool', name: c.name };
+        else
+            out = { type: 'auto' }; // allowed_tools and hosted-tool choices: let the model decide
+    }
+    if (parallel === false && out && out.type !== 'none')
+        out.disable_parallel_tool_use = true;
+    // Anthropic's default is auto; only send the field when it says something.
+    if (out && out.type === 'auto' && !out.disable_parallel_tool_use)
+        return undefined;
+    return out;
+}
+/**
+ * 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 function responsesRequestToAnthropic(req) {
+    const warnings = [];
+    const model = typeof req.model === 'string' ? req.model.trim() : '';
+    if (!model)
+        throw new ResponsesRequestError('model is required', 'model');
+    const unsupported = [];
+    if (req.previous_response_id !== undefined && req.previous_response_id !== null)
+        unsupported.push('previous_response_id');
+    const systemParts = [];
+    if (typeof req.instructions === 'string' && req.instructions.length > 0)
+        systemParts.push(req.instructions);
+    const messages = [];
+    // Tools declared inside the input (`additional_tools` items — what Codex
+    // CLI sends for models it has metadata for) join the top-level list.
+    const extraTools = [];
+    const push = (role, parts) => {
+        if (parts.length === 0)
+            return;
+        const last = messages[messages.length - 1];
+        if (last && last.role === role)
+            last.content.push(...parts);
+        else
+            messages.push({ role, content: parts });
+    };
+    const input = req.input;
+    if (typeof input === 'string') {
+        push('user', [textPart(input)]);
+    }
+    else if (Array.isArray(input)) {
+        for (const raw of input) {
+            const type = typeof raw?.type === 'string' ? raw.type : (raw?.role ? 'message' : '');
+            switch (type) {
+                case 'message': {
+                    const role = String(raw.role ?? 'user');
+                    if (role === 'system' || role === 'developer') {
+                        const text = contentParts(raw.content, warnings).filter((p) => p.type === 'text').map((p) => p.text).join('\n');
+                        if (text)
+                            systemParts.push(text);
+                    }
+                    else {
+                        push(role === 'assistant' ? 'assistant' : 'user', contentParts(raw.content, warnings));
+                    }
+                    break;
+                }
+                case 'function_call': {
+                    const name = String(raw.name ?? '');
+                    const callId = String(raw.call_id ?? raw.id ?? '');
+                    if (!name || !callId) {
+                        warnings.push('function_call without name/call_id dropped');
+                        break;
+                    }
+                    push('assistant', [{ type: 'tool_use', id: callId, name, input: parseArguments(raw.arguments, name, warnings) }]);
+                    break;
+                }
+                case 'function_call_output': {
+                    const callId = String(raw.call_id ?? '');
+                    if (!callId) {
+                        warnings.push('function_call_output without call_id dropped');
+                        break;
+                    }
+                    push('user', [{ type: 'tool_result', tool_use_id: callId, content: toolOutput(raw.output, warnings) }]);
+                    break;
+                }
+                case 'reasoning':
+                    break; // OpenAI's encrypted reasoning; the pool has its own
+                case 'additional_tools':
+                    if (Array.isArray(raw.tools))
+                        extraTools.push(...raw.tools);
+                    break;
+                default:
+                    warnings.push(`input item ${type || '(untyped)'} dropped`);
+            }
+        }
+    }
+    else {
+        throw new ResponsesRequestError('input must be a string or an array of items', 'input');
+    }
+    if (messages.length === 0)
+        throw new ResponsesRequestError('input carries no user or assistant content', 'input');
+    if (messages[0].role !== 'user')
+        messages.unshift({ role: 'user', content: [textPart('(continue)')] });
+    const body = { model, messages };
+    if (systemParts.length > 0)
+        body.system = systemParts.join('\n\n');
+    const maxOut = typeof req.max_output_tokens === 'number' && req.max_output_tokens > 0 ? Math.floor(req.max_output_tokens) : DEFAULT_MAX_OUTPUT_TOKENS;
+    body.max_tokens = maxOut;
+    if (req.stream === true)
+        body.stream = true;
+    if (typeof req.temperature === 'number')
+        body.temperature = req.temperature;
+    if (typeof req.top_p === 'number')
+        body.top_p = req.top_p;
+    const tools = translateTools([...(Array.isArray(req.tools) ? req.tools : []), ...extraTools], warnings);
+    if (tools.length > 0)
+        body.tools = tools;
+    const choice = translateToolChoice(req.tool_choice, req.parallel_tool_calls);
+    if (choice && tools.length > 0)
+        body.tool_choice = choice;
+    const effort = req.reasoning?.effort;
+    if (typeof effort === 'string' && EFFORTS[effort]) {
+        // dario's own per-request effort spelling (model:high), parsed on the
+        // Claude path and the codex path alike — see parseEffortSuffix.
+        body.model = `${model}:${EFFORTS[effort]}`;
+    }
+    const text = req.text;
+    if (text?.format && text.format.type && text.format.type !== 'text')
+        warnings.push(`text.format ${text.format.type} dropped (structured output is not translated on this route)`);
+    return { body, warnings, unsupported };
+}
+/** The 400 the Claude pool answers for a Responses feature it cannot serve. */
+export function unsupportedOnClaudeError(field) {
+    const why = field === 'previous_response_id'
+        ? 'previous_response_id cannot be served from the Claude pool: dario is stateless there — send the full input each turn (store: false), or use a ChatGPT-subscription model, which passes the request through to a backend that keeps state'
+        : `${field} cannot be served from the Claude pool`;
+    return { error: { message: why, type: 'invalid_request_error', param: field, code: null } };
+}
+function responsesUsage(u) {
+    const cached = u?.cache_read_input_tokens ?? 0;
+    const input = (u?.input_tokens ?? 0) + cached + (u?.cache_creation_input_tokens ?? 0);
+    const output = u?.output_tokens ?? 0;
+    return {
+        input_tokens: input,
+        input_tokens_details: { cached_tokens: cached },
+        output_tokens: output,
+        output_tokens_details: { reasoning_tokens: 0 },
+        total_tokens: input + output,
+    };
+}
+function statusFor(stopReason) {
+    if (stopReason === 'max_tokens')
+        return { status: 'incomplete', incomplete_details: { reason: 'max_output_tokens' } };
+    return { status: 'completed', incomplete_details: null };
+}
+/** Anthropic message id `msg_01AB…` → a Responses response id. */
+function responseIdFrom(messageId) {
+    const raw = typeof messageId === 'string' && messageId.length > 0 ? messageId.replace(/^msg_/, '') : Math.random().toString(36).slice(2);
+    return `resp_${raw}`;
+}
+function baseResponse(id, createdAt, model) {
+    return {
+        id, object: 'response', created_at: createdAt, status: 'in_progress', error: null, incomplete_details: null,
+        model, output: [], parallel_tool_calls: true, tool_choice: 'auto', tools: [], store: false, usage: null,
+    };
+}
+/** A buffered Anthropic message → a Responses response object. */
+export function anthropicMessageToResponses(msg, createdAt = Math.floor(Date.now() / 1000)) {
+    const id = responseIdFrom(msg.id);
+    const model = typeof msg.model === 'string' ? msg.model : '';
+    const output = [];
+    let n = 0;
+    for (const block of (Array.isArray(msg.content) ? msg.content : [])) {
+        n++;
+        switch (block.type) {
+            case 'text':
+                output.push({ id: `msg_${id.slice(5)}_${n}`, type: 'message', status: 'completed', role: 'assistant', content: [{ type: 'output_text', text: String(block.text ?? ''), annotations: [] }] });
+                break;
+            case 'tool_use':
+                output.push({ id: `fc_${id.slice(5)}_${n}`, type: 'function_call', status: 'completed', call_id: String(block.id ?? ''), name: String(block.name ?? ''), arguments: JSON.stringify(block.input ?? {}) });
+                break;
+            case 'thinking': {
+                const t = typeof block.thinking === 'string' ? block.thinking : '';
+                output.push({ id: `rs_${id.slice(5)}_${n}`, type: 'reasoning', summary: t ? [{ type: 'summary_text', text: t }] : [] });
+                break;
+            }
+            default: break; // redacted_thinking, server tool blocks: nothing a Responses client can use
+        }
+    }
+    const st = statusFor(msg.stop_reason);
+    return { ...baseResponse(id, createdAt, model), status: st.status, incomplete_details: st.incomplete_details, output, usage: responsesUsage(msg.usage) };
+}
+/** An Anthropic error body → the OpenAI error envelope. */
+export function anthropicErrorToResponses(body) {
+    // Anthropic: { type: 'error', error: { type, message } }. dario's own
+    // pre-upstream errors: { error: 'Proxy error', message: '…' }.
+    const e = body.error;
+    if (typeof e === 'string')
+        return { error: { message: typeof body.message === 'string' ? body.message : e, type: 'api_error', code: null, param: null } };
+    const err = (e ?? {});
+    return { error: { message: err.message ?? 'upstream error', type: err.type ?? 'api_error', code: err.type ?? null, param: null } };
+}
+/**
+ * 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 class ResponsesOutStream {
+    seq = 0;
+    id = '';
+    createdAt = Math.floor(Date.now() / 1000);
+    model;
+    started = false;
+    output = [];
+    open = new Map();
+    usage = {};
+    stopReason = null;
+    done = false;
+    splitter = new SseFrameSplitter();
+    constructor(requestModel) { this.model = requestModel; }
+    ev(type, payload) {
+        return `event: ${type}\ndata: ${JSON.stringify({ type, sequence_number: this.seq++, ...payload })}\n\n`;
+    }
+    snapshot(status) {
+        return { ...baseResponse(this.id, this.createdAt, this.model), status, output: this.output.map((o) => ({ ...o })) };
+    }
+    feed(chunk) {
+        let out = '';
+        for (const f of this.splitter.feed(chunk))
+            out += this.frame(f);
+        return out;
+    }
+    /** Whatever is still buffered (a partial frame) — nothing a Responses client can use. */
+    end() { this.splitter.flush(); return ''; }
+    get finished() { return this.done; }
+    frame(f) {
+        if (f.comment)
+            return f.raw;
+        const d = f.data;
+        if (!d)
+            return '';
+        switch (d.type) {
+            case 'ping': return '';
+            case 'message_start': {
+                const m = (d.message ?? {});
+                this.id = responseIdFrom(m.id);
+                if (typeof m.model === 'string' && m.model)
+                    this.model = m.model;
+                this.usage = { ...m.usage };
+                this.started = true;
+                return this.ev('response.created', { response: this.snapshot('in_progress') }) + this.ev('response.in_progress', { response: this.snapshot('in_progress') });
+            }
+            case 'content_block_start': return this.blockStart(d);
+            case 'content_block_delta': return this.blockDelta(d);
+            case 'content_block_stop': return this.blockStop(d);
+            case 'message_delta': {
+                const delta = d.delta;
+                if (delta?.stop_reason !== undefined)
+                    this.stopReason = delta.stop_reason;
+                const u = d.usage;
+                if (u)
+                    this.usage = { ...this.usage, ...u };
+                return '';
+            }
+            case 'message_stop': {
+                if (!this.started)
+                    return '';
+                this.done = true;
+                const st = statusFor(this.stopReason);
+                const response = { ...this.snapshot(st.status), incomplete_details: st.incomplete_details, usage: responsesUsage(this.usage) };
+                return this.ev('response.completed', { response });
+            }
+            case 'error': {
+                const err = (d.error ?? {});
+                this.done = true;
+                if (!this.started) {
+                    this.id = responseIdFrom(undefined);
+                    this.started = true;
+                }
+                const response = { ...this.snapshot('failed'), error: { code: err.type ?? 'server_error', message: err.message ?? 'upstream error' } };
+                return this.ev('response.failed', { response }) + this.ev('error', { code: err.type ?? 'server_error', message: err.message ?? 'upstream error', param: null });
+            }
+            default: return '';
+        }
+    }
+    blockStart(d) {
+        const idx = typeof d.index === 'number' ? d.index : this.output.length;
+        const cb = (d.content_block ?? {});
+        const n = this.output.length + 1;
+        const outputIndex = this.output.length;
+        switch (cb.type) {
+            case 'text': {
+                const item = { id: `msg_${this.id.slice(5)}_${n}`, type: 'message', status: 'in_progress', role: 'assistant', content: [] };
+                this.output.push(item);
+                this.open.set(idx, { item, kind: 'message', text: typeof cb.text === 'string' ? cb.text : '', summaryOpened: false });
+                return this.ev('response.output_item.added', { output_index: outputIndex, item: { ...item } })
+                    + this.ev('response.content_part.added', { item_id: item.id, output_index: outputIndex, content_index: 0, part: { type: 'output_text', text: '', annotations: [] } });
+            }
+            case 'tool_use': {
+                const item = { id: `fc_${this.id.slice(5)}_${n}`, type: 'function_call', status: 'in_progress', call_id: String(cb.id ?? ''), name: String(cb.name ?? ''), arguments: '' };
+                this.output.push(item);
+                this.open.set(idx, { item, kind: 'function_call', text: '', summaryOpened: false });
+                return this.ev('response.output_item.added', { output_index: outputIndex, item: { ...item } });
+            }
+            case 'thinking': {
+                const item = { id: `rs_${this.id.slice(5)}_${n}`, type: 'reasoning', summary: [] };
+                this.output.push(item);
+                this.open.set(idx, { item, kind: 'reasoning', text: '', summaryOpened: false });
+                return this.ev('response.output_item.added', { output_index: outputIndex, item: { ...item } });
+            }
+            default:
+                return ''; // redacted_thinking, server tools: not surfaced
+        }
+    }
+    blockDelta(d) {
+        const idx = typeof d.index === 'number' ? d.index : -1;
+        const o = this.open.get(idx);
+        if (!o)
+            return '';
+        const delta = (d.delta ?? {});
+        const outputIndex = this.output.indexOf(o.item);
+        if (o.kind === 'message' && delta.type === 'text_delta' && typeof delta.text === 'string') {
+            o.text += delta.text;
+            return this.ev('response.output_text.delta', { item_id: o.item.id, output_index: outputIndex, content_index: 0, delta: delta.text });
+        }
+        if (o.kind === 'function_call' && delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+            o.text += delta.partial_json;
+            return this.ev('response.function_call_arguments.delta', { item_id: o.item.id, output_index: outputIndex, delta: delta.partial_json });
+        }
+        if (o.kind === 'reasoning' && delta.type === 'thinking_delta' && typeof delta.thinking === 'string' && delta.thinking.length > 0) {
+            let out = '';
+            if (!o.summaryOpened) {
+                o.summaryOpened = true;
+                out += this.ev('response.reasoning_summary_part.added', { item_id: o.item.id, output_index: outputIndex, summary_index: 0, part: { type: 'summary_text', text: '' } });
+            }
+            o.text += delta.thinking;
+            return out + this.ev('response.reasoning_summary_text.delta', { item_id: o.item.id, output_index: outputIndex, summary_index: 0, delta: delta.thinking });
+        }
+        return '';
+    }
+    blockStop(d) {
+        const idx = typeof d.index === 'number' ? d.index : -1;
+        const o = this.open.get(idx);
+        if (!o)
+            return '';
+        this.open.delete(idx);
+        const outputIndex = this.output.indexOf(o.item);
+        switch (o.kind) {
+            case 'message': {
+                const part = { type: 'output_text', text: o.text, annotations: [] };
+                o.item.status = 'completed';
+                o.item.content = [part];
+                return this.ev('response.output_text.done', { item_id: o.item.id, output_index: outputIndex, content_index: 0, text: o.text })
+                    + this.ev('response.content_part.done', { item_id: o.item.id, output_index: outputIndex, content_index: 0, part })
+                    + this.ev('response.output_item.done', { output_index: outputIndex, item: { ...o.item } });
+            }
+            case 'function_call': {
+                const args = o.text.trim() === '' ? '{}' : o.text;
+                o.item.arguments = args;
+                o.item.status = 'completed';
+                return this.ev('response.function_call_arguments.done', { item_id: o.item.id, output_index: outputIndex, arguments: args })
+                    + this.ev('response.output_item.done', { output_index: outputIndex, item: { ...o.item } });
+            }
+            case 'reasoning': {
+                let out = '';
+                if (o.summaryOpened) {
+                    out += this.ev('response.reasoning_summary_text.done', { item_id: o.item.id, output_index: outputIndex, summary_index: 0, text: o.text })
+                        + this.ev('response.reasoning_summary_part.done', { item_id: o.item.id, output_index: outputIndex, summary_index: 0, part: { type: 'summary_text', text: o.text } });
+                    o.item.summary = [{ type: 'summary_text', text: o.text }];
+                }
+                return out + this.ev('response.output_item.done', { output_index: outputIndex, item: { ...o.item } });
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+//  The write boundary
+// ---------------------------------------------------------------------------
+/**
+ * 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 class ResponsesOut {
+    mode = 'undecided';
+    json = '';
+    stream;
+    decoder = new TextDecoder();
+    constructor(requestModel) { this.stream = new ResponsesOutStream(requestModel); }
+    write(chunk) {
+        const text = typeof chunk === 'string' ? chunk : this.decoder.decode(chunk, { stream: true });
+        if (this.mode === 'undecided') {
+            const head = text.trimStart();
+            if (head.length === 0)
+                return '';
+            this.mode = head.startsWith('event:') || head.startsWith('data:') || head.startsWith(':') ? 'sse' : 'json';
+        }
+        if (this.mode === 'sse')
+            return this.stream.feed(text);
+        this.json += text;
+        return '';
+    }
+    end() {
+        if (this.mode === 'sse')
+            return this.stream.end();
+        if (this.mode === 'json') {
+            this.json += this.decoder.decode();
+            try {
+                const parsed = JSON.parse(this.json);
+                if (parsed.type === 'message' && Array.isArray(parsed.content))
+                    return JSON.stringify(anthropicMessageToResponses(parsed));
+                // Already the OpenAI envelope (dario answered this route in the
+                // client's shape itself): leave it alone.
+                if (parsed.type !== 'error' && parsed.error && typeof parsed.error === 'object' && 'param' in parsed.error)
+                    return this.json;
+                if (parsed.type === 'error' || parsed.error)
+                    return JSON.stringify(anthropicErrorToResponses(parsed));
+                return this.json;
+            }
+            catch {
+                return this.json;
+            }
+        }
+        return '';
+    }
+}
+/**
+ * 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 function wrapResponsesClient(res, out) {
+    const target = res;
+    return new Proxy(res, {
+        get(_t, prop) {
+            if (prop === 'write') {
+                return (chunk, ...rest) => {
+                    const translated = out.write(chunk);
+                    const cb = rest.find((r) => typeof r === 'function');
+                    if (translated.length === 0) {
+                        cb?.();
+                        return true;
+                    }
+                    return target.write(translated, ...(typeof rest[0] === 'string' ? rest : rest.filter((r) => typeof r === 'function')));
+                };
+            }
+            if (prop === 'end') {
+                return (chunk, ...rest) => {
+                    if (chunk !== undefined && chunk !== null && typeof chunk !== 'function') {
+                        const t = out.write(chunk);
+                        if (t.length > 0)
+                            target.write(t);
+                    }
+                    const tail = out.end();
+                    if (tail.length > 0)
+                        target.write(tail);
+                    return target.end(...(typeof chunk === 'function' ? [chunk] : rest.filter((r) => typeof r === 'function')));
+                };
+            }
+            // Getters run with `this` = the real response, never the proxy: Node's
+            // internals read symbol-keyed state off `this`.
+            const v = Reflect.get(target, prop, target);
+            return typeof v === 'function' ? v.bind(target) : v;
+        },
+    });
+}

package/docs/drift-monitor.md

@@ -1,5 +1,11 @@
 # Drift monitor
 
+> **The feed:** every change the watcher has ever observed, as a page with
+> RSS and JSON Feed — <https://askalf.github.io/dario/drift-feed/>. Rebuilt
+> from git history on every template change (`scripts/drift-feed.mjs`,
+> `.github/workflows/drift-feed.yml`); a "nothing changed on the wire" line is
+> a Claude Code release the watcher checked and found identical.
+
 Dario's bundled CC template (`src/cc-template-data.json`) is the wire-shape
 fallback the proxy uses when it can't fingerprint a live CC install. For that
 fallback to be honest, the bundle has to keep up with what real CC is actually

package/docs/integrations/codex-cli.md

@@ -0,0 +1,94 @@
+# Codex CLI on your Claude plan
+
+OpenAI's Codex CLI runs on a Claude subscription through dario, with its
+tools, since 6.3. The other way round — Claude Code on a ChatGPT plan — has
+worked since 5.5.89. Both on one machine, one `dario proxy`, is the whole
+point of the project in two panes.
+
+## Why this needed a new endpoint
+
+Codex CLI 0.154 removed `wire_api = "chat"` for custom providers
+([openai/codex discussion 7782](https://github.com/openai/codex/discussions/7782)):
+a provider has to speak the **Responses API** or it cannot be used at all. So
+dario now has `POST /v1/responses`. The request is translated once at the front
+door into the Messages shape every other dario path already serves — pool,
+template, failover, mid-stream continuation — and everything written back is
+translated at the write boundary. For a ChatGPT-subscription model the body
+goes through to the codex backend untouched instead (it speaks Responses
+natively), which is what keeps Codex's newest request features working there:
+`additional_tools` input items, `custom` tools, `reasoning.context`,
+`include`.
+
+The OpenAI Agents SDK and anything else that speaks Responses gets the same
+endpoint.
+
+## Setup
+
+```bash
+dario proxy                                   # your Claude plan, port 3456
+```
+
+`~/.codex/config.toml`:
+
+```toml
+model = "claude-opus-5"
+model_provider = "dario"
+
+[model_providers.dario]
+name = "dario"
+base_url = "http://127.0.0.1:3456/v1"
+env_key = "DARIO_API_KEY"
+wire_api = "responses"
+```
+
+`export DARIO_API_KEY=dario` (any value until you set one on the proxy; then it
+has to match), and `codex` runs on the Claude pool. `-m claude-sonnet-5` /
+`-m claude-opus-5` / any `claude-*` id; `codex exec` works the same way.
+
+With a ChatGPT account attached as well (`dario add altman`),
+`-m gpt-5.6-sol` on the same provider block goes to that plan through dario —
+pooling, failover and `x-dario-*` headers included.
+
+Codex prints `Model metadata for claude-opus-5 not found. Defaulting to fallback
+metadata` for any model it does not ship metadata for. Harmless: it falls back
+to its classic request profile (top-level `tools` and `instructions`), which is
+exactly the one the translation reads.
+
+## What runs, and what does not
+
+Verified on 2026-09-12 with Codex CLI 0.154.0 on a Claude Max plan:
+
+- a plain turn;
+- the full agent loop — `exec_command` called by Claude, executed by Codex,
+  the `function_call_output` returned, Claude answering from it — with the
+  17 KB Codex system prompt cached on the Claude side (98–99% cache reads
+  from the second turn);
+- the same loop on a ChatGPT plan through the passthrough.
+
+Translated on the Claude pool: `instructions` and `developer` messages
+(hoisted to the system prompt, in order), `message` items with `input_text`,
+`output_text` and `input_image` parts (data-URL and https images),
+`function_call` / `function_call_output` (tool_use / tool_result, call ids
+preserved), `function` tools (and `namespace` groups, flattened),
+`tool_choice` including `required` and a named function,
+`parallel_tool_calls: false`, `max_output_tokens`, `temperature`, `top_p`,
+`reasoning.effort` (as dario's own `model:high` effort spelling). Back out:
+`message`, `function_call` and `reasoning` items, the full Responses event
+sequence with sequence numbers, usage in OpenAI terms (cached prefix inside
+`input_tokens`, reported again under `cached_tokens`), `incomplete` on
+`max_tokens`, `response.failed` on an upstream error.
+
+Dropped, with a line at `--verbose`: hosted tool types the pool cannot run
+(`web_search`, `file_search`, `mcp`, …), `custom` freeform tools,
+`reasoning` items on the way in (OpenAI's encrypted content — the pool does
+not need it back), `text.format`. `previous_response_id` on the Claude pool is a 400 naming the
+field (dario is stateless there; send the full input each turn, which Codex
+does); on a ChatGPT-subscription model it is forwarded untouched to a backend
+that keeps state, `store` as you sent it or omitted for the backend's default.
+
+Not built: a buffered (non-streaming) response from a ChatGPT-subscription
+model on this route — the backend streams, and folding a Responses stream into
+a response object is not written yet; the answer is a 400 naming `stream`.
+Mid-stream continuation runs under this route on the Claude pool (the
+translated request is an ordinary Anthropic-shape request) and not on the
+passthrough.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.2.1",
+  "version": "6.3.0",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {