@askalf/dario 5.5.88 → 5.5.90

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.d.ts

@@ -114,6 +114,27 @@ export declare function createResponsesTranslator(model: string): {
     /** Everything seen so far, as one non-streaming chat.completion body. */
     complete(): Record<string, unknown>;
 };
+/**
+ * Fields the ChatGPT Codex backend accepts on /responses.
+ *
+ * It is NOT the public Responses API: it rejects a whole class of sampling and
+ * metadata parameters outright, one 400 at a time —
+ *   400 {"detail":"Unsupported parameter: <name>"}
+ * Probed directly against a live subscription (2026-08-30); rejected were
+ * temperature, top_p, max_output_tokens, presence_penalty, frequency_penalty,
+ * seed, metadata, top_logprobs, truncation and service_tier.
+ *
+ * This is an ALLOWLIST rather than a list of the ten known-bad names on
+ * purpose. The backend is undocumented and clearly restrictive, so the failure
+ * we must not have is "we started sending a new field and every request 400s".
+ * Dropping an unknown field degrades one request; sending one breaks all of
+ * them. Both request builders stay correct for an API-key Responses endpoint —
+ * which does accept these — because the scrub happens HERE, at the transport
+ * that knows which backend it is talking to.
+ */
+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 request from a stored Codex account, in either client wire shape.

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';
@@ -377,6 +377,37 @@ export function createResponsesTranslator(model) {
         },
     };
 }
+/**
+ * Fields the ChatGPT Codex backend accepts on /responses.
+ *
+ * It is NOT the public Responses API: it rejects a whole class of sampling and
+ * metadata parameters outright, one 400 at a time —
+ *   400 {"detail":"Unsupported parameter: <name>"}
+ * Probed directly against a live subscription (2026-08-30); rejected were
+ * temperature, top_p, max_output_tokens, presence_penalty, frequency_penalty,
+ * seed, metadata, top_logprobs, truncation and service_tier.
+ *
+ * This is an ALLOWLIST rather than a list of the ten known-bad names on
+ * purpose. The backend is undocumented and clearly restrictive, so the failure
+ * we must not have is "we started sending a new field and every request 400s".
+ * Dropping an unknown field degrades one request; sending one breaks all of
+ * them. Both request builders stay correct for an API-key Responses endpoint —
+ * which does accept these — because the scrub happens HERE, at the transport
+ * that knows which backend it is talking to.
+ */
+export const CODEX_SUPPORTED_FIELDS = [
+    'model', 'input', 'stream', 'store', 'instructions',
+    'tools', 'tool_choice', 'parallel_tool_calls', 'reasoning',
+];
+/** Drop every field this backend does not accept. Pure; exported for tests. */
+export function toCodexSupportedBody(body) {
+    const out = {};
+    for (const k of CODEX_SUPPORTED_FIELDS) {
+        if (body[k] !== undefined)
+            out[k] = body[k];
+    }
+    return out;
+}
 export function buildCodexHeaders(creds) {
     const headers = {
         'Content-Type': 'application/json',
@@ -434,17 +465,7 @@ 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 scrubbed = toCodexSupportedBody(upstreamBody);
     const target = `${CODEX_BACKEND_BASE_URL.replace(/\/$/, '')}/responses`;
     const abort = new AbortController();
     const timeout = setTimeout(() => abort.abort(), upstreamTimeoutMs);
@@ -454,7 +475,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         const upstream = await fetchImpl(target, {
             method: 'POST',
             headers: buildCodexHeaders(creds),
-            body: JSON.stringify(upstreamBody),
+            body: JSON.stringify(scrubbed),
             signal: abort.signal,
         });
         if (!upstream.ok) {
@@ -471,6 +492,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) => {
@@ -483,7 +508,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));
                 }
@@ -563,7 +591,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.88",
+  "version": "5.5.90",
   "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": {