@askalf/dario 5.5.84 → 5.5.86

package/dist/cli.js

@@ -1138,6 +1138,8 @@ async function codex() {
             await completeAddCodexAccount(alias, code, codeVerifier);
             console.log('');
             console.log(`  Added Codex account "${alias}".`);
+            console.log('  A proxy that is already running picks it up within ~30s —');
+            console.log('  no restart needed (dario#1138).');
             console.log('');
         }
         catch (err) {

package/dist/codex-accounts.d.ts

@@ -6,6 +6,9 @@ export interface CodexAccountCredentials {
     idToken?: string;
 }
 export declare function listCodexAccountAliases(): Promise<string[]>;
+export declare function hasAnyCodexAccount(nowMs?: number): Promise<boolean>;
+/** Drop the negative cache so a test doesn't have to sleep out its TTL. */
+export declare function _resetCodexPresenceCacheForTest(): void;
 export declare function loadCodexAccount(alias: string): Promise<CodexAccountCredentials | null>;
 export declare function loadAllCodexAccounts(): Promise<CodexAccountCredentials[]>;
 export declare function saveCodexAccount(creds: CodexAccountCredentials): Promise<void>;

package/dist/codex-accounts.js

@@ -43,6 +43,35 @@ export async function listCodexAccountAliases() {
         return [];
     }
 }
+/**
+ * "Is the codex route available at all" — the routing question, asked per
+ * request rather than once at startup (dario#1138).
+ *
+ * The proxy used to resolve this a single time while booting, so an account
+ * stored by `dario codex add` against an ALREADY-RUNNING proxy stayed
+ * invisible until a restart: /v1/models advertised no gpt slugs and a listed
+ * slug fell through to the Claude path as an unknown model. `dario login`
+ * restarts the proxy by convention, `dario codex add` does not.
+ *
+ * Cheap enough to ask often — a readdir of a directory holding at most a
+ * handful of files — but an idle proxy still shouldn't hit the filesystem on
+ * every request, so the NEGATIVE answer is cached briefly. The positive one
+ * isn't cached: the caller goes on to read the credentials anyway, and a
+ * `codex remove` has to take effect immediately.
+ */
+const CODEX_PRESENCE_NEGATIVE_TTL_MS = 30_000;
+let codexAbsentUntil = 0;
+export async function hasAnyCodexAccount(nowMs = Date.now()) {
+    if (nowMs < codexAbsentUntil)
+        return false;
+    const present = (await listCodexAccountAliases()).length > 0;
+    codexAbsentUntil = present ? 0 : nowMs + CODEX_PRESENCE_NEGATIVE_TTL_MS;
+    return present;
+}
+/** Drop the negative cache so a test doesn't have to sleep out its TTL. */
+export function _resetCodexPresenceCacheForTest() {
+    codexAbsentUntil = 0;
+}
 export async function loadCodexAccount(alias) {
     const path = safeAliasPath(alias);
     if (!path)
@@ -66,6 +95,10 @@ export async function saveCodexAccount(creds) {
         throw new Error(`invalid codex account alias: ${creds.alias}`);
     await ensureDir();
     await durableWriteFile(path, JSON.stringify(creds, null, 2), 0o600);
+    // An account stored in THIS process (`dario codex add` in a running admin
+    // path, or a test) must not be hidden by a negative cache entry taken
+    // moments earlier.
+    codexAbsentUntil = 0;
 }
 export async function removeCodexAccount(alias) {
     const path = safeAliasPath(alias);

package/dist/codex-backend.js

@@ -228,6 +228,7 @@ export function createResponsesTranslator(model) {
     let usage = null;
     const toolCalls = new Map();
     let nextToolIndex = 0;
+    let roleSent = false;
     const frame = (delta, finish) => `data: ${JSON.stringify({
         id,
         object: 'chat.completion.chunk',
@@ -235,6 +236,25 @@ export function createResponsesTranslator(model) {
         model,
         choices: [{ index: 0, delta, finish_reason: finish }],
     })}\n\n`;
+    /**
+     * Prefix the role-only opening frame the first time we emit anything.
+     *
+     * The reference OpenAI stream always opens with
+     * `delta: {"role":"assistant","content":""}` before any content, and SDK
+     * accumulators (openai-node's ChatCompletionStream, and every harness built
+     * on it — Cursor, Continue, Aider) use that frame to OPEN the assistant
+     * message. Without it the assembled message has no role, which reads fine in
+     * a terminal and then fails when the harness sends that history back.
+     * Emitted at `response.created` in the normal case; the flag makes every
+     * other branch safe too, so a stream that somehow starts with a text delta
+     * still cannot put content on the wire before the role.
+     */
+    const opened = (rest) => {
+        if (roleSent)
+            return rest;
+        roleSent = true;
+        return frame({ role: 'assistant', content: '' }, null) + rest;
+    };
     return {
         /** Feed one raw SSE line. Returns the line to forward, or null. */
         chunk(line) {
@@ -255,14 +275,14 @@ export function createResponsesTranslator(model) {
                 const r = e.response;
                 if (r?.id)
                     id = `chatcmpl-${r.id.replace(/^resp_/, '')}`;
-                return null;
+                return opened('');
             }
             if (type === 'response.output_text.delta') {
                 const d = typeof e.delta === 'string' ? e.delta : '';
                 if (!d)
                     return null;
                 text += d;
-                return frame({ content: d }, null);
+                return opened(frame({ content: d }, null));
             }
             if (type === 'response.output_item.added') {
                 const item = e.item;
@@ -276,7 +296,7 @@ export function createResponsesTranslator(model) {
                     args: '',
                 };
                 toolCalls.set(key, acc);
-                return frame({ tool_calls: [{ index: acc.index, id: acc.id, type: 'function', function: { name: acc.name, arguments: '' } }] }, null);
+                return opened(frame({ tool_calls: [{ index: acc.index, id: acc.id, type: 'function', function: { name: acc.name, arguments: '' } }] }, null));
             }
             if (type === 'response.function_call_arguments.delta') {
                 const key = String(e.item_id ?? '');
@@ -285,7 +305,7 @@ export function createResponsesTranslator(model) {
                 if (!acc || !d)
                     return null;
                 acc.args += d;
-                return frame({ tool_calls: [{ index: acc.index, function: { arguments: d } }] }, null);
+                return opened(frame({ tool_calls: [{ index: acc.index, function: { arguments: d } }] }, null));
             }
             if (type === 'response.completed' || type === 'response.incomplete') {
                 const r = e.response;
@@ -297,7 +317,7 @@ export function createResponsesTranslator(model) {
                         total_tokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
                     };
                 }
-                return `${frame({}, toolCalls.size > 0 ? 'tool_calls' : 'stop')}data: [DONE]\n\n`;
+                return opened(`${frame({}, toolCalls.size > 0 ? 'tool_calls' : 'stop')}data: [DONE]\n\n`);
             }
             return null;
         },

package/dist/proxy.js

@@ -21,7 +21,7 @@ import { handleAdminRequest } from './admin-api.js';
 import { createTokenBucket } from './rate-limit.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 import { forwardToCodex, getCodexModelSlugs, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
-import { listCodexAccountAliases, selectCodexAccount, getFreshCodexAccount } from './codex-accounts.js';
+import { listCodexAccountAliases, hasAnyCodexAccount, selectCodexAccount, getFreshCodexAccount } from './codex-accounts.js';
 import { route as routeProvider } from './provider-adapter.js';
 import { RequestQueue, QueueFullError, QueueTimeoutError, DEFAULT_MAX_CONCURRENT, DEFAULT_MAX_QUEUED, DEFAULT_QUEUE_TIMEOUT_MS } from './request-queue.js';
 import { redactSecrets } from './redact.js';
@@ -1222,12 +1222,16 @@ export async function startProxy(opts = {}) {
         console.log(`  OpenAI-compat backend: ${openaiBackend.name} → ${openaiBackend.baseUrl}`);
     }
     // Codex/ChatGPT-subscription accounts — the "altman" engine (dario#1009).
-    // Loaded once at startup the same way the openai-compat backend is; the
-    // credentials themselves are re-read per request (they rotate on refresh),
-    // this only answers "is the codex route available at all" for routing.
-    let hasCodexAccount = (await listCodexAccountAliases()).length > 0;
-    if (hasCodexAccount) {
-        console.log(`  Codex accounts: ${(await listCodexAccountAliases()).join(', ')} → ${CODEX_BACKEND_BASE_URL}`);
+    // This startup probe only decides what to PRINT and whether a Claude login
+    // is required to boot; routing re-asks hasAnyCodexAccount() per request
+    // (dario#1138), so an account stored by `dario codex add` against an
+    // already-running proxy is picked up without a restart — `dario login`
+    // restarts the proxy by convention, `dario codex add` does not. The
+    // credentials themselves are re-read per request too (they rotate on
+    // refresh).
+    const startupCodexAliases = await listCodexAccountAliases();
+    if (startupCodexAliases.length > 0) {
+        console.log(`  Codex accounts: ${startupCodexAliases.join(', ')} → ${CODEX_BACKEND_BASE_URL}`);
     }
     // Pool-exhausted fallback (strictly opt-in). When the Claude pool can't
     // serve — every seat rate-limited or in auth cool-down — OpenAI-shape
@@ -1421,7 +1425,7 @@ export async function startProxy(opts = {}) {
     // dead-but-refreshable token (a container restarted right after a normal
     // expiry, gap #1) is refreshed, then back-filled so the recovered login
     // becomes the pool-of-one it should be — rather than crash-looping on exit(1).
-    if (requiresClaudeLogin(pool.size, adminEnabled, !!upstreamApiKey, opts.noClaudeAuth ?? false, hasCodexAccount)) {
+    if (requiresClaudeLogin(pool.size, adminEnabled, !!upstreamApiKey, opts.noClaudeAuth ?? false, startupCodexAliases.length > 0)) {
         const single = await resolveSingleAccountStartupStatus();
         if (!single.authenticated) {
             console.error('[dario] Not authenticated. Run `dario login` first.');
@@ -2168,7 +2172,7 @@ export async function startProxy(opts = {}) {
             // models that account may actually use. Discovery is cached and never
             // throws, so /v1/models keeps its "always answers" property.
             let codexNames = [];
-            if (hasCodexAccount) {
+            if (await hasAnyCodexAccount()) {
                 const stored = await selectCodexAccount();
                 if (stored) {
                     const creds = await getFreshCodexAccount(stored).catch(() => stored);
@@ -2490,17 +2494,16 @@ export async function startProxy(opts = {}) {
                     // case is a map lookup, not a request.
                     let codexCreds = null;
                     let codexModels = [];
-                    if (hasCodexAccount && isOpenAI) {
+                    // Presence is re-asked here rather than read from a startup flag so
+                    // 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()) {
                         const stored = await selectCodexAccount();
                         if (stored) {
                             codexCreds = await getFreshCodexAccount(stored);
                             codexModels = await getCodexModelSlugs(codexCreds);
                         }
-                        else {
-                            // Accounts disappeared since startup — re-arm the routing flag so
-                            // later requests skip the codex path entirely.
-                            hasCodexAccount = false;
-                        }
                     }
                     const decision = routeProvider({
                         isOpenAIPath: isOpenAI,

package/package.json

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