@askalf/dario 5.5.87 → 5.5.89

package/dist/anthropic-responses-translate.d.ts

@@ -516,6 +516,22 @@ export declare function parseResponsesSSEEvent(eventLine: string | undefined, da
  * Call `flush()` at end-of-stream to parse any trailing record that was
  * not blank-line terminated. Pure and offline-testable.
  */
+/**
+ * Fold the Anthropic stream this module produces back into ONE Message.
+ *
+ * Needed because the ChatGPT Codex backend's terminal `response.completed`
+ * carries `output: []` — the content only ever exists in the delta events, so
+ * `responsesToAnthropicResponse(terminal)` yields an empty message. (The
+ * standard Responses API does populate `output`, which is why this was not
+ * obvious.) The chat path has always avoided the trap by accumulating from
+ * deltas; this is the same discipline for the Anthropic shape, and it means
+ * the streaming and non-streaming bodies are assembled from ONE translation
+ * rather than two that can disagree. dario#1143.
+ */
+export declare function createAnthropicMessageAssembler(): {
+    push(events: readonly ResponsesAnthropicStreamEvent[]): void;
+    message(fallbackModel: string): AnthropicResponseWithThinking;
+};
 export declare function createResponsesSSEParser(): {
     push(chunk: string): ResponsesStreamEvent[];
     flush(): ResponsesStreamEvent[];

package/dist/anthropic-responses-translate.js

@@ -791,6 +791,75 @@ export function parseResponsesSSEEvent(eventLine, dataLine) {
  * Call `flush()` at end-of-stream to parse any trailing record that was
  * not blank-line terminated. Pure and offline-testable.
  */
+/**
+ * Fold the Anthropic stream this module produces back into ONE Message.
+ *
+ * Needed because the ChatGPT Codex backend's terminal `response.completed`
+ * carries `output: []` — the content only ever exists in the delta events, so
+ * `responsesToAnthropicResponse(terminal)` yields an empty message. (The
+ * standard Responses API does populate `output`, which is why this was not
+ * obvious.) The chat path has always avoided the trap by accumulating from
+ * deltas; this is the same discipline for the Anthropic shape, and it means
+ * the streaming and non-streaming bodies are assembled from ONE translation
+ * rather than two that can disagree. dario#1143.
+ */
+export function createAnthropicMessageAssembler() {
+    let msg = null;
+    const blocks = [];
+    const partialJson = new Map();
+    return {
+        push(events) {
+            for (const e of events) {
+                if (e.type === 'message_start') {
+                    msg = { ...e.message, content: [] };
+                }
+                else if (e.type === 'content_block_start') {
+                    blocks[e.index] = { ...e.content_block };
+                    if (e.content_block.type === 'tool_use')
+                        partialJson.set(e.index, '');
+                }
+                else if (e.type === 'content_block_delta') {
+                    const b = blocks[e.index] ?? (blocks[e.index] = {});
+                    const d = e.delta;
+                    if (d.type === 'text_delta')
+                        b.text = String(b.text ?? '') + d.text;
+                    else if (d.type === 'thinking_delta')
+                        b.thinking = String(b.thinking ?? '') + d.thinking;
+                    else if (d.type === 'input_json_delta')
+                        partialJson.set(e.index, (partialJson.get(e.index) ?? '') + d.partial_json);
+                }
+                else if (e.type === 'message_delta') {
+                    if (msg) {
+                        msg.stop_reason = e.delta.stop_reason;
+                        const u = msg.usage ?? { input_tokens: 0, output_tokens: 0 };
+                        msg.usage = {
+                            ...u,
+                            output_tokens: e.usage.output_tokens,
+                            input_tokens: e.usage.input_tokens ?? u.input_tokens,
+                        };
+                    }
+                }
+            }
+        },
+        message(fallbackModel) {
+            for (const [i, raw] of partialJson) {
+                const b = blocks[i];
+                if (!b || b.type !== 'tool_use')
+                    continue;
+                b.input = safeParseArguments(raw);
+            }
+            const content = blocks.filter(Boolean);
+            if (!msg) {
+                return {
+                    id: 'msg_dario', type: 'message', role: 'assistant', model: fallbackModel,
+                    content, stop_reason: 'end_turn', stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 },
+                };
+            }
+            return { ...msg, content };
+        },
+    };
+}
 export function createResponsesSSEParser() {
     let buffer = '';
     const boundary = /\r?\n\r?\n/;

package/dist/codex-backend.js

@@ -1,4 +1,4 @@
-import { anthropicToResponsesRequest, createResponsesSSEParser, formatResponsesAnthropicSSE, responsesStreamToAnthropicSSE, responsesToAnthropicResponse, } from './anthropic-responses-translate.js';
+import { anthropicToResponsesRequest, createResponsesSSEParser, formatResponsesAnthropicSSE, createAnthropicMessageAssembler, responsesStreamToAnthropicSSE, } 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';
@@ -434,6 +434,17 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
     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);
@@ -460,6 +471,10 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         const translator = isAnthropic ? null : createResponsesTranslator(model);
         const sseParser = isAnthropic ? createResponsesSSEParser() : null;
         const antTranslator = isAnthropic ? responsesStreamToAnthropicSSE({ requestModel: model }) : null;
+        // The non-streaming body is FOLDED FROM THE STREAM, not read off the
+        // terminal event: this backend sends response.completed with output: [],
+        // so the content exists only in the deltas (dario#1143).
+        const antAssembler = isAnthropic ? createAnthropicMessageAssembler() : null;
         let terminalResponse = null;
         let anthropicFailed = false;
         const emitAnthropic = (events) => {
@@ -472,7 +487,10 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     if (t === 'response.failed')
                         anthropicFailed = true;
                 }
-                for (const out of antTranslator.push(ev)) {
+                const produced = antTranslator.push(ev);
+                if (!clientWantsStream)
+                    antAssembler.push(produced);
+                for (const out of produced) {
                     if (clientWantsStream)
                         res.write(formatResponsesAnthropicSSE(out));
                 }
@@ -552,7 +570,8 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     'Access-Control-Allow-Origin': corsOrigin,
                     ...securityHeaders,
                 });
-                res.end(JSON.stringify(responsesToAnthropicResponse(terminalResponse ?? {}, model)));
+                antAssembler.push(antTranslator.end());
+                res.end(JSON.stringify(antAssembler.message(model)));
             }
         }
         else if (clientWantsStream) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "5.5.87",
+  "version": "5.5.89",
   "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": {