mixdog 0.9.2 → 0.9.4

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

@@ -6,6 +6,7 @@ import { join } from 'path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { num, round, cleanString } from './lib/usage-primitives.mjs';
 
 const CACHE_FILE = 'gateway-oauth-usage-cache.json';
 const LIVE_CACHE_TTL_MS = 60_000;
@@ -21,24 +22,6 @@ const lastWarnAt = new Map();
 let pendingDiskSnapshots = new Map();
 let pendingDiskFlushTimer = null;
 
-function num(value, fallback = null) {
-  if (value === null || value === undefined || value === '') return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function round(value, digits = 4) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return null;
-  const scale = 10 ** digits;
-  return Math.round(n * scale) / scale;
-}
-
-function cleanString(value) {
-  const s = typeof value === 'string' ? value.trim() : '';
-  return s || null;
-}
-
 function providerKey(routeInfo = {}) {
   return String(routeInfo?.provider || '').toLowerCase();
 }
@@ -301,7 +284,7 @@ function balanceFromCredits(credits, source) {
 }
 
 function balanceFromExtraUsage(extra) {
-  if (!extra || typeof extra !== 'object' || extra.is_enabled !== true) return null;
+  if (!extra || typeof extra !== 'object') return null;
   const limit = num(extra.monthly_limit, null);
   const used = num(extra.used_credits, 0);
   if (limit === null) return null;
@@ -315,6 +298,57 @@ function balanceFromExtraUsage(extra) {
   };
 }
 
+function balanceFromAnthropicSpend(spend) {
+  if (!spend || typeof spend !== 'object') return null;
+  const currency = cleanString(spend.used?.currency ?? spend.limit?.currency) || 'USD';
+  // spend.balance may be a plain number or a {amount_minor, exponent} money
+  // object like used/limit; support both shapes.
+  const directBalance = spend.balance && typeof spend.balance === 'object'
+    ? (() => {
+      const minor = num(spend.balance.amount_minor, null);
+      return minor === null ? null : minor / (10 ** num(spend.balance.exponent, 2));
+    })()
+    : num(spend.balance, null);
+  if (directBalance !== null) {
+    return {
+      source: 'anthropic-oauth-spend',
+      remainingUsd: round(directBalance, 4),
+      spentUsd: round(num(spend.used?.amount_minor, 0) / (10 ** num(spend.used?.exponent, 2)), 4),
+      currency,
+    };
+  }
+
+  const usedMinor = num(spend.used?.amount_minor, null);
+  const usedExponent = num(spend.used?.exponent, 2);
+  const usedUsd = usedMinor === null ? null : usedMinor / (10 ** usedExponent);
+
+  const capMinor = num(spend.cap?.credits?.amount_minor, null);
+  if (capMinor !== null && usedUsd !== null) {
+    const capExponent = num(spend.cap?.credits?.exponent, 2);
+    const capUsd = capMinor / (10 ** capExponent);
+    return {
+      source: 'anthropic-oauth-spend',
+      remainingUsd: round(Math.max(0, capUsd - usedUsd), 4),
+      spentUsd: round(usedUsd, 4),
+      currency,
+    };
+  }
+
+  const limitMinor = num(spend.limit?.amount_minor, null);
+  if (limitMinor !== null && limitMinor > 0 && usedUsd !== null) {
+    const limitExponent = num(spend.limit?.exponent, 2);
+    const limitUsd = limitMinor / (10 ** limitExponent);
+    return {
+      source: 'anthropic-oauth-spend',
+      remainingUsd: round(Math.max(0, limitUsd - usedUsd), 4),
+      spentUsd: round(usedUsd, 4),
+      currency,
+    };
+  }
+
+  return null;
+}
+
 function normalizeOpenAIWhamUsage(data) {
   const rate = data?.rate_limit && typeof data.rate_limit === 'object' ? data.rate_limit : null;
   if (!rate) return null;
@@ -388,7 +422,7 @@ function normalizeAnthropicUsage(data, source = 'anthropic-oauth') {
     provider: 'anthropic-oauth',
     source,
     quotaWindows: windows,
-    balance: balanceFromExtraUsage(data.extra_usage),
+    balance: balanceFromAnthropicSpend(data.spend) || balanceFromExtraUsage(data.extra_usage),
     rawKeys: Object.keys(data || {}).sort(),
   };
 }

package/src/runtime/agent/orchestrator/providers/openai-codex-model.mjs

@@ -0,0 +1,108 @@
+/**
+ * OpenAI Codex OAuth model-catalog transforms.
+ *
+ * Extracted from openai-oauth.mjs: pure catalog helpers — API-shape
+ * normalization, family classification, version comparison, and the
+ * per-family "latest" pass. No module state; openai-oauth.mjs re-exports
+ * _displayCodexModel for existing importers.
+ */
+
+// OAuth catalog returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
+// -YYYY-MM-DD to get the version alias (gpt-5.4-mini). Unknown shapes pass
+// through unchanged.
+export function _displayCodexModel(id) {
+    if (!id || typeof id !== 'string') return id;
+    return id.replace(/-\d{4}-\d{2}-\d{2}$/, '');
+}
+
+function _positiveCodexContextWindow(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+function _codexContextWindowFromApi(m) {
+    return _positiveCodexContextWindow(m?.context_window)
+        || _positiveCodexContextWindow(m?.max_context_window)
+        || null;
+}
+
+export function _codexFamily(id) {
+    const s = String(id || '').toLowerCase();
+    if (s.includes('nano')) return 'gpt-nano';
+    if (s.includes('mini')) return 'gpt-mini';
+    if (s.includes('codex')) return 'gpt-codex';
+    if (s.startsWith('gpt-5.5')) return 'gpt-5.5';
+    if (s.startsWith('gpt-5.4')) return 'gpt-5.4';
+    if (s.startsWith('gpt-5.2')) return 'gpt-5.2';
+    if (s.startsWith('gpt-5')) return 'gpt-5';
+    return 'gpt';
+}
+
+export function _normalizeCodexModel(m) {
+    const id = m?.slug || m?.id;
+    const family = _codexFamily(id);
+    const serviceTiers = Array.isArray(m?.service_tiers)
+        ? m.service_tiers
+            .map(t => ({
+                id: String(t?.id || '').trim(),
+                name: String(t?.name || '').trim(),
+                description: String(t?.description || '').trim(),
+            }))
+            .filter(t => t.id)
+        : [];
+    const additionalSpeedTiers = Array.isArray(m?.additional_speed_tiers)
+        ? m.additional_speed_tiers.map(t => String(t || '').trim()).filter(Boolean)
+        : [];
+    // Catalog ids are version aliases without separate display dating.
+    return {
+        id,
+        name: m?.display_name || id,
+        display: m?.display_name || id,
+        family,
+        provider: 'openai-oauth',
+        contextWindow: _codexContextWindowFromApi(m),
+        maxContextWindow: _positiveCodexContextWindow(m?.max_context_window),
+        outputTokens: m?.max_output_tokens || m?.output_tokens || 32768,
+        autoCompactTokenLimit: m?.auto_compact_token_limit || null,
+        effectiveContextWindowPercent: m?.effective_context_window_percent || null,
+        tier: 'version',
+        latest: false,
+        description: m?.description || '',
+        reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
+        serviceTiers,
+        defaultServiceTier: m?.default_service_tier || null,
+        additionalSpeedTiers,
+    };
+}
+
+// Compare two model ids by the X.Y version embedded in `gpt-X.Y`. Mirrors
+// anthropic-oauth's _compareVersion; these ids have no trailing date so
+// the version lives in the dotted number, not a -YYYY-MM-DD suffix.
+export function _compareVersion(a, b) {
+    const na = (String(a).match(/gpt-(\d+)\.(\d+)/) || []).slice(1).map(Number);
+    const nb = (String(b).match(/gpt-(\d+)\.(\d+)/) || []).slice(1).map(Number);
+    for (let i = 0; i < Math.max(na.length, nb.length); i++) {
+        if ((na[i] || 0) !== (nb[i] || 0)) return (na[i] || 0) - (nb[i] || 0);
+    }
+    return String(a).localeCompare(String(b));
+}
+
+// Main gpt-5 chat family only: exclude the mini/nano/codex variants so "latest"
+// resolves to the flagship, not a smaller sibling.
+export function _isMainCodexFamily(family) {
+    return typeof family === 'string' && family.startsWith('gpt-5');
+}
+
+// Mark the highest-version model per family as `latest: true`. VERSION-based
+// (ids carry no `created`), mirroring anthropic-oauth's per-family pass.
+export function _markLatestCodex(models) {
+    const byFamily = new Map();
+    for (const m of models) {
+        if (!m?.id) continue;
+        const cur = byFamily.get(m.family);
+        if (!cur || _compareVersion(m.id, cur.id) > 0) {
+            byFamily.set(m.family, m);
+        }
+    }
+    for (const m of byFamily.values()) m.latest = true;
+}

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

@@ -31,8 +31,7 @@ function truncatedCompatStreamError(label, detail) {
     );
 }
 
-// Invalid-tool-args marker. Native-provider convergence (openai-oauth /
-// opencode): completed-but-malformed tool_call arguments JSON must NOT throw
+// Invalid-tool-args marker: completed-but-malformed tool_call arguments JSON must NOT throw
 // (kills the turn) NOR be silently swallowed to `{}`. Instead the parse
 // failure is carried as data on the tool call's `arguments` slot so the
 // dispatch loop can turn it into an is_error tool_result and let the model
@@ -49,8 +48,7 @@ export function isInvalidToolArgsMarker(value) {
     return !!value && typeof value === 'object' && value.__invalidToolArgs === true;
 }
 /** Model-facing tool_result text for a tool call whose arguments failed to
- * parse. Mirrors opencode `The arguments provided to the tool are invalid` and
- * `failed to parse function arguments` — instructs an in-turn retry. */
+ * parse; instructs the model to retry with valid JSON in the same turn. */
 export function formatInvalidToolArgsResult(call) {
     const name = call?.name || 'tool';
     const detail = call?.arguments?.__parseError || 'arguments were not valid JSON';
@@ -85,9 +83,9 @@ export function parseCompletedToolCallArgumentsJson(raw, label, meta) {
         // Invariant: a completion/finish signal was observed for this tool call
         // (finish_reason present, or a per-call/response "done" event fired), so
         // the arguments are NOT mid-stream-truncated — they are complete but
-        // malformed. Native convergence: return an invalid-args MARKER (not a
-        // throw) so the dispatch loop feeds the parse error back to the model as
-        // a tool_result and the model self-corrects in the same turn. Only an
+        // malformed. Return an invalid-args MARKER (not a throw) so the
+        // dispatch loop feeds the parse error back to the model as a
+        // tool_result and the model self-corrects in the same turn. Only an
         // unfinished stream (no finishReason) stays the retryable truncation
         // case — that transient behavior is deliberately preserved.
         if (meta?.finishReason) {
@@ -406,7 +404,7 @@ export async function consumeCompatChatCompletionStream(stream, { signal, label,
     } catch (err) {
         // Any mid-stream failure after live text was relayed is non-retryable.
         if (emittedText) throw markErrorLiveTextEmitted(err);
-        // Partial-final recovery parity: on a mid-stream stall, attach the
+        // Partial-final recovery: on a mid-stream stall, attach the
         // streamed partial state so the loop can accept a wedged FINAL no-tool
         // summary as partial-final success. pendingToolUse gates out any
         // in-flight/emitted tool call.
@@ -488,12 +486,15 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         if (!item || item.type !== 'tool_search_call') return;
         const callId = item.call_id || item.id || '';
         if (!callId || state.toolCalls.some((call) => call.id === callId)) return;
+        const _tsArgs = item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
+            ? item.arguments
+            : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, { id: callId, name: 'tool_search', finishReason: 'done' });
         const call = {
             id: callId,
             name: 'tool_search',
-            arguments: item.arguments && typeof item.arguments === 'object'
-                ? item.arguments
-                : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, { id: callId, name: 'tool_search', finishReason: 'done' }),
+            // Schema is a plain object ({query,select,limit}); an array must
+            // never pass through as args.
+            arguments: (_tsArgs && typeof _tsArgs === 'object' && !Array.isArray(_tsArgs)) ? _tsArgs : {},
             nativeType: 'tool_search_call',
         };
         state.toolCalls.push(call);
@@ -533,6 +534,12 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
                 state.toolInFlight = true;
             } else if (event.item?.type === 'custom_tool_call') {
                 state.toolInFlight = true;
+            } else if (event.item?.type === 'tool_search_call') {
+                // Mark tool_search in-flight at item-added time, same as
+                // function_call/custom_tool_call above, so the stall-recovery
+                // pendingToolUse gate never drops a mid-flight tool_search
+                // before response.output_item.done pushes it.
+                state.toolInFlight = true;
             }
             try { onStreamDelta?.(); } catch {}
             break;
@@ -766,7 +773,7 @@ export async function consumeCompatResponsesStream(stream, {
         }
         flushLeak();
     } catch (err) {
-        // Partial-final recovery parity: attach streamed partial state so a
+        // Partial-final recovery: attach streamed partial state so a
         // wedged FINAL no-tool summary can be accepted as partial-final success.
         if (err?.streamStalled === true) {
             try {

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

@@ -0,0 +1,58 @@
+/**
+ * openai-compat-trace.mjs — shared trace/token helpers for the OpenAI-compat
+ * provider family.
+ *
+ * Extracted from openai-compat.mjs. Holds the two low-level helpers
+ * (summarizeTraceMessages, extractCompatCachedTokens) consumed by both
+ * openai-compat.mjs and openai-compat-xai.mjs cache-trace writers. Isolating
+ * them here breaks the former import cycle between those two modules.
+ */
+import { traceHash, stableTraceStringify, traceTextShape } from './trace-utils.mjs';
+
+export function summarizeTraceMessages(messages) {
+    const summaries = (messages || []).map((m, index) => {
+        const content = typeof m?.content === 'string'
+            ? { type: 'text', ...traceTextShape(m.content) }
+            : { type: m?.content == null ? 'null' : typeof m.content, hash: traceHash(stableTraceStringify(m?.content ?? null)) };
+        const toolCalls = Array.isArray(m?.tool_calls)
+            ? m.tool_calls.map(tc => ({
+                name: tc?.function?.name || null,
+                argsHash: traceHash(tc?.function?.arguments || ''),
+            }))
+            : [];
+        return {
+            index,
+            role: m?.role || null,
+            content,
+            ...(typeof m?.reasoning_content === 'string'
+                ? { reasoningContent: traceTextShape(m.reasoning_content) }
+                : {}),
+            toolCallCount: toolCalls.length,
+            ...(toolCalls.length ? { toolCalls } : {}),
+        };
+    });
+    if (summaries.length <= 12) return summaries;
+    return [
+        ...summaries.slice(0, 8),
+        { omittedTurns: summaries.length - 12 },
+        ...summaries.slice(-4),
+    ];
+}
+
+export function extractCompatCachedTokens(usage) {
+    const candidates = [
+        usage?.prompt_tokens_details?.cached_tokens,
+        usage?.input_tokens_details?.cached_tokens,
+        usage?.prompt_cache_hit_tokens,
+        usage?.cached_prompt_text_tokens,
+    ];
+    for (const v of candidates) {
+        const n = Number(v);
+        if (Number.isFinite(n) && n > 0) return n;
+    }
+    for (const v of candidates) {
+        const n = Number(v);
+        if (Number.isFinite(n)) return n;
+    }
+    return 0;
+}