@askalf/dario 5.5.86 → 5.5.88

package/dist/codex-backend.d.ts

@@ -76,6 +76,22 @@ export declare function extractChatGPTAccountId(idToken: string | undefined): st
  *   the user would expect to find in their history
  */
 export declare function chatCompletionsToResponses(body: Record<string, unknown>): Record<string, unknown>;
+/** Which wire shape the CLIENT spoke; selects both translation ends. */
+export type CodexRequestShape = 'openai' | 'anthropic';
+/**
+ * The Responses stream has THREE terminal events, not two. Missing
+ * `response.failed` is not inert in either direction: on the chat path the
+ * stream would end with no finish frame and no `[DONE]` (an SDK parser waits
+ * forever or throws), and on the Anthropic path the non-streaming collapse
+ * would find no terminal response and hand back a well-formed EMPTY success —
+ * a failure that reads as a normal, empty turn. Found by review on dario#1141;
+ * the chat-path half was the same bug, pre-existing.
+ */
+export declare function isTerminalResponsesEvent(type: string): boolean;
+/** True when a terminal Responses payload describes a FAILURE rather than a turn. */
+export declare function isFailedResponse(resp: unknown): boolean;
+/** The upstream message on a failed Responses payload, for the error body. */
+export declare function failedResponseMessage(resp: unknown): string;
 /**
  * Stateful per-request translator: Responses SSE in, chat/completions out.
  *
@@ -93,15 +109,31 @@ export declare function chatCompletionsToResponses(body: Record<string, unknown>
 export declare function createResponsesTranslator(model: string): {
     /** Feed one raw SSE line. Returns the line to forward, or null. */
     chunk(line: string): string | null;
+    /** True when the upstream stream terminated as a FAILURE. */
+    didFail(): boolean;
     /** Everything seen so far, as one non-streaming chat.completion body. */
     complete(): Record<string, unknown>;
 };
 export declare function buildCodexHeaders(creds: CodexAccountCredentials): Record<string, string>;
 /**
- * Serve a /v1/chat/completions request from a stored Codex account.
+ * Serve a request from a stored Codex account, in either client wire shape.
+ *
+ * `shape` picks the two translation ends; everything between — headers, the
+ * timeout, the upstream POST, the read loop, the error paths — is shared,
+ * because only the translation differs between an OpenAI-shape and an
+ * Anthropic-shape client:
+ *
+ *   openai     chat/completions ─┐                    ┌─ chat.completion(.chunk)
+ *                                ├→ Responses (codex) ┤
+ *   anthropic  messages ─────────┘                    └─ Anthropic SSE / Message
+ *
+ * dario always asks the backend for a stream and collapses it here when the
+ * client didn't want one, so `stream: true` is forced on the way out for both
+ * shapes. For the Anthropic shape the non-streaming body is rebuilt from the
+ * `response` object carried by the terminal `response.completed` event.
  *
  * `fetchImpl` is injectable so the translation and header construction are
  * testable without network (test/codex-backend.mjs), matching the pattern
  * test/codex-oauth.mjs already uses.
  */
-export declare function forwardToCodex(req: IncomingMessage, res: ServerResponse, body: Buffer, creds: CodexAccountCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean, fetchImpl?: typeof fetch): Promise<void>;
+export declare function forwardToCodex(req: IncomingMessage, res: ServerResponse, body: Buffer, creds: CodexAccountCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean, shape?: CodexRequestShape, fetchImpl?: typeof fetch): Promise<void>;

package/dist/codex-backend.js

@@ -1,3 +1,4 @@
+import { anthropicToResponsesRequest, createResponsesSSEParser, formatResponsesAnthropicSSE, responsesStreamToAnthropicSSE, responsesToAnthropicResponse, } from './anthropic-responses-translate.js';
 export const CODEX_BACKEND_BASE_URL = process.env.DARIO_CODEX_BASE_URL || 'https://chatgpt.com/backend-api/codex';
 /** Originator string the codex CLI identifies itself with. */
 const CODEX_ORIGINATOR = 'codex_cli_rs';
@@ -207,6 +208,32 @@ export function chatCompletionsToResponses(body) {
         out.reasoning = { effort: body.reasoning_effort };
     return out;
 }
+/**
+ * The Responses stream has THREE terminal events, not two. Missing
+ * `response.failed` is not inert in either direction: on the chat path the
+ * stream would end with no finish frame and no `[DONE]` (an SDK parser waits
+ * forever or throws), and on the Anthropic path the non-streaming collapse
+ * would find no terminal response and hand back a well-formed EMPTY success —
+ * a failure that reads as a normal, empty turn. Found by review on dario#1141;
+ * the chat-path half was the same bug, pre-existing.
+ */
+export function isTerminalResponsesEvent(type) {
+    return type === 'response.completed' || type === 'response.incomplete' || type === 'response.failed';
+}
+/** True when a terminal Responses payload describes a FAILURE rather than a turn. */
+export function isFailedResponse(resp) {
+    if (!resp || typeof resp !== 'object')
+        return false;
+    const r = resp;
+    return r.status === 'failed' || (r.error !== null && r.error !== undefined);
+}
+/** The upstream message on a failed Responses payload, for the error body. */
+export function failedResponseMessage(resp) {
+    const e = resp?.error;
+    const msg = e && typeof e.message === 'string' ? e.message : '';
+    const code = e && typeof e.code === 'string' ? e.code : '';
+    return msg || code || 'the Codex backend ended the response as failed';
+}
 /**
  * Stateful per-request translator: Responses SSE in, chat/completions out.
  *
@@ -229,6 +256,7 @@ export function createResponsesTranslator(model) {
     const toolCalls = new Map();
     let nextToolIndex = 0;
     let roleSent = false;
+    let failed = false;
     const frame = (delta, finish) => `data: ${JSON.stringify({
         id,
         object: 'chat.completion.chunk',
@@ -307,7 +335,9 @@ export function createResponsesTranslator(model) {
                 acc.args += d;
                 return opened(frame({ tool_calls: [{ index: acc.index, function: { arguments: d } }] }, null));
             }
-            if (type === 'response.completed' || type === 'response.incomplete') {
+            if (isTerminalResponsesEvent(type)) {
+                if (type === 'response.failed' || isFailedResponse(e.response))
+                    failed = true;
                 const r = e.response;
                 const u = r?.usage;
                 if (u) {
@@ -321,6 +351,10 @@ export function createResponsesTranslator(model) {
             }
             return null;
         },
+        /** True when the upstream stream terminated as a FAILURE. */
+        didFail() {
+            return failed;
+        },
         /** Everything seen so far, as one non-streaming chat.completion body. */
         complete() {
             const calls = [...toolCalls.values()].sort((a, b) => a.index - b.index);
@@ -357,26 +391,60 @@ export function buildCodexHeaders(creds) {
     return headers;
 }
 /**
- * Serve a /v1/chat/completions request from a stored Codex account.
+ * Serve a request from a stored Codex account, in either client wire shape.
+ *
+ * `shape` picks the two translation ends; everything between — headers, the
+ * timeout, the upstream POST, the read loop, the error paths — is shared,
+ * because only the translation differs between an OpenAI-shape and an
+ * Anthropic-shape client:
+ *
+ *   openai     chat/completions ─┐                    ┌─ chat.completion(.chunk)
+ *                                ├→ Responses (codex) ┤
+ *   anthropic  messages ─────────┘                    └─ Anthropic SSE / Message
+ *
+ * dario always asks the backend for a stream and collapses it here when the
+ * client didn't want one, so `stream: true` is forced on the way out for both
+ * shapes. For the Anthropic shape the non-streaming body is rebuilt from the
+ * `response` object carried by the terminal `response.completed` event.
  *
  * `fetchImpl` is injectable so the translation and header construction are
  * testable without network (test/codex-backend.mjs), matching the pattern
  * test/codex-oauth.mjs already uses.
  */
-export async function forwardToCodex(req, res, body, creds, corsOrigin, securityHeaders, upstreamTimeoutMs, verbose, fetchImpl = fetch) {
+export async function forwardToCodex(req, res, body, creds, corsOrigin, securityHeaders, upstreamTimeoutMs, verbose, shape = 'openai', fetchImpl = fetch) {
     void req;
+    const isAnthropic = shape === 'anthropic';
+    // An Anthropic-shape error body is {type,error{type,message}}; an OpenAI one
+    // is {error}. A client SDK reads its own shape, so errors follow the request.
+    const errBody = (message, extra = {}) => JSON.stringify(isAnthropic
+        ? { type: 'error', error: { type: 'api_error', message }, ...extra }
+        : { error: message, ...extra });
     let parsed;
     try {
         parsed = JSON.parse(body.toString());
     }
     catch {
         res.writeHead(400, { 'Content-Type': 'application/json', ...securityHeaders });
-        res.end(JSON.stringify({ error: 'Codex backend requires a JSON chat/completions body' }));
+        res.end(errBody(`Codex backend requires a JSON ${isAnthropic ? 'messages' : 'chat/completions'} body`));
         return;
     }
     const clientWantsStream = parsed.stream === true;
     const model = String(parsed.model ?? '');
-    const upstreamBody = chatCompletionsToResponses(parsed);
+    // stream is forced: the backend is always streamed and collapsed here.
+    const upstreamBody = isAnthropic
+        ? { ...anthropicToResponsesRequest(parsed, model), stream: true }
+        : chatCompletionsToResponses(parsed);
+    // The ChatGPT Codex backend REJECTS an output cap outright:
+    //   400 {"detail":"Unsupported parameter: max_output_tokens"}
+    // Both builders set it from the client's max_tokens / max_completion_tokens,
+    // so BOTH shapes 400 whenever a client asks for one. It stayed hidden because
+    // every smoke test so far happened to omit max_tokens; it then showed up as a
+    // 100% failure on the Anthropic path, where the Messages API REQUIRES
+    // max_tokens and so always produced it. Stripped here rather than in either
+    // translator because it is a property of THIS backend, not of either wire
+    // format — the same builders are correct against an API-key Responses
+    // endpoint, which does support the parameter.
+    delete upstreamBody.max_output_tokens;
     const target = `${CODEX_BACKEND_BASE_URL.replace(/\/$/, '')}/responses`;
     const abort = new AbortController();
     const timeout = setTimeout(() => abort.abort(), upstreamTimeoutMs);
@@ -394,14 +462,33 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             if (verbose)
                 console.error(`[dario] codex backend ${upstream.status}: ${detail.slice(0, 300)}`);
             res.writeHead(upstream.status, { 'Content-Type': 'application/json', ...securityHeaders });
-            res.end(JSON.stringify({
-                error: 'Upstream Codex backend error',
-                status: upstream.status,
-                account: creds.alias,
-            }));
+            res.end(errBody('Upstream Codex backend error', { status: upstream.status, account: creds.alias }));
             return;
         }
-        const translator = createResponsesTranslator(model);
+        // OpenAI shape: one stateful line-in/line-out translator (unchanged).
+        // Anthropic shape: parse the typed Responses event stream, then map events
+        // to Anthropic SSE, keeping the terminal `response` for the collapse.
+        const translator = isAnthropic ? null : createResponsesTranslator(model);
+        const sseParser = isAnthropic ? createResponsesSSEParser() : null;
+        const antTranslator = isAnthropic ? responsesStreamToAnthropicSSE({ requestModel: model }) : null;
+        let terminalResponse = null;
+        let anthropicFailed = false;
+        const emitAnthropic = (events) => {
+            for (const ev of events) {
+                const t = ev.type ?? '';
+                if (isTerminalResponsesEvent(t)) {
+                    const r = ev.response;
+                    if (r)
+                        terminalResponse = r;
+                    if (t === 'response.failed')
+                        anthropicFailed = true;
+                }
+                for (const out of antTranslator.push(ev)) {
+                    if (clientWantsStream)
+                        res.write(formatResponsesAnthropicSSE(out));
+                }
+            }
+        };
         if (clientWantsStream) {
             res.writeHead(200, {
                 'Content-Type': 'text/event-stream',
@@ -420,7 +507,13 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     const { done, value } = await reader.read();
                     if (done)
                         break;
-                    buffered += decoder.decode(value, { stream: true });
+                    const decoded = decoder.decode(value, { stream: true });
+                    if (isAnthropic) {
+                        // The parser owns its own partial-frame buffering.
+                        emitAnthropic(sseParser.push(decoded));
+                        continue;
+                    }
+                    buffered += decoded;
                     // SSE frames are newline-delimited; keep the trailing partial line.
                     const lines = buffered.split('\n');
                     buffered = lines.pop() ?? '';
@@ -434,13 +527,46 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             finally {
                 reader.releaseLock();
             }
-            if (buffered.length > 0) {
+            if (isAnthropic) {
+                emitAnthropic(sseParser.flush());
+            }
+            else if (buffered.length > 0) {
                 const out = translator.chunk(buffered);
                 if (out && clientWantsStream)
                     res.write(out);
             }
         }
-        if (clientWantsStream) {
+        // A stream that ended in failure must not collapse into a 200 with empty
+        // content: to a non-streaming client that is indistinguishable from a model
+        // that chose to say nothing. Streaming clients already saw the terminal
+        // event, so only the collapse needs this.
+        const upstreamFailed = isAnthropic
+            ? (anthropicFailed || isFailedResponse(terminalResponse))
+            : translator.didFail();
+        if (!clientWantsStream && upstreamFailed) {
+            const detail = failedResponseMessage(terminalResponse);
+            if (verbose)
+                console.error(`[dario] codex backend (${creds.alias}) response failed: ${detail}`);
+            res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
+            res.end(errBody(`Codex backend response failed: ${detail}`, { account: creds.alias }));
+            return;
+        }
+        if (isAnthropic) {
+            if (clientWantsStream) {
+                for (const out of antTranslator.end())
+                    res.write(formatResponsesAnthropicSSE(out));
+                res.end();
+            }
+            else {
+                res.writeHead(200, {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': corsOrigin,
+                    ...securityHeaders,
+                });
+                res.end(JSON.stringify(responsesToAnthropicResponse(terminalResponse ?? {}, model)));
+            }
+        }
+        else if (clientWantsStream) {
             res.end();
         }
         else {
@@ -460,7 +586,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             console.error(`[dario] codex backend (${creds.alias}) error: ${detail}`);
         if (!res.headersSent) {
             res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
-            res.end(JSON.stringify({ error: 'Upstream Codex backend error', account: creds.alias }));
+            res.end(errBody('Upstream Codex backend error', { account: creds.alias }));
         }
         else {
             try {

package/dist/provider-adapter.d.ts

@@ -64,10 +64,17 @@ export interface ProviderAdapter {
  * subscription even when an API-key backend is also configured; anything not
  * listed — `gpt-4o` and friends — is untouched and still lands on that backend.
  *
- * OpenAI-path only: the ChatGPT backend speaks Responses, and dario's
- * chat/completions⇄Responses translation (codex-backend.ts) is written against
- * the OpenAI request shape. An Anthropic-shape /v1/messages request would need
- * a second translation that doesn't exist, so it stays with Claude.
+ * Serves BOTH request shapes. The ChatGPT backend speaks Responses, and dario
+ * now owns a translation for each side of it: chat/completions⇄Responses in
+ * codex-backend.ts, and Messages⇄Responses in anthropic-responses-translate.ts
+ * (dario#1141). So an Anthropic-shape /v1/messages request naming a listed slug
+ * is served from the subscription too — which is what lets a Claude-shaped
+ * harness (Claude Code, or any Anthropic-SDK client) run on a ChatGPT plan.
+ *
+ * There is deliberately no path guard: the claim is driven by the MODEL, and a
+ * Claude model is never in `codexModels`, so Claude traffic on either path is
+ * untouched. The `openai` adapter below keeps its OpenAI-path guard — the
+ * API-key backend has no Messages translation.
  */
 export declare const codexAdapter: ProviderAdapter;
 /**

package/dist/provider-adapter.js

@@ -31,10 +31,17 @@ import { isCodexModel } from './codex-backend.js';
  * subscription even when an API-key backend is also configured; anything not
  * listed — `gpt-4o` and friends — is untouched and still lands on that backend.
  *
- * OpenAI-path only: the ChatGPT backend speaks Responses, and dario's
- * chat/completions⇄Responses translation (codex-backend.ts) is written against
- * the OpenAI request shape. An Anthropic-shape /v1/messages request would need
- * a second translation that doesn't exist, so it stays with Claude.
+ * Serves BOTH request shapes. The ChatGPT backend speaks Responses, and dario
+ * now owns a translation for each side of it: chat/completions⇄Responses in
+ * codex-backend.ts, and Messages⇄Responses in anthropic-responses-translate.ts
+ * (dario#1141). So an Anthropic-shape /v1/messages request naming a listed slug
+ * is served from the subscription too — which is what lets a Claude-shaped
+ * harness (Claude Code, or any Anthropic-SDK client) run on a ChatGPT plan.
+ *
+ * There is deliberately no path guard: the claim is driven by the MODEL, and a
+ * Claude model is never in `codexModels`, so Claude traffic on either path is
+ * untouched. The `openai` adapter below keeps its OpenAI-path guard — the
+ * API-key backend has no Messages translation.
  */
 export const codexAdapter = {
     id: 'codex',
@@ -42,8 +49,6 @@ export const codexAdapter = {
     claimsPrimary(ctx) {
         if (!ctx.hasCodexAccount)
             return false;
-        if (!ctx.isOpenAIPath)
-            return false;
         if (ctx.forcedProvider === 'claude' || ctx.forcedProvider === 'openai')
             return false;
         return ctx.forcedProvider === 'codex' || isCodexModel(ctx.model, ctx.codexModels);

package/dist/proxy.js

@@ -2498,7 +2498,7 @@ export async function startProxy(opts = {}) {
                     // an account added while the proxy runs routes on the very next
                     // request; the absent answer is cached ~30s, so an idle proxy with
                     // no codex account is not stat-ing the filesystem per request.
-                    if (isOpenAI && await hasAnyCodexAccount()) {
+                    if (await hasAnyCodexAccount()) {
                         const stored = await selectCodexAccount();
                         if (stored) {
                             codexCreds = await getFreshCodexAccount(stored);
@@ -2520,7 +2520,7 @@ export async function startProxy(opts = {}) {
                             console.log(`[dario] #${requestCount} ${req.method} ${urlPath} (model: ${rawModel}) → codex account ${codexCreds.alias}`);
                         }
                         requestCount++;
-                        await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose);
+                        await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic');
                         return;
                     }
                     if (rawModel && openaiBackend && decision.provider === 'openai') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "5.5.86",
+  "version": "5.5.88",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {