mixdog 0.8.0 → 0.9.0

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

@@ -1,7 +1,7 @@
 /**
  * OpenAI Direct API — WebSocket transport via Responses API.
  *
- * Uses the same `sendViaWebSocket` plumbing as openai-oauth (Codex), with two
+ * Uses the same `sendViaWebSocket` plumbing as openai-oauth, with two
  * differences encoded in the `auth.type === 'openai-direct'` branch inside
  * openai-oauth-ws.mjs:
  *   1. Authorization header: Bearer <OPENAI_API_KEY> (no account_id, no
@@ -18,7 +18,7 @@ import { enrichModels } from './model-catalog.mjs';
 import {
     resolveProviderCacheKey,
     resolveProviderPromptCacheLane,
-} from '../smart-bridge/cache-strategy.mjs';
+} from '../agent-runtime/cache-strategy.mjs';
 
 const OPENAI_DIRECT_PRIORITY_MODEL_PATTERNS = Object.freeze([
     /^gpt-5\.5(?:-\d{4}|$)/,
@@ -67,13 +67,13 @@ export class OpenAIDirectProvider {
             promptCacheLane,
         });
         // Public OpenAI API priority support is documented separately from the
-        // Codex OAuth catalog. Keep this provider's service-tier decision local
-        // so gpt-5.4-mini can opt into Priority even when the Codex catalog does
+        // openai-oauth catalog. Keep this provider's service-tier decision local
+        // so gpt-5.4-mini can opt into Priority even when the OAuth catalog does
         // not advertise a Fast tier for its OAuth endpoint.
         applyOpenAIDirectFastTier(body, useModel, opts);
         // Public Responses API supports prompt_cache_retention='24h' at no
         // extra cost (same cached_input_tokens billing as the default 5–10
-        // min in-memory cache). Codex/oauth rejects the parameter, so it's
+        // min in-memory cache). openai-oauth rejects the parameter, so it's
         // injected only on the direct path. See openai-oauth.mjs:290-294
         // for the rationale.
         body.prompt_cache_retention = '24h';
@@ -85,7 +85,7 @@ export class OpenAIDirectProvider {
         // cacheKey (prompt_cache_key) only groups the server-side prefix-cache
         // shard — safe to share across sessions, unlike the sessionId poolKey
         // above. buildRequestBody derives it from the base namespace plus a
-        // model/system/tools hash, mirroring the Codex OAuth path while keeping
+        // model/system/tools hash, mirroring the openai-oauth path while keeping
         // public OpenAI's 24h retention below.
         const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai');
         const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;

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

@@ -1,21 +1,30 @@
-import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs';
-import { AnthropicProvider } from './anthropic.mjs';
-import { OpenCodeGoProvider } from './opencode-go.mjs';
-import { GeminiProvider } from './gemini.mjs';
-import { OpenAIOAuthProvider, hasOpenAIOAuthCredentials } from './openai-oauth.mjs';
-import { AnthropicOAuthProvider, hasAnthropicOAuthCredentials } from './anthropic-oauth.mjs';
-import { GrokOAuthProvider, hasGrokOAuthCredentials } from './grok-oauth.mjs';
-import { OpenAIDirectProvider } from './openai-ws.mjs';
+import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
+import {
+    hasAnthropicOAuthCredentials,
+    hasOpenAIOAuthCredentials,
+    hasGrokOAuthCredentials,
+} from './oauth-credential-probes.mjs';
 import { refreshCatalog as refreshMetadataCatalog, warmModelMetadataCatalogs } from './model-catalog.mjs';
-// OpenAI-compat provider names are self-declared by openai-compat.mjs via
+// OpenAI-compat provider names are self-declared by openai-compat-presets.mjs via
 // OPENAI_COMPAT_PRESETS. No parallel list maintained here.
 const providers = new Map();
+const providerCtors = new Map();
+const providerModulePromises = new Map();
 // Parallel map: provider name -> signature of the config it was built from.
 // Lets initProviders() skip reconstructing a provider whose config is byte-for-
 // byte identical to the live one, so lazy-init misses that re-run initProviders
 // don't churn (tear down + rebuild) every live provider instance on every call.
 const signatures = new Map();
 
+// Module-level init serialization. agent-tool.mjs's ensureProvider() already
+// serializes inits per provider on a chain promise, but its gateOnPrior() lets
+// a queued init PROCEED once a 120s gate expires even if the prior init has
+// not settled — so a slow-but-still-running init and a newer one can reach
+// initProviders() concurrently. This chain makes the clear()+rebuild section
+// strictly sequential at the registry level, independent of any caller gating,
+// so two different config signatures can never interleave their rebuilds.
+let _initChain = Promise.resolve();
+
 // Deterministic structural signature of a provider config. Recursively sorts
 // object keys so signature equality reflects config-value equality regardless
 // of key insertion order. Invariant: same config in -> same string out.
@@ -37,7 +46,51 @@ function configSignature(cfg) {
         return null;
     }
 }
+
+async function loadProviderExport(cacheKey, spec, exportName) {
+    if (!providerModulePromises.has(cacheKey)) {
+        providerModulePromises.set(cacheKey, import(spec));
+    }
+    const mod = await providerModulePromises.get(cacheKey);
+    const value = mod?.[exportName];
+    if (typeof value !== 'function') throw new Error(`provider export missing: ${exportName}`);
+    providerCtors.set(cacheKey, value);
+    return value;
+}
+
+async function loadProviderCtor(name) {
+    if (name === 'anthropic') return loadProviderExport('anthropic', './anthropic.mjs', 'AnthropicProvider');
+    if (name === 'gemini') return loadProviderExport('gemini', './gemini.mjs', 'GeminiProvider');
+    if (name === 'openai-oauth') return loadProviderExport('openai-oauth', './openai-oauth.mjs', 'OpenAIOAuthProvider');
+    if (name === 'anthropic-oauth') return loadProviderExport('anthropic-oauth', './anthropic-oauth.mjs', 'AnthropicOAuthProvider');
+    if (name === 'grok-oauth') return loadProviderExport('grok-oauth', './grok-oauth.mjs', 'GrokOAuthProvider');
+    if (name === 'openai') return loadProviderExport('openai', './openai-ws.mjs', 'OpenAIDirectProvider');
+    if (name === 'opencode-go') return loadProviderExport('opencode-go', './opencode-go.mjs', 'OpenCodeGoProvider');
+    if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name)) {
+        return loadProviderExport('openai-compat', './openai-compat.mjs', 'OpenAICompatProvider');
+    }
+    throw new Error(`unknown enabled provider: ${name}`);
+}
+
+function instantiateProvider(name, Ctor, cfg) {
+    if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name) && name !== 'opencode-go') {
+        return new Ctor(name, cfg);
+    }
+    return new Ctor(cfg);
+}
+
 export async function initProviders(config) {
+    // Serialize ALL inits through a single chain so two different config
+    // signatures can never run their clear()+rebuild concurrently, regardless
+    // of caller-side gating (agent-tool gateOnPrior may release a queued init
+    // before the prior one settled). Errors do not poison the chain.
+    const run = () => _initProvidersUnsynchronized(config);
+    const next = _initChain.then(run, run);
+    _initChain = next.then(() => {}, () => {});
+    return next;
+}
+
+async function _initProvidersUnsynchronized(config) {
     // Invariant: never wipe the live registry based on an empty / all-disabled
     // config. Without this guard, a stale `loadAgentConfig()` (e.g. mid-reload
     // or a transient FS hiccup) would land here as `{}` or `{...,enabled:false}`,
@@ -51,54 +104,30 @@ export async function initProviders(config) {
     }
     const next = new Map();
     const nextSignatures = new Map();
-    for (const [name, cfg] of entries) {
-        if (!cfg.enabled)
-            continue;
+    const enabledResults = await Promise.all(entries.map(async ([name, cfg]) => {
+        if (!cfg.enabled) return null;
         // Idempotent reuse: an enabled provider whose config signature is
         // unchanged from the live registry is carried forward as-is. Only
         // added or changed providers are (re)constructed below.
         const sig = configSignature(cfg);
         if (sig !== null && providers.has(name) && signatures.get(name) === sig) {
-            next.set(name, providers.get(name));
-            nextSignatures.set(name, sig);
-            continue;
+            return { name, inst: providers.get(name), sig };
         }
         try {
-            let inst;
-            if (name === 'anthropic') {
-                inst = new AnthropicProvider(cfg);
-            }
-            else if (name === 'gemini') {
-                inst = new GeminiProvider(cfg);
-            }
-            else if (name === 'openai-oauth') {
-                inst = new OpenAIOAuthProvider(cfg);
-            }
-            else if (name === 'anthropic-oauth') {
-                inst = new AnthropicOAuthProvider(cfg);
-            }
-            else if (name === 'grok-oauth') {
-                inst = new GrokOAuthProvider(cfg);
-            }
-            else if (name === 'openai') {
-                inst = new OpenAIDirectProvider(cfg);
-            }
-            else if (name === 'opencode-go') {
-                inst = new OpenCodeGoProvider(cfg);
-            }
-            else if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name)) {
-                inst = new OpenAICompatProvider(name, cfg);
-            }
-            else {
-                throw new Error(`unknown enabled provider: ${name}`);
-            }
-            next.set(name, inst);
-            if (sig !== null) nextSignatures.set(name, sig);
+            const Ctor = await loadProviderCtor(name);
+            const inst = instantiateProvider(name, Ctor, cfg);
+            return { name, inst, sig };
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`[provider] Failed to init "${name}": ${msg}`);
+            return { name, error: new Error(`[provider] Failed to init "${name}": ${msg}`) };
         }
+    }));
+    for (const result of enabledResults) {
+        if (!result) continue;
+        if (result.error) throw result.error;
+        next.set(result.name, result.inst);
+        if (result.sig !== null) nextSignatures.set(result.name, result.sig);
     }
     // Second guard: every entry was disabled. Same reasoning — keep the
     // existing registry rather than going dark.
@@ -136,19 +165,27 @@ export function getProvider(name) {
     // failure) — initProviders then skipped the entry entirely so there is
     // nothing for the preservation guard to carry forward. Re-probe the
     // credential each miss: if the credential is now valid, register the
-    // instance on the spot so subsequent calls hit the cached entry.
+    // instance on the spot when that provider module has already been loaded,
+    // so subsequent calls hit the cached entry without making registry import
+    // pay every provider runtime at boot.
     if (name === 'anthropic-oauth' && hasAnthropicOAuthCredentials()) {
-        const inst = new AnthropicOAuthProvider({});
+        const Ctor = providerCtors.get('anthropic-oauth');
+        if (!Ctor) return undefined;
+        const inst = new Ctor({});
         providers.set(name, inst);
         return inst;
     }
     if (name === 'openai-oauth' && hasOpenAIOAuthCredentials()) {
-        const inst = new OpenAIOAuthProvider({});
+        const Ctor = providerCtors.get('openai-oauth');
+        if (!Ctor) return undefined;
+        const inst = new Ctor({});
         providers.set(name, inst);
         return inst;
     }
     if (name === 'grok-oauth' && hasGrokOAuthCredentials()) {
-        const inst = new GrokOAuthProvider({});
+        const Ctor = providerCtors.get('grok-oauth');
+        if (!Ctor) return undefined;
+        const inst = new Ctor({});
         providers.set(name, inst);
         return inst;
     }
@@ -173,7 +210,7 @@ export function getAllProviders() {
 }
 // Background catalog warm-up. Each provider's listModels() either hits its
 // own cached model list (no-op) or fires a single HTTP refresh. Called from
-// agent.init() after providers are registered so the first bridge LLM call
+// agent.init() after providers are registered so the first agent dispatch call
 // (e.g. cycle1 on session start) does not pay the catalog refresh latency
 // inline. Fire-and-forget: failures are logged inside each provider.
 export function warmupCatalogs() {

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -27,10 +27,10 @@ import {
 
 // HTTP statuses considered transient — safe to retry with backoff.
 //   408 — request timeout
-//   429 — rate limit (caller may still respect Retry-After, but the kind
-//         classification here only signals "retryable"; sub-error in the
-//         provider can still treat 429 as permanent for quota-exhausted)
 //   500/502/503/504 — server errors (overload / bad gateway / timeout)
+//   429 is deliberately excluded: rate-limit/quota windows are deterministic
+//   for the current call and must surface immediately instead of sleeping until
+//   an outer watchdog reports a misleading timeout.
 const TRANSIENT_STATUSES = new Set([408, 500, 502, 503, 504])
 
 // HTTP statuses that mean "permanent: stop retrying, surface to caller".
@@ -44,7 +44,7 @@ const PERMANENT_STATUSES = new Set([400, 404, 405, 410, 415, 422])
 // payload but no explicit status code — we sniff the text and assign the most
 // likely HTTP equivalent so the retry layer can use the same rules.
 const MESSAGE_PATTERNS = [
-  // OpenAI/Codex sometimes surfaces generic backend failures only as
+  // OpenAI OAuth/API sometimes surfaces generic backend failures only as
   // message text plus a request ID, with no HTTP status on the WS event.
   { regex: /(?:an error occurred while processing your request|please include the request id)/i, status: 503 },
   // Overload / transient 5xx — server is asking us to back off. The `\b`
@@ -58,7 +58,7 @@ const MESSAGE_PATTERNS = [
   // by classifyError because per-call retry won't change the answer (the
   // window must elapse). Providers that want time-bounded retry should
   // honor Retry-After on the original response, not loop here.
-  { regex: /(?:rate ?limit|quota)/i, status: 429 },
+  { regex: /(?:rate[_ -]?limit|quota|too many requests|resource exhausted|insufficient_quota|quota_exceeded)/i, status: 429 },
   // Auth — never retryable from our side.
   { regex: /\b(?:unauthorized|unauthorised|authentication|not authenticated|token expired|access token|invalid api key)\b/i, status: 401 },
   { regex: /\b(?:forbidden|permission denied|policy violation)\b/i, status: 403 },
@@ -212,6 +212,13 @@ export function isRetryable(err) {
 const DEFAULT_BACKOFF_MS = PROVIDER_RETRY_BACKOFF_MS
 const DEFAULT_MAX_ATTEMPTS = PROVIDER_RETRY_MAX_ATTEMPTS
 
+export const MIDSTREAM_BACKOFF_MS = [250, 1000, 2000, 4000]
+
+export function midstreamBackoffFor(retryNumber, schedule = MIDSTREAM_BACKOFF_MS) {
+  const raw = schedule[Math.min(Math.max(retryNumber, 1), schedule.length) - 1]
+  return jitterDelayMs(raw)
+}
+
 export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 'symmetric') {
   const base = Number(ms) || 0
   if (base <= 0) return 0
@@ -296,13 +303,17 @@ export async function withRetry(fn, opts = {}) {
       }
       lastErr = caught
       populateHttpStatusFromMessage(caught)
-      const retryAfterMs = retryAfterMsFromError(caught)
       const status = Number(caught?.httpStatus || caught?.status || caught?.response?.status || 0)
       const kind = classifyError(caught)
-      const retryableRateLimit = status === 429 && retryAfterMs != null
-      if (kind !== 'transient' && !retryableRateLimit) throw caught
+      const unsafeToRetry = caught?.unsafeToRetry === true
+        || caught?.providerQuota === true
+        || caught?.quotaExceeded === true
+      if (unsafeToRetry) throw caught
+      if (status === 429) throw caught
+      if (kind !== 'transient') throw caught
       // Last attempt failed transiently — propagate to caller.
       if (attempt === maxAttempts - 1) throw caught
+      const retryAfterMs = retryAfterMsFromError(caught)
       if (retryAfterMs != null) {
         nextDelayMs = Math.max(0, Math.min(retryAfterMs, maxRetryAfterMs))
         nextDelayReason = 'retry-after'
@@ -316,7 +327,7 @@ export async function withRetry(fn, opts = {}) {
 }
 
 function _sleepWithAbort(ms, signal) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     let onAbort = null
     const t = setTimeout(() => {
       if (signal && onAbort) {
@@ -325,8 +336,17 @@ function _sleepWithAbort(ms, signal) {
       resolve()
     }, ms)
     if (!signal) return
-    if (signal.aborted) { clearTimeout(t); resolve(); return }
-    onAbort = () => { clearTimeout(t); resolve() }
+    if (signal.aborted) {
+      clearTimeout(t)
+      const reason = signal.reason
+      reject(reason instanceof Error ? reason : new Error('sleep aborted'))
+      return
+    }
+    onAbort = () => {
+      clearTimeout(t)
+      const reason = signal.reason
+      reject(reason instanceof Error ? reason : new Error('sleep aborted'))
+    }
     signal.addEventListener('abort', onAbort, { once: true })
   })
 }

package/src/runtime/agent/orchestrator/providers/statusline-route-meta.mjs

@@ -1,11 +1,44 @@
-let routeMeta;
+let routeMeta = null;
+let routeMetaPromise = null;
 
-try {
-  routeMeta = await import('../../../../vendor/statusline/src/gateway/route-meta.mjs');
-} catch {
-  routeMeta = await import('../../../gateway/route-meta.mjs');
+async function loadRouteMetaModule() {
+  if (routeMeta) return routeMeta;
+  if (!routeMetaPromise) {
+    routeMetaPromise = import('../../../../vendor/statusline/src/gateway/route-meta.mjs').then((mod) => {
+      routeMeta = mod;
+      return mod;
+    });
+  }
+  try {
+    return await routeMetaPromise;
+  } catch (err) {
+    routeMetaPromise = null;
+    routeMeta = null;
+    throw err;
+  }
 }
 
-export const buildGatewayLimits = routeMeta.buildGatewayLimits;
-export const recordGatewayUsageEvent = routeMeta.recordGatewayUsageEvent;
-export const summarizeGatewayUsage = routeMeta.summarizeGatewayUsage;
+/** Await before calling the sync exports when route-meta may not be ready yet. */
+export async function ensureStatuslineRouteMetaLoaded() {
+  return loadRouteMetaModule();
+}
+
+function requireRouteMeta() {
+  if (!routeMeta) {
+    void loadRouteMetaModule().catch(() => {});
+    throw new Error('statusline route-meta not loaded');
+  }
+  return routeMeta;
+}
+
+export function buildGatewayLimits(routeInfo, providerOut = null, usageSnapshot = null) {
+  return requireRouteMeta().buildGatewayLimits(routeInfo, providerOut, usageSnapshot);
+}
+
+export function recordGatewayUsageEvent(summary) {
+  return requireRouteMeta().recordGatewayUsageEvent(summary);
+}
+
+export function summarizeGatewayUsage(routeInfo, providerOut, compact = null, durationMs = null) {
+  return requireRouteMeta().summarizeGatewayUsage(routeInfo, providerOut, compact, durationMs);
+}

package/src/runtime/agent/orchestrator/session/cache/post-edit-marks.mjs

@@ -1,12 +1,12 @@
-// Post-edit advisory marks: one-shot sidecar on the next read after a write.
+// Post-patch advisory marks: one-shot sidecar on the next read after a patch.
 import { _normalizeAbs } from './util.mjs';
 
 // sessionId -> Map<absPath, { ts, toolName }>
 const _postEditBySession = new Map();
 
 /**
- * Mark `path` as just-edited for `sessionId`. Caller invokes this after a
- * successful write/edit/apply_patch so the next read on the same path can
+ * Mark `path` as just-patched for `sessionId`. Caller invokes this after a
+ * successful apply_patch so the next read on the same path can
  * receive a one-shot advisory sidecar.
  */
 export function markPostEdit({ sessionId, path, cwd, toolName }) {
@@ -15,7 +15,7 @@ export function markPostEdit({ sessionId, path, cwd, toolName }) {
     if (!abs) return;
     let m = _postEditBySession.get(sessionId);
     if (!m) { m = new Map(); _postEditBySession.set(sessionId, m); }
-    m.set(abs, { ts: Date.now(), toolName: String(toolName || 'edit') });
+    m.set(abs, { ts: Date.now(), toolName: String(toolName || 'apply_patch') });
 }
 
 /**

package/src/runtime/agent/orchestrator/session/cache/read-cache.mjs

@@ -222,7 +222,7 @@ export function setReadCached({ sessionId, args, cwd, content, toolUseId }) {
 
 /**
  * Invalidate all cache entries for `path` in the given session. Called when
- * a write-class tool (write/edit/apply_patch) touches the path.
+ * a mutation tool (apply_patch) touches the path.
  */
 export function invalidatePathForSession(sessionId, path, cwd) {
     if (!sessionId) return;