mixdog 0.9.19 → 0.9.21

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -319,16 +319,34 @@ export function bp1HasDeferredToolManifestBlock(text) {
 }
 
 /**
- * Names-only manifest for tools in the deferred pool (catalog minus active wire tools).
+ * Skill-style manifest for tools in the deferred pool (catalog minus active
+ * wire tools). Each entry is either a bare name string or `{ name, description }`;
+ * output lines are `- name: description` (description omitted when absent),
+ * mirroring the available-skills manifest so the model calls deferred tools
+ * directly. Descriptions are compacted and stripped of `<`/`>`.
  * Empty pool → '' (caller omits the block).
  */
-export function buildDeferredToolManifest(names) {
-    const list = [...new Set((Array.isArray(names) ? names : [])
-        .map((name) => sanitizeDeferredToolManifestName(name))
-        .filter(Boolean))]
-        .sort((a, b) => a.localeCompare(b));
+export function buildDeferredToolManifest(entries) {
+    const list = [];
+    const seen = new Set();
+    for (const entry of Array.isArray(entries) ? entries : []) {
+        const rawName = typeof entry === 'string' ? entry : entry?.name;
+        const name = sanitizeDeferredToolManifestName(rawName);
+        if (!name || seen.has(name)) continue;
+        seen.add(name);
+        const description = typeof entry === 'string'
+            ? ''
+            : compactSkillManifestText(String(entry?.description || '').replace(/[<>]/g, ''));
+        list.push({ name, description });
+    }
     if (!list.length) return '';
-    return ['<available-deferred-tools>', ...list, '</available-deferred-tools>'].join('\n');
+    list.sort((a, b) => a.name.localeCompare(b.name));
+    return [
+        '<available-deferred-tools>',
+        'You may call any tool listed below directly by name with its arguments; it auto-loads on first call.',
+        ...list.map((entry) => (entry.description ? `- ${entry.name}: ${entry.description}` : `- ${entry.name}`)),
+        '</available-deferred-tools>',
+    ].join('\n');
 }
 
 function sanitizeMcpManifestServerName(name) {
@@ -389,12 +407,18 @@ export function stripDeferredToolManifestBlock(text) {
         .trimEnd();
 }
 
-/** Inject names-only deferred pool into BP1 once at session start; never rewrite BP1 after. */
+/** Inject the skill-style deferred pool (name + description) into BP1 once at session start; never rewrite BP1 after. */
 export function applyInitialDeferredToolManifestToBp1(session, poolNames) {
     if (!session || !Array.isArray(session.messages) || session.deferredToolBp1Applied) return false;
     const pool = Array.isArray(poolNames) ? poolNames : [];
+    const descByName = new Map();
+    for (const tool of Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []) {
+        const name = String(tool?.name || '').trim();
+        if (name && !descByName.has(name)) descByName.set(name, String(tool?.description || ''));
+    }
+    const entries = pool.map((name) => ({ name, description: descByName.get(String(name).trim()) || '' }));
     const parts = [];
-    const deferredManifest = buildDeferredToolManifest(pool);
+    const deferredManifest = buildDeferredToolManifest(entries);
     if (deferredManifest) parts.push(deferredManifest);
     const mcpManifest = buildMcpInstructionsManifest(session.mcpServerInstructions, pool);
     if (mcpManifest) parts.push(mcpManifest);

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';
 import { loadConfig } from '../config.mjs';
 import { sanitizeToolPairs, sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../session/context-utils.mjs';
-import { classifyError, midstreamBackoffFor, sleepWithAbort, withRetry } from './retry-classifier.mjs';
+import { classifyError, midstreamBackoffFor, sleepWithAbort, withRetry, retryAfterMsFromError } from './retry-classifier.mjs';
 import { traceAgentUsage } from '../agent-trace.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
@@ -518,7 +518,8 @@ export class AnthropicProvider {
         try {
             return await this._doSend(messages, model, tools, sendOpts);
         } catch (err) {
-            if (err.message && (err.message.includes('401') || err.message.includes('403'))) {
+            if (err.message && (err.message.includes('401') || err.message.includes('403'))
+                && !err.liveTextEmitted && !err.emittedToolCall && !err.unsafeToRetry) {
                 process.stderr.write(`[provider] Auth error, re-reading config...\n`);
                 this.reloadApiKey();
                 return await this._doSend(messages, model, tools, sendOpts);
@@ -745,6 +746,22 @@ export class AnthropicProvider {
                                 const err = new Error(`Anthropic API ${res.status}: ${text.slice(0, 200)}`);
                                 err.status = res.status;
                                 err.httpStatus = res.status;
+                                // Carry response headers so withRetry can honor a
+                                // short Retry-After and upstream can read quota hints.
+                                err.headers = res.headers;
+                                err.response = { status: res.status, headers: res.headers };
+                                // 429: promote to a quota-style error equivalent to
+                                // anthropic-oauth's anthropicQuotaError so upstream
+                                // quota handling and unsafe-to-retry gating apply.
+                                if (res.status === 429) {
+                                    const retryAfterMs = retryAfterMsFromError({ headers: res.headers, response: { headers: res.headers } });
+                                    err.name = 'ProviderQuotaError';
+                                    err.code = 'PROVIDER_QUOTA';
+                                    err.retryAfterMs = retryAfterMs;
+                                    err.providerQuota = true;
+                                    err.quotaExceeded = true;
+                                    err.unsafeToRetry = true;
+                                }
                                 throw err;
                             }
                             if (!res.body) {
@@ -858,6 +875,21 @@ export class AnthropicProvider {
                         await _midstreamSleepWithAbort(midstreamBackoffFor(attemptIndex + 1), totalSignal);
                         continue;
                     }
+                    if (classifyError(err) === 'transient'
+                        && !midState.sawMessageStart
+                        && !midState.emittedToolCall
+                        && attemptIndex < MAX_MIDSTREAM_RETRIES) {
+                        firstAttemptError = err;
+                        firstAttemptClassifier = err?.providerErrorType || 'sse_transient';
+                        try { streamController.abort?.(err); } catch {}
+                        try {
+                            process.stderr.write(
+                                `[${this.name}] transient SSE error — retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES} (${err?.providerErrorType || err?.message || 'unknown'})\n`,
+                            );
+                        } catch {}
+                        await _midstreamSleepWithAbort(midstreamBackoffFor(attemptIndex + 1), totalSignal);
+                        continue;
+                    }
                     if ((err?.truncatedStream === true || err?.code === 'TRUNCATED_STREAM')
                         && classifyError(err) === 'transient'
                         && !midState.emittedToolCall

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -478,6 +478,9 @@ export class GeminiProvider {
             return await this._doSend(messages, model, tools, sendOpts);
         } catch (err) {
             if (err.message && (err.message.includes('401') || err.message.includes('403'))) {
+                if (err.liveTextEmitted === true || err.emittedToolCall === true || err.unsafeToRetry === true) {
+                    throw err;
+                }
                 process.stderr.write(`[provider] Auth error, re-reading config...\n`);
                 this.reloadApiKey();
                 return await this._doSend(messages, model, tools, sendOpts);

package/src/runtime/agent/orchestrator/providers/grok-oauth.mjs

@@ -308,10 +308,7 @@ export function forgetGrokOAuthCredentials() {
 }
 
 let _refreshInFlight = null;
-async function refreshTokens(tokens) {
-    if (!tokens?.refresh_token) {
-        throw new Error('[grok-oauth] refresh token not available — open /providers in mixdog to sign in again');
-    }
+async function _postRefresh(tokens) {
     const tokenEndpoint = tokens.token_endpoint
         ? assertTrustedXaiEndpoint(tokens.token_endpoint, 'token endpoint')
         : (await fetchDiscovery()).token_endpoint;
@@ -365,6 +362,34 @@ async function refreshTokens(tokens) {
     }
 }
 
+// 16 mixdog processes share one grok-oauth.json and xAI rotates refresh
+// tokens single-use. Re-read the store immediately before the network POST so
+// a peer's just-completed rotation is adopted instead of spending our
+// (now-stale) refresh_token; on invalid_grant, re-read once and retry with a
+// peer-rotated refresh_token before propagating.
+async function refreshTokens(tokens, { force = false } = {}) {
+    if (!tokens?.refresh_token) {
+        throw new Error('[grok-oauth] refresh token not available — open /providers in mixdog to sign in again');
+    }
+    const disk = _loadOwnTokens();
+    const validAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);
+    if (disk?.access_token && disk.access_token !== tokens.access_token
+        && (!disk.expires_at || disk.expires_at >= validAfter)) {
+        return disk;
+    }
+    try {
+        return await _postRefresh(tokens);
+    } catch (err) {
+        if (err?.isInvalidGrant) {
+            const rotated = _loadOwnTokens();
+            if (rotated?.refresh_token && rotated.refresh_token !== tokens.refresh_token) {
+                return await _postRefresh(rotated);
+            }
+        }
+        throw err;
+    }
+}
+
 // --- Model catalog cache (24h disk TTL) ---
 const _modelCache = makeModelCache({
     fileName: 'grok-oauth-models.json',
@@ -530,6 +555,9 @@ export class GrokOAuthProvider {
     tokens = null;
     _inner = null;
     _innerKey = null;
+    // Grace window after a non-force refresh failure: keep serving the current
+    // still-valid access_token instead of thrashing the shared refresh_token.
+    _refreshFallbackUntil = 0;
 
     constructor(config) {
         this.config = config || {};
@@ -553,15 +581,44 @@ export class GrokOAuthProvider {
             if (disk?.access_token) this.tokens = disk;
             this._lastDiskScan = ownM;
         }
+        if (!forceRefresh && this._refreshFallbackUntil > Date.now() && this.tokens?.access_token
+            && (!this.tokens.expires_at || this.tokens.expires_at > Date.now())) {
+            return this.tokens;
+        }
         const expiring = this.tokens.expires_at
             && this.tokens.expires_at < Date.now() + TOKEN_REFRESH_SKEW_MS;
         if (forceRefresh || expiring) {
-            if (_refreshInFlight) {
-                this.tokens = await _refreshInFlight;
-            } else {
-                _refreshInFlight = refreshTokens(this.tokens)
-                    .finally(() => { _refreshInFlight = null; });
-                this.tokens = await _refreshInFlight;
+            const currentToken = this.tokens?.access_token || null;
+            try {
+                if (_refreshInFlight) {
+                    const shared = await _refreshInFlight;
+                    this.tokens = shared;
+                    // A forced caller must not accept a shared non-force result
+                    // that merely handed back its own prior token: start a fresh
+                    // forced refresh instead (mirror openai-oauth).
+                    if (forceRefresh && shared?.access_token === currentToken) {
+                        if (!_refreshInFlight) {
+                            _refreshInFlight = refreshTokens(this.tokens, { force: true })
+                                .finally(() => { _refreshInFlight = null; });
+                        }
+                        this.tokens = await _refreshInFlight;
+                    }
+                } else {
+                    _refreshInFlight = refreshTokens(this.tokens, { force: forceRefresh })
+                        .finally(() => { _refreshInFlight = null; });
+                    this.tokens = await _refreshInFlight;
+                }
+                this._refreshFallbackUntil = 0;
+            } catch (err) {
+                // Non-force failure while the current token is still valid: serve
+                // it under a grace window rather than throwing (mirror openai-oauth).
+                if (!forceRefresh && currentToken
+                    && (!this.tokens?.expires_at || this.tokens.expires_at > Date.now())) {
+                    this._refreshFallbackUntil = Date.now() + TOKEN_REFRESH_SKEW_MS;
+                    process.stderr.write(`[grok-oauth] Refresh failed (${String(err?.message || err).slice(0, 120)}); using still-valid current token\n`);
+                    return this.tokens;
+                }
+                throw err;
             }
         }
         return this.tokens;

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -173,6 +173,9 @@ export class OpenAICompatProvider {
             return await this._doSend(messages, model, tools, sendOpts);
         } catch (err) {
             if (err.message && (err.message.includes('401') || err.message.includes('403'))) {
+                if (err.liveTextEmitted === true || err.emittedToolCall === true || err.unsafeToRetry === true) {
+                    throw err;
+                }
                 process.stderr.write(`[provider] Auth error, re-reading config...\n`);
                 this.reloadApiKey();
                 return await this._doSend(messages, model, tools, sendOpts);

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -27,6 +27,13 @@ import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './ant
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL, _displayCodexModel } from './openai-oauth.mjs';
 
+// Public OpenAI Responses API endpoint for the api-key `openai` provider.
+// The openai-direct WS transport hits the same origin (openai-ws-pool
+// OPENAI_WS_URL = wss://api.openai.com/v1/responses); this HTTP/SSE fallback
+// mirrors it so OpenAIDirectProvider can fall back off WebSocket like
+// openai-oauth. Same Responses SSE wire format, only endpoint + auth differ.
+const OPENAI_DIRECT_RESPONSES_URL = 'https://api.openai.com/v1/responses';
+
 export function _envFlag(name, fallback = true) {
     const raw = process.env[name];
     if (raw == null || raw === '') return fallback;
@@ -116,6 +123,18 @@ function _pushOutputTextAnnotations(part, citations, citationKeys) {
 }
 
 function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
+    if (auth?.type === 'openai-direct') {
+        // Public API-key auth: Bearer <OPENAI_API_KEY>, no chatgpt-account-id /
+        // originator (mirrors openai-ws-pool _buildHandshakeHeaders' direct
+        // branch). session_id anchors are an OAuth-backend behavior, so omit
+        // them — the public API keys its prefix cache off body.prompt_cache_key.
+        return {
+            Authorization: `Bearer ${auth.apiKey}`,
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream',
+            'x-client-request-id': randomBytes(16).toString('hex'),
+        };
+    }
     const headers = {
         Authorization: `Bearer ${auth.access_token}`,
         'Content-Type': 'application/json',
@@ -189,10 +208,13 @@ export async function sendViaHttpSse({
     );
     const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey });
     const fetchStartedAt = Date.now();
+    const responsesUrl = auth?.type === 'openai-direct'
+        ? OPENAI_DIRECT_RESPONSES_URL
+        : CODEX_RESPONSES_URL;
     let response;
     try {
         try { onStageChange?.('requesting'); } catch {}
-        response = await fetchFn(CODEX_RESPONSES_URL, {
+        response = await fetchFn(responsesUrl, {
             method: 'POST',
             headers,
             body: JSON.stringify(body),
@@ -304,6 +326,17 @@ export async function sendViaHttpSse({
     // a second attempt.
     let emittedText = false;
 
+    // Tool-emit invariant (mirrors emittedText, WS path's emittedToolCall): set
+    // once onToolCall has actually dispatched a call. A failure afterwards is
+    // non-retryable — the side-effecting tool already ran, and any upstream
+    // retry/fallback would double-execute it. Stamped onto errors below so
+    // shouldFallbackTransport / the WS auth-retry gate refuse to reissue.
+    let emittedToolCall = false;
+    const _stampToolSafety = (err) => {
+        if (emittedToolCall && err) { try { err.emittedToolCall = true; err.unsafeToRetry = true; } catch {} }
+        return err;
+    };
+
     // Single-emit guard for tool calls (matches the WS path's
     // emittedToolCall intent). The HTTP/SSE event stream can surface the
     // same function_call across multiple frames — response.function_call_arguments.done,
@@ -324,6 +357,7 @@ export async function sendViaHttpSse({
         if (emittedToolCallIds.has(call.id)) return;
         emittedToolCallIds.add(call.id);
         if (!_toolDedupe.shouldDispatch(call.name, call.arguments)) return;
+        emittedToolCall = true;
         try { onToolCall?.(call); } catch {}
     };
 
@@ -676,6 +710,9 @@ export async function sendViaHttpSse({
         // Live-text invariant: once a non-empty chunk has been relayed it
         // cannot be withdrawn — flag the error so no upstream layer retries.
         if (emittedText && err) { try { err.liveTextEmitted = true; err.unsafeToRetry = true; } catch {} }
+        // Tool-emit invariant: an error after a dispatched tool call must not
+        // reissue the turn (double-execution). Stamp emittedToolCall too.
+        _stampToolSafety(err);
         throw err;
     } finally {
         _clearSemanticIdle();
@@ -688,10 +725,10 @@ export async function sendViaHttpSse({
 
     const unresolved = toolCalls.find(t => t._pendingItemId);
     if (unresolved) {
-        throw new Error(`OpenAI OAuth HTTP fallback function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`);
+        throw _stampToolSafety(new Error(`OpenAI OAuth HTTP fallback function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`));
     }
     if (!completed && !content && !toolCalls.length) {
-        throw new Error('OpenAI OAuth HTTP fallback ended before response.completed');
+        throw _stampToolSafety(new Error('OpenAI OAuth HTTP fallback ended before response.completed'));
     }
 
     const liveModel = model || useModel;

package/src/runtime/agent/orchestrator/providers/openai-ws.mjs

@@ -16,6 +16,9 @@ import { sendViaWebSocket } from './openai-oauth-ws.mjs';
 import { buildRequestBody } from './openai-oauth.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
+import { sendViaHttpSse, _envFlag } from './openai-oauth-http-sse.mjs';
+import { shouldFallbackTransport } from './retry-classifier.mjs';
+import { loadConfig } from '../config.mjs';
 import {
     resolveProviderCacheKey,
     resolveProviderPromptCacheLane,
@@ -52,6 +55,23 @@ export class OpenAIDirectProvider {
         if (!k) throw new Error('OPENAI_API_KEY not configured (providers.openai.apiKey)');
         return k;
     }
+    // Auth-recovery mirror of openai-compat.reloadApiKey: on a 401/403 the key
+    // was likely rotated in config after this provider instance was built, so
+    // re-read providers.openai.apiKey from disk before the single retry.
+    // Returns the fresh key (or null if none) — no client to rebuild here since
+    // the WS/HTTP transports take the key per-call via the `auth` object.
+    reloadApiKey() {
+        try {
+            const freshConfig = loadConfig();
+            const cfg = freshConfig.providers?.openai;
+            const newKey = cfg?.apiKey || this.config.apiKey;
+            if (newKey) {
+                this.config = { ...(this.config || {}), ...(cfg || {}), apiKey: newKey };
+                return newKey;
+            }
+        } catch { /* best effort */ }
+        return null;
+    }
     async send(messages, model, tools, sendOpts) {
         const opts = sendOpts || {};
         const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
@@ -109,10 +129,8 @@ export class OpenAIDirectProvider {
         const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai');
         const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
         const auth = { type: 'openai-direct', apiKey };
-        return sendViaWebSocket({
-            auth,
+        const common = {
             body,
-            sendOpts: opts,
             onStreamDelta,
             onToolCall,
             onTextDelta,
@@ -122,8 +140,60 @@ export class OpenAIDirectProvider {
             cacheKey,
             iteration,
             useModel,
+        };
+        const dispatchWs = (a) => sendViaWebSocket({
+            ...common,
+            auth: a,
+            sendOpts: opts,
             displayModel: (id) => id,
         });
+        // WS→HTTP/SSE fallback mirrors the openai-oauth wrapper: the shared
+        // HTTP transport now accepts auth.type==='openai-direct' (public
+        // Responses endpoint + Bearer <apiKey>), so the api-key provider gets
+        // the same envelope. Gate via shouldFallbackTransport (denies
+        // 401/403/404/429 + liveTextEmitted/emittedToolCall/unsafeToRetry).
+        const httpFallbackEnabled = _envFlag('MIXDOG_OPENAI_HTTP_FALLBACK', true);
+        const dispatchHttp = (a) => {
+            if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) {
+                process.stderr.write('[openai-ws] WebSocket unhealthy; falling back to HTTP/SSE\n');
+            }
+            return sendViaHttpSse({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
+        };
+        try {
+            return await dispatchWs(auth);
+        } catch (err) {
+            const status = err?.httpStatus;
+            // Live-text/tool invariant: never reissue a turn that already
+            // relayed visible output or dispatched a tool call.
+            const unsafeToRetry = err?.liveTextEmitted === true
+                || err?.emittedToolCall === true
+                || err?.unsafeToRetry === true;
+            // (1) 401/403 → reload apiKey from config and retry once over WS.
+            //     shouldFallbackTransport denies 401/403, so this branch owns
+            //     its own guard.
+            if ((status === 401 || status === 403) && !unsafeToRetry) {
+                process.stderr.write(`[openai-ws] ${status} — reloading apiKey and retrying once\n`);
+                const freshKey = this.reloadApiKey();
+                if (freshKey) {
+                    const retryAuth = { type: 'openai-direct', apiKey: freshKey };
+                    try {
+                        return await dispatchWs(retryAuth);
+                    } catch (retryErr) {
+                        if (shouldFallbackTransport(retryErr, { signal: externalSignal, enabled: httpFallbackEnabled })) {
+                            return await dispatchHttp(retryAuth);
+                        }
+                        throw retryErr;
+                    }
+                }
+                throw err;
+            }
+            // (2) WS transport failure → HTTP/SSE fallback (predicate handles
+            //     the safety denies).
+            if (shouldFallbackTransport(err, { signal: externalSignal, enabled: httpFallbackEnabled })) {
+                return await dispatchHttp(auth);
+            }
+            throw err;
+        }
     }
     async listModels() {
         try {