mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/providers/model-pricing-rates.mjs

@@ -1,71 +1 @@
-// Source formats are normalized to USD per million tokens before merging.
-export const PRICING_RATE_KEYS = Object.freeze([
-  'inputCostPerM',
-  'outputCostPerM',
-  'cacheReadCostPerM',
-  'cacheWriteCostPerM',
-]);
-const LITELLM_KEYS = [
-  'input_cost_per_token',
-  'output_cost_per_token',
-  'cache_read_input_token_cost',
-  'cache_creation_input_token_cost',
-];
-const MODELSDEV_KEYS = ['input', 'output', 'cache_read', 'cache_write'];
-const validRate = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-
-function rates(source, keys, multiplier) {
-  return Object.fromEntries(
-    PRICING_RATE_KEYS.map((key, i) => [key, validRate(source?.[keys[i]]) ? source[keys[i]] * multiplier : null])
-  );
-}
-
-export function litellmPricing(entry) {
-  const thresholds = new Set();
-  for (const key of Object.keys(entry || {})) {
-    for (const prefix of LITELLM_KEYS) {
-      if (!key.startsWith(`${prefix}_above_`)) continue;
-      const match = key.slice(prefix.length).match(/^_above_(\d+)k_tokens$/);
-      if (match) thresholds.add(Number(match[1]) * 1000);
-    }
-  }
-  return {
-    ...rates(entry, LITELLM_KEYS, 1_000_000),
-    pricingTiers: [...thresholds]
-      .sort((a, b) => a - b)
-      .map((aboveInputTokens) => ({
-        aboveInputTokens,
-        ...rates(
-          entry,
-          LITELLM_KEYS.map((key) => `${key}_above_${aboveInputTokens / 1000}k_tokens`),
-          1_000_000
-        ),
-      })),
-  };
-}
-
-export function modelsDevPricing(cost) {
-  // Structured tiers supersede the older context_over_200k compatibility
-  // field; it can coexist with a tier whose actual boundary is not 200k.
-  let tiers = [];
-  if (Array.isArray(cost?.tiers)) {
-    tiers = cost.tiers
-      .filter((row) => row?.tier?.type === 'context' && Number.isFinite(row.tier.size) && row.tier.size > 0)
-      .map((row) => ({ aboveInputTokens: row.tier.size, ...rates(row, MODELSDEV_KEYS, 1) }));
-  } else if (cost?.context_over_200k) {
-    tiers = [{ aboveInputTokens: 200000, ...rates(cost.context_over_200k, MODELSDEV_KEYS, 1) }];
-  }
-  return {
-    ...rates(cost, MODELSDEV_KEYS, 1),
-    pricingTiers: tiers.sort((a, b) => a.aboveInputTokens - b.aboveInputTokens),
-  };
-}
-
-export function ratesForPrompt(meta, promptTokens) {
-  const result = Object.fromEntries(PRICING_RATE_KEYS.map((key) => [key, meta?.[key] ?? null]));
-  for (const tier of meta?.pricingTiers || []) {
-    if (promptTokens <= tier.aboveInputTokens) continue;
-    for (const key of PRICING_RATE_KEYS) if (tier[key] != null) result[key] = tier[key];
-  }
-  return result;
-}
+export * from '../../../shared/llm/model-pricing-rates.mjs';

package/src/runtime/agent/orchestrator/providers/npm-cli-version.mjs

@@ -0,0 +1,87 @@
+// Live "latest published CLI version" lookup from the npm registry, shared by
+// providers that must present a current CLI client version to a version gate.
+// Sync accessor never blocks (kicks a background refresh); warm() is the
+// awaitable cold-start path. Failures resolve to null so callers fall back to
+// their floor. MIXDOG_DISABLE_LIVE_CLI_VERSIONS=1 turns the lookup off.
+
+const SEMVER = /^\d+\.\d+\.\d+$/;
+const DEFAULT_TTL_MS = 24 * 60 * 60_000;
+const FAILURE_TTL_MS = 10 * 60_000;
+const TIMEOUT_MS = 4_000;
+
+export function compareSemver(a, b) {
+  const pa = String(a).split('.').map(Number);
+  const pb = String(b).split('.').map(Number);
+  for (let i = 0; i < 3; i += 1) {
+    if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  }
+  return 0;
+}
+
+/** Highest valid x.y.z among the candidates (invalid/empty ignored). */
+export function maxSemver(...candidates) {
+  let best = null;
+  for (const c of candidates) {
+    const v = String(c ?? '').trim();
+    if (SEMVER.test(v) && (!best || compareSemver(v, best) > 0)) best = v;
+  }
+  return best;
+}
+
+export function createNpmVersionSource(pkg, options) {
+  return createRemoteVersionSource(
+    `https://registry.npmjs.org/${pkg}/latest`,
+    async (res) => {
+      const v = String((await res.json())?.version || '').trim();
+      return SEMVER.test(v) ? v : null;
+    },
+    options
+  );
+}
+
+/**
+ * Generic source: GET `url`, `parse(res)` returns the version string or null
+ * (unrecognised format). Same TTL/in-flight/timeout/disable rules as npm.
+ */
+export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS, timeoutMs = TIMEOUT_MS } = {}) {
+  let value = null;
+  let expiresAt = 0;
+  let inFlight = null;
+
+  async function refresh() {
+    let next = null;
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+      if (res.ok) next = (await parse(res)) || null;
+    } catch {
+      /* offline or slow — keep previous/floor */
+    }
+    if (next) value = next;
+    expiresAt = Date.now() + (next ? ttlMs : FAILURE_TTL_MS);
+    return value;
+  }
+
+  function ensureRefresh() {
+    if (process.env.MIXDOG_DISABLE_LIVE_CLI_VERSIONS === '1') return Promise.resolve(value);
+    if (!inFlight) {
+      inFlight = refresh().finally(() => {
+        inFlight = null;
+      });
+    }
+    return inFlight;
+  }
+
+  const fresh = () => Date.now() < expiresAt;
+
+  return {
+    /** Cached live version or null; refreshes in the background when stale. */
+    sync() {
+      if (!fresh()) ensureRefresh();
+      return value;
+    },
+    /** Awaitable, never rejects; bounded by the fetch timeout. */
+    warm() {
+      return fresh() ? Promise.resolve(value) : ensureRefresh();
+    },
+  };
+}

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

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { grokClientVersionHeaders, warmGrokCliVersion } from './grok-client-version.mjs';
 import { num, round, cleanString } from './lib/usage-primitives.mjs';
 import { recordQuotaReadings } from './lib/quota-readings.mjs';
 import { currentProviderAccountId } from '../../../shared/provider-auth-binding.mjs';
@@ -281,7 +282,7 @@ function codexHeaders(auth, beta = 'codex-1') {
 
 function normalizedResetCreditRows(value) {
   return (Array.isArray(value) ? value : []).map((credit) => ({
-    status: cleanString(credit?.status).toLowerCase(),
+    status: (cleanString(credit?.status) || '').toLowerCase(),
     expiresAt: resetAtMs(credit?.expires_at ?? credit?.expiresAt),
     grantedAt: resetAtMs(credit?.granted_at ?? credit?.grantedAt),
   }));
@@ -838,10 +839,8 @@ async function fetchGrokUsage(providerObj, routeInfo) {
   const token = auth?.access_token || auth?.accessToken || auth?.key;
   if (!token) return null;
   const userId = auth?.user_id || auth?.userId || auth?.principal_id || auth?.principalId || '';
-  const cliHeaders = grokProxyHeaders(token, userId, {
-    'x-grok-client-version': '0.2.87',
-    'User-Agent': 'xai-grok-build/0.2.87',
-  });
+  await warmGrokCliVersion();
+  const cliHeaders = grokProxyHeaders(token, userId, grokClientVersionHeaders());
   const billing = await probeGrokBilling(cliHeaders, routeInfo);
   if (billing) return billing;
   return probeGrokGenericUsage(grokProxyHeaders(token, userId, { 'User-Agent': 'xai-grok-build/mixdog' }), routeInfo);

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

@@ -95,7 +95,7 @@ function _codexInstallationId(sendOpts) {
 // The identity block is rebuilt per request: never cached on the pooled
 // socket, or a later turn would
 // replay the first turn's identity.
-function _codexMetadataBase(_entry, { poolKey, cacheKey, sendOpts, handshake = false } = {}) {
+function _codexMetadataBase({ poolKey, cacheKey, sendOpts, handshake = false } = {}) {
   const rawSessionId =
     cleanString(
       sendOpts?.codexSessionId ||
@@ -113,10 +113,9 @@ function _codexMetadataBase(_entry, { poolKey, cacheKey, sendOpts, handshake = f
         cacheKey ||
         rawSessionId
     ) || rawSessionId;
-  const rawInstallationId = _codexInstallationId(sendOpts);
+  const installationId = _codexInstallationId(sendOpts);
   const sessionId = _codexUuidV7(rawSessionId);
   const threadId = _codexUuidV7(rawThreadId);
-  const installationId = rawInstallationId;
   const startedAt = Number.isFinite(Number(sendOpts?.turnStartedAtUnixMs))
     ? Math.floor(Number(sendOpts.turnStartedAtUnixMs))
     : _sessionStartedAtUnixMs(rawSessionId);
@@ -178,7 +177,7 @@ export function _metadataTrace(metadata) {
 // The WebSocket handshake carries compatibility identity and routing fields.
 // Installation data stays in per-request client_metadata.
 export function _codexWsCompatibilityHeaders(context = {}) {
-  const metadata = _codexMetadataBase(null, context);
+  const metadata = _codexMetadataBase(context);
   const headers = {};
   if (metadata.session_id) headers['session-id'] = metadata.session_id;
   if (metadata.thread_id) {
@@ -207,7 +206,7 @@ export function _codexWsCompatibilityHeaders(context = {}) {
 
 export function _withCodexWsClientMetadata(frame, entry, enabled, context = {}) {
   if (!enabled || !frame || typeof frame !== 'object') return frame;
-  const base = _codexMetadataBase(entry, context);
+  const base = _codexMetadataBase(context);
   const explicitLogicalTurnId = cleanString(
     context?.sendOpts?.turnId || context?.sendOpts?.codexTurnId || context?.sendOpts?.session?.turnId
   );

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

@@ -1,7 +1,7 @@
 import { canFallbackNonStreaming, markProviderRecoveryExhausted, withRetry } from './retry-classifier.mjs';
 import { consumeCompatChatCompletionStream } from './openai-compat-stream.mjs';
 import { getModelMetadataSync } from './model-catalog.mjs';
-import { appendAgentTrace } from '../agent-trace.mjs';
+import { traceNonStreamingFallback } from './lib/transport-fallback-trace.mjs';
 import {
   PROVIDER_FIRST_BYTE_TIMEOUT_MS,
   PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
@@ -186,26 +186,7 @@ export async function recoverCompatNonStreaming(provider, { streamErr, params, o
   } catch {
     /* best-effort */
   }
-  try {
-    appendAgentTrace({
-      sessionId: opts?.sessionId || opts?.session?.id || null,
-      iteration: Number.isFinite(Number(opts?.iteration)) ? Number(opts.iteration) : null,
-      kind: 'transport_fallback',
-      provider: provider.name,
-      model: useModel,
-      transport: 'non-streaming',
-      payload: {
-        from: 'stream',
-        to: 'non-streaming',
-        reason: streamErr?.retryClassifier || streamErr?.code || streamErr?.message || 'stream_failed',
-        error_code: streamErr?.code || null,
-        error_http_status: Number(streamErr?.httpStatus || streamErr?.status || 0) || null,
-        error_classifier: streamErr?.retryClassifier || streamErr?.midstreamClassifier || null,
-      },
-    });
-  } catch {
-    /* best-effort */
-  }
+  traceNonStreamingFallback({ provider: provider.name, model: useModel, opts, streamErr });
   return {
     response,
     model: response.model || useModel,

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

@@ -3,7 +3,7 @@
  * chat-completions stream: the no-event / no-finish_reason rejections, the
  * reconstructed response, tool-call parsing and dispatch, and the result.
  */
-import { dedupeToolCallList } from '../anthropic-leaked-toolcall.mjs';
+import { dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
 import { truncatedCompatStreamError } from '../lib/openai-tool-args.mjs';
 import {
   emitCompatToolCallOnce,

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

@@ -5,13 +5,13 @@
  * rescues tool calls printed as text.
  */
 import { stampStreamOutcome, STREAM_TRANSPORTS } from '../lib/stream-outcome.mjs';
-import { createLeakGuard, createToolCallDedupe } from '../anthropic-leaked-toolcall.mjs';
+import { createLeakGuard, createToolCallDedupe } from '../lib/leaked-toolcall.mjs';
 import { emitCompatToolCallOnce, synthLeakedOpenAICall } from '../openai-compat-stream-common.mjs';
 import { createToolCallAccumulator } from './tool-call-acc.mjs';
 
 export function createCompatStreamState({ knownToolNames, idleMs, onStreamDelta, onToolCall, onTextDelta }) {
   const toolDedupe = createToolCallDedupe();
-  const state = {
+  return {
     idleMs,
     onStreamDelta,
     onToolCall,
@@ -34,7 +34,6 @@ export function createCompatStreamState({ knownToolNames, idleMs, onStreamDelta,
     leakGuard: createLeakGuard({ knownToolNames, harmony: true }),
     leakedCalls: [],
   };
-  return state;
 }
 
 export function reportTransport(state) {

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/tool-call-acc.mjs

@@ -15,8 +15,7 @@ export function mergeToolCallDelta(acc, deltaCalls) {
     } else if (tc.id) {
       key = `id:${tc.id}`;
     } else if (tc.function?.name) {
-      const anonId = ++acc.nextAnonId;
-      key = `anon:${anonId}`;
+      key = `anon:${++acc.nextAnonId}`;
     } else {
       key = acc.lastAnonKey;
       if (!key) continue;

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

@@ -44,14 +44,10 @@ export function applyCompatProviderChatOptions(params, providerName, opts = {},
     const rawThinking = opts.deepseekThinking ?? opts.thinking ?? config?.thinking;
     const rawEffort = opts.deepseekReasoningEffort ?? opts.effort ?? config?.reasoningEffort;
     if (rawThinking !== undefined || rawEffort !== undefined) {
-      const disabled =
-        rawThinking === false ||
-        String(rawThinking?.type ?? rawThinking ?? rawEffort)
-          .trim()
-          .toLowerCase() === 'disabled' ||
-        String(rawThinking?.type ?? rawThinking ?? rawEffort)
-          .trim()
-          .toLowerCase() === 'none';
+      const thinkingMode = String(rawThinking?.type ?? rawThinking ?? rawEffort)
+        .trim()
+        .toLowerCase();
+      const disabled = rawThinking === false || thinkingMode === 'disabled' || thinkingMode === 'none';
       params.thinking = { type: disabled ? 'disabled' : 'enabled' };
       if (!disabled) {
         const effort = String(rawEffort ?? '')

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

@@ -46,6 +46,34 @@ function traceXaiResponses(fields) {
   traceXaiResponsesCacheContext(fields);
 }
 
+/** Record one completed turn's usage; `extra` carries provider-specific trace fields. */
+export function traceCompatResponseUsage({
+  opts,
+  provider,
+  model,
+  response,
+  inputTokens,
+  outputTokens,
+  cachedTokens,
+  ...extra
+}) {
+  traceAgentUsage({
+    sessionId: opts.sessionId || opts.session?.id || null,
+    iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
+    inputTokens,
+    outputTokens,
+    cachedTokens,
+    cacheWriteTokens: 0,
+    promptTokens: inputTokens,
+    model: response.model || model,
+    modelDisplay: response.model || model,
+    responseId: response.id || null,
+    rawUsage: response.usage,
+    provider,
+    ...extra,
+  });
+}
+
 function chatCompletionUsage(providerName, usage) {
   const input = usage.prompt_tokens ?? usage.input_tokens ?? 0;
   return withCostUsd(
@@ -104,7 +132,7 @@ export function normalizeCompatChatResponse({
     (stopReason === 'length' && Array.isArray(toolCalls) && toolCalls.length > 0) ||
     stopReason === 'content_filter'
   ) {
-    const err = Object.assign(new Error(`${providerName} response incomplete: finish_reason=${stopReason}`), {
+    throw Object.assign(new Error(`${providerName} response incomplete: finish_reason=${stopReason}`), {
       name: 'ProviderIncompleteError',
       code: 'PROVIDER_INCOMPLETE',
       providerIncomplete: true,
@@ -115,7 +143,6 @@ export function normalizeCompatChatResponse({
       responseId: response.id || null,
       rawUsage: response.usage || null,
     });
-    throw err;
   }
   writeCompatCacheTrace({
     provider: providerName,
@@ -129,20 +156,14 @@ export function normalizeCompatChatResponse({
   });
   if (response.usage) {
     const inputTokens = Number(response.usage.prompt_tokens ?? response.usage.input_tokens ?? 0);
-    const cachedTokens = extractCompatCachedTokens(response.usage);
-    traceAgentUsage({
-      sessionId: opts.sessionId || opts.session?.id || null,
-      iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
+    traceCompatResponseUsage({
+      opts,
+      provider: providerName,
+      model: useModel,
+      response,
       inputTokens,
       outputTokens: Number(response.usage.completion_tokens ?? response.usage.output_tokens ?? 0),
-      cachedTokens,
-      cacheWriteTokens: 0,
-      promptTokens: inputTokens,
-      model: response.model || useModel,
-      modelDisplay: response.model || useModel,
-      responseId: response.id || null,
-      rawUsage: response.usage,
-      provider: providerName,
+      cachedTokens: extractCompatCachedTokens(response.usage),
     });
   }
   const capturesReasoningContent =
@@ -207,27 +228,20 @@ export function normalizeXaiResponsesHttp({
   });
   if (response.usage) {
     const inputTokens = Number(response.usage.input_tokens ?? response.usage.prompt_tokens ?? 0);
-    const cachedTokens = extractCompatCachedTokens(response.usage);
     const cacheChain = grokCacheChainTraceFields(opts.providerState, previousResponseId, continuationResetReason);
-    traceAgentUsage({
-      sessionId: opts.sessionId || opts.session?.id || null,
-      iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
+    traceCompatResponseUsage({
+      opts,
+      provider: 'xai',
+      model: useModel,
+      response,
       inputTokens,
       outputTokens: Number(response.usage.output_tokens ?? response.usage.completion_tokens ?? 0),
-      cachedTokens,
-      cacheWriteTokens: 0,
-      promptTokens: inputTokens,
-      model: response.model || useModel,
-      modelDisplay: response.model || useModel,
-      responseId: response.id || null,
-      rawUsage: response.usage,
-      provider: 'xai',
+      cachedTokens: extractCompatCachedTokens(response.usage),
       requestPrevResponseId: cacheChain.requestPrevResponseId,
       chainContinuous: cacheChain.chainContinuous,
       continuationResetReason: cacheChain.continuationResetReason,
     });
   }
-  const nextPreviousResponseId = response.id;
   const encryptedReasoningItems = encryptedXaiReasoningItems(response.output);
   const providerReplay = createProviderReplay('xai-responses', response.output);
   const encryptedReasoningHistory = xaiEncryptedReasoningHistory(opts, messages, encryptedReasoningItems);
@@ -248,7 +262,7 @@ export function normalizeXaiResponsesHttp({
       ...(opts.providerState || {}),
       xaiResponses: {
         previousResponseId: null,
-        responseId: nextPreviousResponseId,
+        responseId: response.id,
         store: false,
         encryptedReasoningItems,
         encryptedReasoningHistory,
@@ -279,7 +293,6 @@ export function normalizeXaiResponsesWebSocket({
   cacheLane,
 }) {
   const responseId = result.responseId || previousResponseId || null;
-  const nextPreviousResponseId = responseId;
   const encryptedReasoningItems = encryptedXaiReasoningItems(result.responseItems);
   const providerReplay = createProviderReplay('xai-responses', result.responseItems);
   const encryptedReasoningHistory = xaiEncryptedReasoningHistory(opts, messages, encryptedReasoningItems);
@@ -309,15 +322,15 @@ export function normalizeXaiResponsesWebSocket({
     model: result.model || useModel,
     toolCalls: result.toolCalls,
     stopReason: result.stopReason || null,
-    // P1 audit fix: same truncated signal as the HTTP path (see
-    // _doSendXaiResponses above) for the WebSocket transport.
+    // P1 audit fix: same truncated signal as the HTTP path, for the
+    // WebSocket transport.
     ...(result.stopReason === 'length' && (result.content || '').length > 0 ? { truncated: true } : {}),
     providerReplay,
     providerState: {
       ...(opts.providerState || {}),
       xaiResponses: {
         previousResponseId: null,
-        responseId: nextPreviousResponseId,
+        responseId,
         store: false,
         encryptedReasoningItems,
         encryptedReasoningHistory,

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

@@ -66,7 +66,7 @@ function pushToolSearchCall(state, item, ctx) {
   if (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 =
+  const searchArgs =
     item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
       ? item.arguments
       : parseCompletedToolCallArgumentsJson(item.arguments || '{}', ctx.label, {
@@ -78,7 +78,7 @@ function pushToolSearchCall(state, item, ctx) {
     callId,
     // Schema is a plain object ({query,select,limit}); an array must
     // never pass through as args.
-    _tsArgs && typeof _tsArgs === 'object' && !Array.isArray(_tsArgs) ? _tsArgs : {}
+    searchArgs && typeof searchArgs === 'object' && !Array.isArray(searchArgs) ? searchArgs : {}
   );
   state.toolCalls.push(call);
   emitCompatToolCallOnce(state, call, ctx.onToolCall);

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

@@ -2,7 +2,7 @@
 // tool-call relay over its text, the canonical stream-outcome stamp and the
 // final result assembly.
 import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
-import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
+import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './lib/leaked-toolcall.mjs';
 import { createActiveToolItemTracker } from './tool-stream-state.mjs';
 import { emitCompatToolCallOnce, synthLeakedOpenAICall } from './openai-compat-stream-common.mjs';
 
@@ -27,7 +27,7 @@ export function createResponsesStreamState() {
     completed: false,
     completedResponse: null,
     sawOutput: false,
-    // Fix 2: cross-path name+args dedupe shared by synthetic leaked-call
+    // Cross-path name+args dedupe shared by synthetic leaked-call
     // dispatch and every native emit in this Responses stream.
     _toolDedupe: createToolCallDedupe(),
     // Gateway live-text relay invariant: set once a non-empty text chunk

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

@@ -9,7 +9,6 @@
 import { markProviderRecoveryExhausted, withRetry } from './retry-classifier.mjs';
 import { consumeCompatResponsesStream } from './openai-compat-stream.mjs';
 import { getModelMetadataSync } from './model-catalog.mjs';
-import { traceAgentUsage } from '../agent-trace.mjs';
 import { PROVIDER_FIRST_BYTE_TIMEOUT_MS, createPassthroughSignal } from '../stall-policy.mjs';
 import { extractCompatCachedTokens } from './openai-compat-trace.mjs';
 import {
@@ -28,7 +27,7 @@ import {
   compatResponsesReplayProvider,
   compatStreamRetryReporter,
 } from './compat-request-policy.mjs';
-import { encryptedXaiReasoningItems } from './openai-compat-response-normalization.mjs';
+import { encryptedXaiReasoningItems, traceCompatResponseUsage } from './openai-compat-response-normalization.mjs';
 
 // providerState slot + providerReplay tag. Distinct from the xAI slot so a
 // provider switch never replays foreign encrypted items into this gateway.
@@ -154,19 +153,14 @@ export async function sendCompatResponses(provider, messages, useModel, tools, o
   const outputTokens = Number(usage?.output_tokens ?? usage?.completion_tokens ?? 0);
   const cachedTokens = usage ? extractCompatCachedTokens(usage) : 0;
   if (usage) {
-    traceAgentUsage({
-      sessionId: opts.sessionId || opts.session?.id || null,
-      iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
+    traceCompatResponseUsage({
+      opts,
+      provider: provider.name,
+      model: useModel,
+      response,
       inputTokens,
       outputTokens,
       cachedTokens,
-      cacheWriteTokens: 0,
-      promptTokens: inputTokens,
-      model: response.model || useModel,
-      modelDisplay: response.model || useModel,
-      responseId: response.id || null,
-      rawUsage: usage,
-      provider: provider.name,
       requestPrevResponseId: previousResponseId || null,
       continuationResetReason: continuationResetReason || null,
     });

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

@@ -25,6 +25,7 @@ function markInBandWireError(err) {
   } catch {}
   return err;
 }
+
 export function synthLeakedOpenAICall(recovered) {
   let args = recovered?.arguments;
   if (args === null || typeof args !== 'object' || Array.isArray(args)) args = {};
@@ -91,7 +92,7 @@ export async function nextAsyncWithWatchdog(
   };
   armIdle();
   try {
-    const result = await new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
       idleReject = reject;
       if (signal?.aborted) {
         const reason = signal.reason;
@@ -107,7 +108,6 @@ export async function nextAsyncWithWatchdog(
       }
       iterator.next().then(resolve, reject);
     });
-    return result;
   } catch (err) {
     if (idleTimedOut)
       throw streamStalledError(idleLabel || 'compat SSE', idleMs, { emittedToolCall: didEmitToolCall() });

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

@@ -4,8 +4,8 @@
  *
  * 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.
+ * openai-compat.mjs and openai-compat-xai.mjs cache-trace writers. Keeping
+ * them here avoids an import cycle between those two modules.
  */
 import { traceHash, traceContentShape, traceTextShape } from './trace-utils.mjs';