mixdog 0.9.174 → 1.0.0

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

@@ -55,6 +55,14 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
     const details = metadata?.reasoning_details ?? metadata?.reasoningDetails;
     return Array.isArray(details) && details.length ? details : null;
   };
+  const attachAssistantReasoning = (msg, message) => {
+    if (replaysReasoningContent && typeof message.reasoningContent === 'string') {
+      msg.reasoning_content = message.reasoningContent;
+    }
+    const reasoningDetails = openRouterReasoningDetails(message);
+    if (reasoningDetails) msg.reasoning_details = reasoningDetails;
+    return msg;
+  };
   const flushToolMedia = () => {
     if (!pendingToolMedia.length) return;
     out.push({ role: 'user', content: pendingToolMedia.splice(0) });
@@ -81,27 +89,11 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
           function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
         })),
       };
-      if (replaysReasoningContent && typeof m.reasoningContent === 'string') msg.reasoning_content = m.reasoningContent;
-      const reasoningDetails = openRouterReasoningDetails(m);
-      if (reasoningDetails) msg.reasoning_details = reasoningDetails;
-      out.push(msg);
-      continue;
-    }
-    const reasoningDetails = m.role === 'assistant' ? openRouterReasoningDetails(m) : null;
-    if (
-      m.role === 'assistant' &&
-      ((replaysReasoningContent && typeof m.reasoningContent === 'string') || reasoningDetails)
-    ) {
-      const msg = {
-        role: m.role,
-        content: normalizeContentForOpenAIChat(m.content, { role: 'assistant' }),
-      };
-      if (replaysReasoningContent && typeof m.reasoningContent === 'string') msg.reasoning_content = m.reasoningContent;
-      if (reasoningDetails) msg.reasoning_details = reasoningDetails;
-      out.push(msg);
+      out.push(attachAssistantReasoning(msg, m));
       continue;
     }
-    out.push({ role: m.role, content: normalizeContentForOpenAIChat(m.content, { role: m.role }) });
+    const msg = { role: m.role, content: normalizeContentForOpenAIChat(m.content, { role: m.role }) };
+    out.push(m.role === 'assistant' ? attachAssistantReasoning(msg, m) : msg);
   }
   flushToolMedia();
   return out;
@@ -232,7 +224,7 @@ export function parseResponsesToolCalls(response, label) {
       const call = customToolCallFromResponseItem(item);
       if (call) out.push(call);
     } else if (item?.type === 'tool_search_call') {
-      const _tsArgs =
+      const searchArgs =
         item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
           ? item.arguments
           : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, {
@@ -245,7 +237,7 @@ export function parseResponsesToolCalls(response, label) {
           item.call_id || item.id,
           // Schema is a plain object ({query,select,limit}); an array
           // (parsed JSON or passthrough) must never pass through as args.
-          _tsArgs && typeof _tsArgs === 'object' && !Array.isArray(_tsArgs) ? _tsArgs : {}
+          searchArgs && typeof searchArgs === 'object' && !Array.isArray(searchArgs) ? searchArgs : {}
         )
       );
     }
@@ -325,7 +317,7 @@ function toResponsesInputMessage(m, pendingToolMedia = null) {
     const item = {
       type: 'function_call_output',
       call_id: m.toolCallId || '',
-      output: output,
+      output,
     };
     if (mediaContent && pendingToolMedia) pendingToolMedia.push(...mediaContent);
     return item;

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

@@ -24,6 +24,29 @@ import { applyCompatToolChoice, compatStreamRetryReporter } from './compat-reque
 import { envFlag as _envFlag } from '../../../shared/env.mjs';
 import { resolveResponsesTransportPolicy, RESPONSES_TRANSPORT_CAPABILITIES } from './openai-transport-policy.mjs';
 
+// Tool list, parallel tool calls, tool choice and reasoning effort shared by
+// the HTTP/SSE and WebSocket Responses bodies.
+function applyXaiResponsesToolsAndEffort(params, { provider, tools, opts, useModel }) {
+  const nativeTools = nativeResponsesTools(opts);
+  if (tools?.length || nativeTools.length) {
+    params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
+  }
+  // Explicit parallel tool calls, matching the OpenAI Responses
+  // reference shape. Probe-verified accepted by api.x.ai (HTTP 200,
+  // 2026-08-16); absent, the service default decides per turn.
+  if (params.tools?.length) params.parallel_tool_calls = true;
+  applyCompatToolChoice(params, opts);
+  const reasoningEffort = normalizeXaiReasoningEffort(
+    opts.xaiReasoningEffort ??
+      opts.effort ??
+      provider.config?.reasoningEffort ??
+      process.env.MIXDOG_XAI_REASONING_EFFORT
+  );
+  if (reasoningEffort && xaiModelSupportsReasoningEffort(useModel)) {
+    params.reasoning = { effort: reasoningEffort };
+  }
+}
+
 export async function sendXaiResponses(provider, messages, useModel, tools, opts) {
   const signal = opts.signal || null;
   if (signal?.aborted) {
@@ -52,15 +75,7 @@ export async function sendXaiResponses(provider, messages, useModel, tools, opts
   // service's automatic prefix caching.
   if (cacheRouting.key) params.prompt_cache_key = cacheRouting.key;
   if (previousResponseId) params.previous_response_id = previousResponseId;
-  const nativeTools = nativeResponsesTools(opts);
-  if (tools?.length || nativeTools.length) {
-    params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
-  }
-  // Explicit parallel tool calls, matching the OpenAI Responses
-  // reference shape. Probe-verified accepted by api.x.ai (HTTP 200,
-  // 2026-08-16); absent, the service default decides per turn.
-  if (params.tools?.length) params.parallel_tool_calls = true;
-  applyCompatToolChoice(params, opts);
+  applyXaiResponsesToolsAndEffort(params, { provider, tools, opts, useModel });
   // SSE transport: report 'requesting' until the stream opens, then
   // per-chunk onStreamDelta feeds the agent stall watchdog.
   try {
@@ -68,15 +83,6 @@ export async function sendXaiResponses(provider, messages, useModel, tools, opts
   } catch {
     /* heartbeat best-effort */
   }
-  const reasoningEffort = normalizeXaiReasoningEffort(
-    opts.xaiReasoningEffort ??
-      opts.effort ??
-      provider.config?.reasoningEffort ??
-      process.env.MIXDOG_XAI_REASONING_EFFORT
-  );
-  if (reasoningEffort && xaiModelSupportsReasoningEffort(useModel)) {
-    params.reasoning = { effort: reasoningEffort };
-  }
   params.stream = true;
   const cacheLane = XAI_CACHE_LANE_META;
   const totalSignal = createPassthroughSignal(signal);
@@ -172,22 +178,7 @@ export async function sendXaiResponsesWebSocket(provider, messages, useModel, to
   // xAI rejects instructions together with previous_response_id; the
   // first response already anchors instructions for the continuation.
   else if (instructions) params.instructions = instructions;
-  const nativeTools = nativeResponsesTools(opts);
-  if (tools?.length || nativeTools.length) {
-    params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
-  }
-  // Same explicit parallel-tool-calls contract as the HTTP/SSE path.
-  if (params.tools?.length) params.parallel_tool_calls = true;
-  applyCompatToolChoice(params, opts);
-  const reasoningEffort = normalizeXaiReasoningEffort(
-    opts.xaiReasoningEffort ??
-      opts.effort ??
-      provider.config?.reasoningEffort ??
-      process.env.MIXDOG_XAI_REASONING_EFFORT
-  );
-  if (reasoningEffort && xaiModelSupportsReasoningEffort(useModel)) {
-    params.reasoning = { effort: reasoningEffort };
-  }
+  applyXaiResponsesToolsAndEffort(params, { provider, tools, opts, useModel });
   const warmupBody = useXaiResponsesWebSocketWarmup(opts, provider.config, { previousResponseId })
     ? { ...params, generate: false, input: [] }
     : null;

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

@@ -343,6 +343,18 @@ function compatCacheTraceEnabled(provider) {
   );
 }
 
+function traceSessionMeta(opts) {
+  return {
+    owner: opts?.session?.owner || null,
+    role: opts?.session?.role || opts?.role || null,
+    permission: opts?.session?.permission || null,
+    toolPermission: opts?.session?.toolPermission || null,
+    profileId: opts?.session?.profileId || null,
+    sourceType: opts?.session?.sourceType || null,
+    sourceName: opts?.session?.sourceName || null,
+  };
+}
+
 export function writeCompatCacheTrace({
   provider,
   model,
@@ -365,13 +377,7 @@ export function writeCompatCacheTrace({
       provider,
       model,
       responseModel: response?.model || null,
-      owner: opts?.session?.owner || null,
-      role: opts?.session?.role || opts?.role || null,
-      permission: opts?.session?.permission || null,
-      toolPermission: opts?.session?.toolPermission || null,
-      profileId: opts?.session?.profileId || null,
-      sourceType: opts?.session?.sourceType || null,
-      sourceName: opts?.session?.sourceName || null,
+      ...traceSessionMeta(opts),
       sessionIdHash: opts?.sessionId ? traceHash(opts.sessionId) : null,
       providerCacheKeyHash: opts?.providerCacheKey ? traceHash(opts.providerCacheKey) : null,
       promptCacheKeyHash: opts?.promptCacheKey ? traceHash(opts.promptCacheKey) : null,
@@ -606,13 +612,7 @@ export function writeXaiResponsesCacheTrace({
       responseModel: response?.model || null,
       responseIdHash: response?.id ? traceHash(response.id) : null,
       previousResponseIdHash: previousResponseId ? traceHash(previousResponseId) : null,
-      owner: opts?.session?.owner || null,
-      role: opts?.session?.role || opts?.role || null,
-      permission: opts?.session?.permission || null,
-      toolPermission: opts?.session?.toolPermission || null,
-      profileId: opts?.session?.profileId || null,
-      sourceType: opts?.session?.sourceType || null,
-      sourceName: opts?.session?.sourceName || null,
+      ...traceSessionMeta(opts),
       sessionIdHash: opts?.sessionId ? traceHash(opts.sessionId) : null,
       promptCacheKeyHash: params?.prompt_cache_key ? traceHash(params.prompt_cache_key) : null,
       xGrokPromptPrefixHash: cacheRouting?.prefixHash || null,

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

@@ -109,6 +109,8 @@ async function postWithRetries({
       bodyForSend = { bytes: rawBytes, encoding: null };
       await response.arrayBuffer().catch(() => {});
       response = undefined;
+      // The uncompressed replay is not a retry: it must not consume an attempt.
+      attempt--;
       continue;
     }
     const retryableStatus = response && response.status >= 500 && response.status <= 599;
@@ -122,7 +124,7 @@ async function postWithRetries({
       !externalSignal?.aborted &&
       !totalTimeout.signal?.aborted;
     if (attempt < CODEX_REQUEST_MAX_RETRIES && (retryableStatus || retryableTransport)) {
-      if (retryableTransport && requestError) {
+      if (retryableTransport) {
         const code = String(requestError.code || requestError.cause?.code || '');
         if (code === 'ECONNRESET' || code === 'EPIPE' || code === 'UND_ERR_SOCKET') {
           try {

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events/terminal-frames.mjs

@@ -11,7 +11,7 @@ import {
   isMaxOutputIncompleteReason,
 } from '../../lib/responses-terminal-fields.mjs';
 import { LABEL, toolInputPending } from '../response-state.mjs';
-import { usageFromResponse } from '../response-outcome.mjs';
+import { normalizeWsUsage } from '../../openai-ws-response-state/usage.mjs';
 
 // Typed status only — nothing is synthesized from text. The frame itself is
 // preserved so the wire-error default-retry classification applies (fatal
@@ -58,7 +58,7 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
     state.serviceTier = resp.service_tier || resp.serviceTier || state.serviceTier;
     if (!state.model && resp.model) state.model = resp.model;
     if (!state.responseId && resp.id) state.responseId = resp.id;
-    if (resp.usage) state.usage = usageFromResponse(resp.usage, state.serviceTier);
+    if (resp.usage) state.usage = normalizeWsUsage(resp.usage, state.serviceTier);
     if (!absorbCompletedOutput(resp.output || [])) meaningful('semantic');
     state.completed = true;
     setEndTurn(event);

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-items.mjs

@@ -4,7 +4,7 @@
  * items, reasoning items, web_search / tool_search / custom tool calls and
  * pending function_call completion.
  */
-import { makeInvalidToolArgsMarker } from '../openai-compat-stream.mjs';
+import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
 import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
 
 // Completed function_call.arguments parse for the OpenAI Responses stream.

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-outcome.mjs

@@ -4,24 +4,13 @@
  * carries, the stall partial, and `finish` (the success result or the
  * EOF-without-terminal failure).
  */
-import { extractCacheWriteTokens, extractCachedTokens, traceAgentSse, traceAgentUsage } from '../../agent-trace.mjs';
-import { dedupeToolCallList } from '../anthropic-leaked-toolcall.mjs';
+import { traceAgentSse, traceAgentUsage } from '../../agent-trace.mjs';
+import { dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
 import { _displayCodexModel } from '../openai-codex-model.mjs';
 import { createProviderReplay } from '../lib/provider-replay.mjs';
 import { LABEL } from './response-state.mjs';
 import { createResponseStamps } from './response-stamps.mjs';
 
-export function usageFromResponse(rawUsage, serviceTier) {
-  return {
-    inputTokens: rawUsage.input_tokens || 0,
-    outputTokens: rawUsage.output_tokens || 0,
-    cachedTokens: extractCachedTokens(rawUsage),
-    cacheWriteTokens: extractCacheWriteTokens(rawUsage),
-    promptTokens: rawUsage.input_tokens || 0,
-    raw: serviceTier ? { ...rawUsage, service_tier: serviceTier } : rawUsage,
-  };
-}
-
 export function createResponseOutcome({ state }) {
   const { stampToolSafety, stampOutcome, stallPartial, stampStreamError, attachStreamPartial, endedEarlyError } =
     createResponseStamps({

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

@@ -6,7 +6,7 @@
  * module of the stream reads and writes this one object.
  */
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
-import { createToolCallDedupe } from '../anthropic-leaked-toolcall.mjs';
+import { createToolCallDedupe } from '../lib/leaked-toolcall.mjs';
 
 export const LABEL = 'OpenAI OAuth HTTP fallback';
 

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/text-relay.mjs

@@ -13,7 +13,7 @@
  * fires for tools the model was actually offered. Additive: the native
  * function_call path is untouched.
  */
-import { createLeakGuard } from '../anthropic-leaked-toolcall.mjs';
+import { createLeakGuard } from '../lib/leaked-toolcall.mjs';
 import { synthLeakedOpenAICall } from '../openai-compat-stream-common.mjs';
 
 function pushOutputTextAnnotations(part, citations, citationKeys) {

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

@@ -5,8 +5,8 @@
  * exchange, the localhost callback server, and interactive login helpers.
  * openai-oauth.mjs re-exports beginOAuthLogin/loginOAuth as a facade so
  * existing importers resolve unchanged. Token persistence + JWT parsing stay
- * owned by openai-oauth.mjs and are injected here to avoid a circular import
- * of its module-level token store state.
+ * owned by openai-oauth-tokens.mjs and are injected here to avoid a circular
+ * import of its module-level token store state.
  */
 import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';

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

@@ -18,7 +18,7 @@ import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
-import { decodeJwtPayload, expiryFromAccessToken } from './lib/oauth-token-utils.mjs';
+import { decodeJwtPayload, expiryFromAccessToken, oauthCredentialStatus } from './lib/oauth-token-utils.mjs';
 import { createOpenAIOAuthLogin } from './openai-oauth-login.mjs';
 import { CODEX_OAUTH_ORIGINATOR } from './openai-codex-endpoints.mjs';
 
@@ -125,8 +125,6 @@ export function describeOpenAIOAuthCredentials() {
     }
     const hasRefresh = Boolean(tokens.refresh_token);
     const expiresAt = _normalizeExpiresAt(tokens.expires_at ?? tokens.expiresAt);
-    const expiring = expiresAt > 0 && expiresAt < Date.now() + TOKEN_REFRESH_SKEW_MS;
-    const expired = expiresAt > 0 && expiresAt <= Date.now();
     const source = tokens.source || 'oauth';
     // Account identity for multi-account rosters: the id_token's email
     // when present, else a short prefix of the ChatGPT account id.
@@ -134,48 +132,8 @@ export function describeOpenAIOAuthCredentials() {
     const email = typeof claims.email === 'string' ? claims.email : '';
     const accountId = tokens.account_id ? `${String(tokens.account_id).slice(0, 8)}…` : '';
     const identity = { ...(email ? { email } : {}), ...(accountId ? { accountId } : {}) };
-    if (!hasRefresh) {
-      return {
-        authenticated: expiresAt === 0 || !expired,
-        usable: expiresAt === 0 || !expired,
-        refreshable: false,
-        reauthRequired: expired,
-        status: expired ? 'Reauth Required' : 'Access Only',
-        detail: `${source}; no refresh token`,
-        expiresAt,
-        ...identity,
-      };
-    }
-    if (expired)
-      return {
-        authenticated: true,
-        usable: false,
-        refreshable: true,
-        reauthRequired: false,
-        status: 'Refresh Required',
-        detail: source,
-        expiresAt,
-        ...identity,
-      };
-    if (expiring)
-      return {
-        authenticated: true,
-        usable: true,
-        refreshable: true,
-        reauthRequired: false,
-        status: 'Refresh Soon',
-        detail: source,
-        expiresAt,
-        ...identity,
-      };
     return {
-      authenticated: true,
-      usable: true,
-      refreshable: true,
-      reauthRequired: false,
-      status: 'Valid',
-      detail: source,
-      expiresAt,
+      ...oauthCredentialStatus({ hasRefresh, expiresAt, detail: source, refreshSkewMs: TOKEN_REFRESH_SKEW_MS }),
       ...identity,
     };
   } catch (err) {

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

@@ -32,6 +32,7 @@
 import { performance } from 'node:perf_hooks';
 import { appendAgentTrace } from '../agent-trace.mjs';
 import { acquireWebSocket, _sendFrame, drainOpenaiWsPool } from './openai-ws-pool.mjs';
+import { sleepWithAbort } from './retry-classifier.mjs';
 import { _logicalResponseItemMatch, parseToolSearchArgs, _streamResponse } from './openai-ws-stream.mjs';
 import {
   HANDSHAKE_MAX_ATTEMPTS,
@@ -160,22 +161,7 @@ async function _acquireWithRetry({
       const sleepStart = performance.now();
       try {
         if (externalSignal) {
-          await new Promise((resolve, reject) => {
-            const t = setTimeout(() => {
-              externalSignal.removeEventListener('abort', onAbort);
-              resolve();
-            }, backoff);
-            const onAbort = () => {
-              clearTimeout(t);
-              const reason = externalSignal.reason;
-              reject(reason instanceof Error ? reason : new Error('OpenAI OAuth WS acquire aborted'));
-            };
-            if (externalSignal.aborted) {
-              onAbort();
-              return;
-            }
-            externalSignal.addEventListener('abort', onAbort, { once: true });
-          });
+          await sleepWithAbort(backoff, externalSignal, undefined, 'OpenAI OAuth WS acquire aborted');
         } else {
           await _sleepFn(backoff);
         }

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

@@ -39,6 +39,7 @@ import {
   resolveProviderCacheKey,
 } from '../agent-runtime/cache-strategy.mjs';
 import { preconnect } from '../../../shared/llm/http-agent.mjs';
+import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import { sendViaHttpSse, _envFlag } from './openai-oauth-http-sse.mjs';
 import { warmCodexClientVersion } from './codex-client-meta.mjs';
 import { CODEX_BACKEND_ORIGIN } from './openai-codex-endpoints.mjs';
@@ -51,11 +52,12 @@ import {
   refreshCodexCatalog,
 } from './openai-oauth-catalog.mjs';
 import { _displayCodexModel } from './openai-codex-model.mjs';
+import { buildRequestBody } from './openai-responses-payload.mjs';
+import { streamCallbacks } from './lib/send-callbacks.mjs';
 export { _displayCodexModel };
 
 // Public test/integration entry retained alongside the transport module export.
 export { sendViaHttpSse };
-import { buildRequestBody } from './openai-responses-payload.mjs';
 export {
   buildCodexStartupPrewarmBody,
   buildRequestBody,
@@ -171,10 +173,7 @@ export class OpenAIOAuthProvider {
     // build so the HTTP/SSE path skips the cold TLS handshake.
     preconnect(CODEX_BACKEND_ORIGIN);
     const opts = sendOpts || {};
-    const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
-    const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
-    const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
-    const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
+    const { onStageChange, onStreamDelta, onToolCall, onTextDelta } = streamCallbacks(opts);
     const externalSignal = opts.signal || null;
     const _sendSessionId = opts.sessionId || '(none)';
     const _sendAgent = opts.agent || '(none)';
@@ -211,6 +210,8 @@ export class OpenAIOAuthProvider {
     const authState = { tokens: await _authP };
     await _verP;
     const body = await _bodyP;
+    // Every WS/HTTP attempt of this send carries this body's tier unchanged.
+    noteRequestServiceTier(body.service_tier);
     // poolKey != cacheKey by design. poolKey isolates socket/delta state per
     // session. cacheKey is body.prompt_cache_key and affects prompt-cache
     // routing only; Codex handshake identity comes from sendOpts and remains

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

@@ -17,7 +17,10 @@ import {
  * media, since that item carries no text field), everything else with
  * function_call_output.
  */
-function pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallNameById, nativeSearchCalls, opts }) {
+function pushToolResult(
+  m,
+  { out, pendingToolMedia, pendingToolLoads, customToolCallNameById, nativeSearchCalls, opts }
+) {
   const { output, mediaContent } = splitToolContentForOpenAIResponses(m.content);
   if (customToolCallNameById.has(m.toolCallId || '')) {
     out.push({

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

@@ -20,8 +20,6 @@ import {
   resolveTimeoutMs,
 } from '../stall-policy.mjs';
 
-// Human-readable transport label for handshake/acquire error messages. Shared
-// with openai-oauth-ws.mjs (stream-side errors use the same labels).
 import {
   _envOn,
   _codexBetaFeatures,
@@ -30,6 +28,9 @@ import {
   _cfCookieHeader,
 } from './openai-ws-headers.mjs';
 import { clearAllCodexTurnStates, clearCodexTurnStateScope, retireCodexTurnStateOwner } from './openai-turn-state.mjs';
+
+// Human-readable transport label for handshake/acquire error messages. Shared
+// with openai-oauth-ws.mjs (stream-side errors use the same labels).
 export function _wsErrLabel(p) {
   if (p === 'xai') return 'xAI WS';
   if (p === 'openai-direct' || p === 'openai') return 'OpenAI WS';

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state/tool-calls.mjs

@@ -1,6 +1,6 @@
-import { makeInvalidToolArgsMarker } from '../openai-compat-stream.mjs';
+import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
 import { synthLeakedOpenAICall } from '../openai-compat-stream-common.mjs';
-import { createToolCallDedupe, dedupeToolCallList } from '../anthropic-leaked-toolcall.mjs';
+import { createToolCallDedupe, dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
 import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
 

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

@@ -9,7 +9,7 @@
  * stream, synthesized (native `call_...` id shape), and dispatched like
  * native ones. Additive: the native function_call path is untouched.
  */
-import { createLeakGuard } from './anthropic-leaked-toolcall.mjs';
+import { createLeakGuard } from './lib/leaked-toolcall.mjs';
 
 /**
  * @param {object} deps

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

@@ -20,7 +20,10 @@ import { sendViaHttpSse, _envFlag } from './openai-oauth-http-sse.mjs';
 import { shouldFallbackTransport } from './retry-classifier.mjs';
 import { resolveOpenAiTransportPolicy } from './openai-transport-policy.mjs';
 import { applyOpenAIDirectCachePolicy, openAiDirectSupportsFast } from './openai-direct-request.mjs';
+import { streamCallbacks } from './lib/send-callbacks.mjs';
 import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
+import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import { resolveProviderCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
 
 function applyOpenAIDirectFastTier(body, model, opts) {
@@ -105,10 +108,7 @@ export class OpenAIDirectProvider {
   }
   async send(messages, model, tools, sendOpts) {
     const opts = sendOpts || {};
-    const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
-    const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
-    const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
-    const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
+    const { onStageChange, onStreamDelta, onToolCall, onTextDelta } = streamCallbacks(opts);
     const externalSignal = opts.signal || null;
     const apiKey = this._ensureKey();
     const useModel = model || 'gpt-5.5';
@@ -123,6 +123,7 @@ export class OpenAIDirectProvider {
     // so a model can opt into Fast even when the OAuth catalog does not
     // advertise a Fast tier for its OAuth endpoint.
     applyOpenAIDirectFastTier(body, useModel, opts);
+    noteRequestServiceTier(body.service_tier);
     // Keep public response storage and model-specific cache options out of
     // the shared OAuth payload. Storage opt-out still forces full frames in
     // _computeDelta; retained output items make those frames self-contained.
@@ -247,6 +248,7 @@ export class OpenAIDirectProvider {
       const res = await fetch('https://api.openai.com/v1/models', {
         signal: AbortSignal.timeout(10_000),
         headers: { Authorization: `Bearer ${apiKey}` },
+        dispatcher: getLlmDispatcher(),
       });
       if (!res.ok) return [];
       const j = await res.json();

package/src/runtime/agent/orchestrator/providers/opencode-go-usage.mjs

@@ -9,6 +9,7 @@ import { recordQuotaReadings } from './lib/quota-readings.mjs';
 const CACHE_FILE = 'opencode-go-usage-cache.json';
 const LIVE_TTL_MS = 5 * 60_000;
 const STALE_TTL_MS = 60 * 60_000;
+const FETCH_TIMEOUT_MS = 6500;
 // The console replaced its server-rendered page (usage inlined in the HTML) with
 // a SPA over this REST API, so scraping `/workspace/{id}/go` now yields an empty
 // shell. `GET /api/go/status` answers a service-account key that carries the
@@ -146,7 +147,7 @@ export async function fetchOpenCodeGoUsageSnapshot(_config = {}, { force = false
     throw err;
   }
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 6500);
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
     const res = await fetch(`${BASE_URL}/api/go/status`, {
       signal: controller.signal,

package/src/runtime/agent/orchestrator/providers/opencode-go.mjs

@@ -64,10 +64,10 @@ function normalizeOpenCodeGoResultUsage(result, anthropicRoute) {
   };
 }
 
-function opencodeGoContextWindow(_modelId, current = 0) {
+function opencodeGoContextWindow(modelId, current = 0) {
   const native = Number(current);
   if (Number.isFinite(native) && native > 0) return native;
-  const catalog = getModelMetadataSync(_modelId, 'opencode-go');
+  const catalog = getModelMetadataSync(modelId, 'opencode-go');
   const contextWindow = Number(catalog?.contextWindow);
   if (Number.isFinite(contextWindow) && contextWindow > 0) return Math.floor(contextWindow);
   return 0;