mixdog 0.9.170 → 0.9.172

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

@@ -1,4 +1,4 @@
-// Grok OAuth browser login + PKCE exchange, extracted from grok-oauth.mjs.
+// Grok OAuth browser login + PKCE exchange.
 /**
  * Grok CLI OAuth provider ("Grok Build").
  *
@@ -14,11 +14,10 @@
  * preset wired for the Responses API — with the proxy URL + CLI headers
  * injected via config.extraHeaders, bearer swapped for the OAuth access token.
  */
-import { createServer } from 'http';
-import { randomBytes } from 'crypto';
+import { createServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
 
-// --- Constants ---
 // xAI's shared OAuth client. The consent screen renders this as "Grok Build".
 import {
   CLIENT_ID,

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

@@ -1,4 +1,4 @@
-// Grok OAuth discovery, token storage/refresh, and proxy identity, extracted from grok-oauth.mjs.
+// Grok OAuth discovery, token storage/refresh, and proxy identity.
 /**
  * Grok CLI OAuth provider ("Grok Build").
  *
@@ -14,9 +14,9 @@
  * preset wired for the Responses API — with the proxy URL + CLI headers
  * injected via config.extraHeaders, bearer swapped for the OAuth access token.
  */
-import { randomUUID } from 'crypto';
-import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
-import { join, resolve } from 'path';
+import { randomUUID } from 'node:crypto';
+import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
@@ -24,7 +24,6 @@ import { createTimeoutSignal } from '../stall-policy.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { decodeJwtPayload, expiryFromAccessToken, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
 
-// --- Constants ---
 // xAI's shared OAuth client. The consent screen renders this as "Grok Build".
 
 export const CLIENT_ID = 'b1a00492-073a-47ea-816f-4c329264a828';
@@ -35,27 +34,24 @@ export const CALLBACK_HOST = '127.0.0.1';
 export const CALLBACK_PORT = 56121;
 export const CALLBACK_PATH = '/callback';
 export const REDIRECT_URI = `http://${CALLBACK_HOST}:${CALLBACK_PORT}${CALLBACK_PATH}`;
-// Primary inference + search target. The OAuth token's `api:access` scope works
-// against the STANDARD xAI API (GET /models 200, POST /responses 200, web_search
-// 200 with citations). grok-4.x and web search live here. Proxy-only models
-// (grok-build, grok-composer-2.5-fast) are NOT published on api.x.ai — they route
-// to PROXY_BASE_URL below, which is version-gated and needs the Grok CLI client
-// headers (see proxyHeaders).
+// Native xAI model catalog. Proxy-only models (grok-build,
+// grok-composer-2.5-fast) are not published here, so discovery merges both
+// catalogs. All OAuth inference uses PROXY_BASE_URL instead.
 export const INFERENCE_BASE_URL = 'https://api.x.ai/v1';
 export const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
 
 // --- grok-build CLI proxy (Composer 2.5, grok-build) ---
 // These models live ONLY on the grok-build proxy, not api.x.ai. /models is
 // readable with the bare OAuth bearer; /responses is version-gated (HTTP 426)
-// and requires the Grok CLI's client headers. We route only proxy-only models
-// here and keep grok-4.x + search on api.x.ai.
+// and requires the Grok CLI's client headers. All OAuth models route here
+// for inference, including those discovered through api.x.ai.
 export const PROXY_BASE_URL = 'https://cli-chat-proxy.grok.com/v1';
 const GROK_CLIENT_IDENTIFIER = 'grok-shell';
 const GROK_CLI_VERSION_FALLBACK = '0.2.16';
 
-// Route to the proxy: any grok-composer* model, plus the bare `grok-build`
+// Proxy-only catalog models: any grok-composer* model, plus the bare `grok-build`
 // coding agent. NOT grok-build-0.1 — that is a real api.x.ai model and must stay
-// on api.x.ai, so we match grok-build exactly rather than by prefix.
+// in the native catalog, so we match grok-build exactly rather than by prefix.
 const PROXY_EXACT_MODELS = new Set(['grok-build']);
 export function isProxyOnlyModel(model) {
   const m = String(model || '');
@@ -187,12 +183,6 @@ export function _normalizeExpiresAt(value) {
   return n < 1e12 ? n * 1000 : n;
 }
 
-// Fallback expiry from the access_token's JWT `exp` claim (epoch ms) when the
-// store carries no explicit expires_at — without it expires_at stays 0, which
-// ensureAuth reads as "never expires", disabling proactive refresh. Returns 0
-// for opaque (non-JWT) tokens. JWT `exp` is epoch SECONDS (RFC 7519).
-const _expiryFromAccessToken = expiryFromAccessToken;
-
 export function _identityFromAccessToken(token) {
   const payload = decodeJwtPayload(token);
   if (!payload) return {};
@@ -226,7 +216,11 @@ export function _loadOwnTokens() {
     return {
       access_token: raw.access_token,
       refresh_token: raw.refresh_token,
-      expires_at: _normalizeExpiresAt(raw.expires_at ?? raw.expiresAt) || _expiryFromAccessToken(raw.access_token),
+      // Fallback expiry from the access_token's JWT `exp` claim (epoch ms) when the
+      // store carries no explicit expires_at — without it expires_at stays 0, which
+      // ensureAuth reads as "never expires", disabling proactive refresh. Returns 0
+      // for opaque (non-JWT) tokens. JWT `exp` is epoch SECONDS (RFC 7519).
+      expires_at: _normalizeExpiresAt(raw.expires_at ?? raw.expiresAt) || expiryFromAccessToken(raw.access_token),
       token_endpoint: raw.token_endpoint || null,
       user_id: raw.user_id || raw.userId || identity.user_id || '',
       principal_type: raw.principal_type || raw.principalType || identity.principal_type || '',
@@ -494,5 +488,3 @@ export async function refreshTokens(tokens, { force = false } = {}) {
     }
   );
 }
-
-// --- Model catalog cache (24h disk TTL) ---

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

@@ -21,7 +21,6 @@ import { createTimeoutSignal } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
 
-// --- Constants ---
 // xAI's shared OAuth client. The consent screen renders this as "Grok Build".
 import {
   INFERENCE_BASE_URL,
@@ -139,9 +138,7 @@ function _displayGrokModel(model) {
     .replace(/^grok-/i, 'Grok ')
     .replace(/-0?309\b/g, '')
     .replace(/-/g, ' ')
-    .replace(/\b\w/g, (m) => m.toUpperCase())
-    .replace(/\bNon Reasoning\b/g, 'Non Reasoning')
-    .replace(/\bMulti Agent\b/g, 'Multi Agent');
+    .replace(/\b\w/g, (m) => m.toUpperCase());
   text = text.replace(/\s+/g, ' ').trim();
   return text || raw;
 }
@@ -419,8 +416,7 @@ export class GrokOAuthProvider {
       // own 401 handler — that one reloads a static apiKey from config,
       // which is wrong for OAuth. We own the refresh-and-retry below.
       // Caller's model passes through (or catalog-top default), with
-      // retired aliases normalized. api.x.ai exposes the full grok-4.x
-      // catalog to this token — no single-model lock.
+      // retired aliases normalized — no single-model lock.
       return await inner._doSend(messages, useModel, grokTools, sendOpts);
     } catch (err) {
       // Refresh-and-retry on a server-rejected OAuth session (401/403).
@@ -554,5 +550,3 @@ export class GrokOAuthProvider {
     return this.tokens !== null || loadTokens() !== null;
   }
 }
-
-// --- Login flow (PKCE, export for CLI / setup use) ---

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -76,8 +76,7 @@ export function resolveAnthropicMessageCacheSlots(systemBlocks, ttls) {
 
 // Single lowering of orchestrator messages to the Anthropic wire shape. The
 // API-key provider (anthropic.mjs, via anthropic-messages.mjs) and the OAuth
-// provider (anthropic-oauth.mjs) both used to carry byte-identical copies;
-// they now share this one.
+// provider (anthropic-oauth.mjs) share this lowering.
 //
 // Marker-free lowering. cache_control is applied AFTER sanitization by
 // applyAnthropicCacheMarkers() so that block drops/inserts/reorders performed
@@ -205,11 +204,11 @@ export function toAnthropicMessages(messages, availableTools) {
           ? []
           : references.filter((name) => !usableReferences.includes(name));
       const isError = m.toolKind === 'error' || m.isError === true;
-      let content = usableReferences.length
-        ? usableReferences.map((tool_name) => ({ type: 'tool_reference', tool_name }))
-        : droppedReferences.length
-          ? toolResultContentWithoutReferences(m, droppedReferences)
-          : normalizeContentForAnthropic(m.content);
+      let content;
+      if (usableReferences.length)
+        content = usableReferences.map((tool_name) => ({ type: 'tool_reference', tool_name }));
+      else if (droppedReferences.length) content = toolResultContentWithoutReferences(m, droppedReferences);
+      else content = normalizeContentForAnthropic(m.content);
       let hoisted = [];
       if (isError) ({ content, hoisted } = splitErrorToolResultContent(content));
       const block = {
@@ -363,7 +362,7 @@ export function sanitizeAnthropicInputSchema(schema, toolName, logTag) {
   }
   const compound = schema.oneOf || schema.anyOf || schema.allOf;
   if (!compound) return structuredClone(schema);
-  const compoundKey = schema.oneOf ? 'oneOf' : schema.anyOf ? 'anyOf' : 'allOf';
+  const compoundKey = ['oneOf', 'anyOf', 'allOf'].find((key) => schema[key]);
   const conjunctive = compoundKey === 'allOf';
   const mergedProps = { ...(schema.properties && typeof schema.properties === 'object' ? schema.properties : {}) };
   const required = new Set(Array.isArray(schema.required) ? schema.required : []);

package/src/runtime/agent/orchestrator/providers/lib/gemini-model-catalog.mjs

@@ -11,6 +11,14 @@ export const GEMINI_MODELS = [
 
 export const DEFAULT_GEMINI_MODEL = GEMINI_MODELS[0].id;
 
+// Most specific family first: a flash-lite id also matches /flash/.
+const GEMINI_FAMILIES = [
+  [/flash-lite/, 'gemini-flash-lite'],
+  [/flash/, 'gemini-flash'],
+  [/pro/, 'gemini-pro'],
+];
+const geminiFamily = (id) => GEMINI_FAMILIES.find(([pattern]) => pattern.test(id))?.[1] ?? 'gemini';
+
 export const geminiModelCache = makeModelCache({
   fileName: 'gemini-models.json',
   ttlMs: 24 * 60 * 60_000,
@@ -89,13 +97,7 @@ export async function fetchAndCacheGeminiModels({ apiKey, fetchFn, modelCache, c
     .filter((model) => !/embedding|aqa|imagen|robotics|computer-use/.test(model?.name || ''))
     .map((model) => {
       const id = (model.name || '').replace(/^models\//, '');
-      const family = /flash-lite/.test(id)
-        ? 'gemini-flash-lite'
-        : /flash/.test(id)
-          ? 'gemini-flash'
-          : /pro/.test(id)
-            ? 'gemini-pro'
-            : 'gemini';
+      const family = geminiFamily(id);
       return {
         id,
         display: model.displayName || id,

package/src/runtime/agent/orchestrator/providers/lib/grok-tool-schema.mjs

@@ -41,11 +41,10 @@ function mergeObjectBranchProperties(objectBranches) {
       }
       if (schemasDeepEqual(properties[name], schema)) continue;
       const alternatives = [...pureAnyOfAlternatives(properties[name]), ...pureAnyOfAlternatives(schema)];
-      const deduped = alternatives.reduce(
-        (unique, alternative) =>
-          unique.some((item) => schemasDeepEqual(item, alternative)) ? unique : [...unique, alternative],
-        []
-      );
+      const deduped = [];
+      for (const alternative of alternatives) {
+        if (!deduped.some((item) => schemasDeepEqual(item, alternative))) deduped.push(alternative);
+      }
       if (deduped.every((value) => value.type === 'object' || value.properties)) {
         const { required: _required, properties: _properties, ...base } = deduped[0];
         const required = requiredKeys(deduped[0]).filter((key) =>
@@ -100,14 +99,13 @@ function describesScalar(schema) {
 // Flattening keeps one branch, so a description that still promises the dropped
 // shape would advertise more than the wire schema accepts. Project the loss
 // into the text the model actually reads.
+function droppedBranchNote(schema, dropped) {
+  if (describesArray(schema)) return dropped.some(describesScalar) ? ARRAY_ONLY_NOTE : null;
+  return dropped.some(describesArray) ? ARRAY_DROP_NOTE : null;
+}
+
 function projectDroppedBranches(schema, dropped) {
-  const note = describesArray(schema)
-    ? dropped.some(describesScalar)
-      ? ARRAY_ONLY_NOTE
-      : null
-    : dropped.some(describesArray)
-      ? ARRAY_DROP_NOTE
-      : null;
+  const note = droppedBranchNote(schema, dropped);
   if (!note) return schema;
   const description = String(schema.description || '').trim();
   if (description.includes(note)) return schema;
@@ -123,12 +121,36 @@ function projectDroppedBranches(schema, dropped) {
 function preferredBranch(branches) {
   const objects = branches.filter((branch) => branch && typeof branch === 'object' && !Array.isArray(branch));
   const arrays = objects.filter(describesArray);
-  if (arrays.length === 1 && objects.length > 1 && objects.every((branch) => branch === arrays[0] || describesScalar(branch))) {
+  if (
+    arrays.length === 1 &&
+    objects.length > 1 &&
+    objects.every((branch) => branch === arrays[0] || describesScalar(branch))
+  ) {
     return arrays[0];
   }
   return objects[0] || null;
 }
 
+// Keywords whose value is a name → schema map.
+const SCHEMA_MAP_KEYWORDS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas'];
+// Keywords whose value is a schema or a list of schemas. Schema-valued
+// keywords are not restricted to object properties. Data-valued keywords
+// such as enum/default/examples are never walked.
+const SCHEMA_VALUED_KEYWORDS = [
+  'items',
+  'prefixItems',
+  'additionalProperties',
+  'contains',
+  'allOf',
+  'not',
+  'if',
+  'then',
+  'else',
+  'propertyNames',
+  'unevaluatedProperties',
+  'unevaluatedItems',
+];
+
 function normalizeGrokPropertySchema(schema) {
   if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return schema;
   const branches = [
@@ -147,7 +169,7 @@ function normalizeGrokPropertySchema(schema) {
   const replace = (key, value) => {
     if (value !== schema[key]) result = { ...result, [key]: value };
   };
-  for (const key of ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']) {
+  for (const key of SCHEMA_MAP_KEYWORDS) {
     if (!schema[key] || typeof schema[key] !== 'object') continue;
     let changed = false;
     const children = Object.fromEntries(
@@ -159,22 +181,7 @@ function normalizeGrokPropertySchema(schema) {
     );
     if (changed) replace(key, children);
   }
-  // Schema-valued keywords are not restricted to object properties. Do not
-  // walk data-valued keywords such as enum/default/examples.
-  for (const key of [
-    'items',
-    'prefixItems',
-    'additionalProperties',
-    'contains',
-    'allOf',
-    'not',
-    'if',
-    'then',
-    'else',
-    'propertyNames',
-    'unevaluatedProperties',
-    'unevaluatedItems',
-  ]) {
+  for (const key of SCHEMA_VALUED_KEYWORDS) {
     const child = schema[key];
     if (Array.isArray(child)) {
       const children = child.map(normalizeGrokPropertySchema);
@@ -198,15 +205,7 @@ function normalizeGrokToolSchema(schema) {
 
   const { anyOf, oneOf, ...root } = schema;
   const branches = [...(Array.isArray(anyOf) ? anyOf : []), ...(Array.isArray(oneOf) ? oneOf : [])];
-  const objectBranches = branches.filter(
-    (branch) =>
-      branch &&
-      typeof branch === 'object' &&
-      !Array.isArray(branch) &&
-      (branch.type === 'object' ||
-        (Array.isArray(branch.type) && branch.type.includes('object')) ||
-        (branch.properties && typeof branch.properties === 'object'))
-  );
+  const objectBranches = branches.filter(isObjectBranch);
 
   if (!objectBranches.length) {
     const required = [...new Set([...requiredKeys(root), ...firstExclusiveRequired(branches)])];
@@ -218,52 +217,67 @@ function normalizeGrokToolSchema(schema) {
     });
   }
 
+  const properties = mergedSchemaProperties(root, objectBranches);
+  const actionContract = actionInputContract(schema);
+  if (actionContract && properties?.input) {
+    properties.input = { ...properties.input, description: actionContract };
+  }
+  const required = unionRequired(root, objectBranches);
+  return normalizeGrokPropertySchema({
+    ...withoutPropertiesOrRequired(Object.assign({}, ...objectBranches)),
+    ...withoutPropertiesOrRequired(root),
+    type: 'object',
+    ...(properties ? { properties } : {}),
+    ...(required.length ? { required } : {}),
+  });
+}
+
+function isObjectBranch(branch) {
+  return (
+    branch &&
+    typeof branch === 'object' &&
+    !Array.isArray(branch) &&
+    (branch.type === 'object' ||
+      (Array.isArray(branch.type) && branch.type.includes('object')) ||
+      (branch.properties && typeof branch.properties === 'object'))
+  );
+}
+
+// The branches' merged properties under the root's own. A root's generic
+// input object constrains its type; it must not erase the action branches'
+// actual fields.
+function mergedSchemaProperties(root, objectBranches) {
   const properties =
     objectBranches.some((branch) => branch.properties) || root.properties
       ? mergeObjectBranchProperties(objectBranches)
       : undefined;
   for (const [name, property] of Object.entries(root.properties || {})) {
     const combined = properties[name];
-    // A root's generic input object constrains its type; it must not erase
-    // the action branches' actual fields.
     properties[name] =
       property.type === 'object' && !property.properties && combined?.type === 'object'
         ? { ...combined, ...property, properties: combined.properties }
         : property;
   }
-  const actionContract = actionInputContract(schema);
-  if (actionContract && properties?.input) {
-    properties.input = {
-      ...properties.input,
-      description: actionContract,
-    };
-  }
+  return properties;
+}
+
+// The root's required keys plus the ones every branch requires; when the
+// branches share none, the first branch's exclusive keys stand in.
+function unionRequired(root, objectBranches) {
   const branchRequiredInEvery = (Array.isArray(objectBranches[0].required) ? objectBranches[0].required : []).filter(
     (key) => objectBranches.every((branch) => Array.isArray(branch.required) && branch.required.includes(key))
   );
-  const required = [
+  return [
     ...new Set([
       ...requiredKeys(root),
       ...branchRequiredInEvery,
       ...(branchRequiredInEvery.length ? [] : firstExclusiveRequired(objectBranches)),
     ]),
   ];
-  const { properties: _rootProperties, required: _rootRequired, ...rootWithoutPropertiesOrRequired } = root;
-  const mergedObjectBranches = Object.assign({}, ...objectBranches);
-  const {
-    properties: _branchProperties,
-    required: _branchRequired,
-    ...mergedObjectBranchesWithoutPropertiesOrRequired
-  } = mergedObjectBranches;
-  return normalizeGrokPropertySchema({
-    ...mergedObjectBranchesWithoutPropertiesOrRequired,
-    ...rootWithoutPropertiesOrRequired,
-    type: 'object',
-    ...(properties ? { properties } : {}),
-    ...(required.length ? { required } : {}),
-  });
 }
 
+const withoutPropertiesOrRequired = ({ properties: _properties, required: _required, ...rest }) => rest;
+
 export function normalizeGrokToolSchemas(tools) {
   if (!Array.isArray(tools)) return tools;
   return tools.map((tool) => {

package/src/runtime/agent/orchestrator/providers/lib/oauth-pkce.mjs

@@ -1,4 +1,4 @@
-import { createHash, randomBytes } from 'crypto';
+import { createHash, randomBytes } from 'node:crypto';
 
 export function createOAuthPkce(verifierBytes = 32) {
   const verifier = randomBytes(verifierBytes).toString('base64url');

package/src/runtime/agent/orchestrator/providers/lib/openai-tool-args.mjs

@@ -38,12 +38,14 @@ export function formatInvalidToolArgsResult(call) {
  *   the call: a JSON.parse failure is then deterministic bad JSON (permanent),
  *   not a mid-stream truncation (retryable). */
 export function parseCompletedToolCallArgumentsJson(raw, label, meta) {
-  const text = typeof raw === 'string' ? raw : raw == null ? '' : String(raw);
+  let text = '';
+  if (typeof raw === 'string') text = raw;
+  else if (raw != null) text = String(raw);
   const src = text === '' ? '{}' : text;
   try {
     return JSON.parse(src);
   } catch (err) {
-    const preview = text.length <= 64 ? text : text.slice(0, 32) + '...' + text.slice(-32);
+    const preview = text.length <= 64 ? text : `${text.slice(0, 32)}...${text.slice(-32)}`;
     const detailParts = [`invalid tool_call arguments JSON: len=${text.length} preview=${JSON.stringify(preview)}`];
     if (meta) {
       const m = {};

package/src/runtime/agent/orchestrator/providers/lib/responses-terminal-fields.mjs

@@ -0,0 +1,28 @@
+/**
+ * lib/responses-terminal-fields.mjs — fields read off terminal Responses
+ * frames, shared by the HTTP SSE and WebSocket transports.
+ */
+
+// Wire-level `end_turn` on a terminal Responses frame: an optional boolean on
+// the completed response, where "false ⇒ needs follow-up". Only a real boolean
+// is normalized; anything else — including a missing field — stays undefined
+// so absence is preserved and no caller can mistake "server said nothing" for
+// "server said true/false".
+export function endTurnFromEvent(event) {
+  if (!event || typeof event !== 'object') return undefined;
+  const fromResponse = event.response?.end_turn;
+  if (typeof fromResponse === 'boolean') return fromResponse;
+  const topLevel = event.end_turn;
+  if (typeof topLevel === 'boolean') return topLevel;
+  return undefined;
+}
+
+export function incompleteReasonFromEvent(event) {
+  const reasonObj =
+    event?.response?.incomplete_details || event?.incomplete_details || event?.response?.status_details || null;
+  return String(reasonObj?.reason || event?.response?.status || 'incomplete');
+}
+
+export function isMaxOutputIncompleteReason(reason) {
+  return /^(?:max_output_tokens|max_tokens|length|output_token_limit)$/i.test(String(reason || '').trim());
+}

package/src/runtime/agent/orchestrator/providers/lib/stream-outcome.mjs

@@ -251,7 +251,9 @@ function _finalize(signals) {
   const replayUnsafe = visibleOutput || sideEffectDispatched || s.dispatchAmbiguous === true || s.unsafeMarker === true;
   const replaySafe = !replayUnsafe && s.userAbort !== true;
   // A terminal frame that declared `end_turn=false` keeps the turn open.
-  const continuation = s.declaredContinuation === true ? true : terminalObserved ? false : s.continuation === true;
+  let continuation = s.continuation === true;
+  if (s.declaredContinuation === true) continuation = true;
+  else if (terminalObserved) continuation = false;
   return Object.freeze({
     version: STREAM_OUTCOME_VERSION,
     provider: s.provider || null,

package/src/runtime/agent/orchestrator/providers/lib/usage-primitives.mjs

@@ -1,10 +1,5 @@
 // Shared numeric/string primitives for provider usage-accounting modules.
 //
-// These are byte-for-byte identical helpers that were duplicated across
-// api-usage.mjs, oauth-usage.mjs and opencode-go-usage.mjs. Extracting them
-// here is behavior-preserving: each exported function reproduces the exact
-// logic of the copies it replaces.
-//
 // NOTE ON `num`: api-usage.mjs and oauth-usage.mjs use the guarded variant
 // below (treats null/undefined/'' as the fallback before Number()).
 // opencode-go-usage.mjs uses an *unguarded* variant (Number('') === 0), which
@@ -24,8 +19,6 @@ export function round(value, digits = 4) {
   return Math.round(n * scale) / scale;
 }
 
-// cleanString (oauth-usage.mjs) and clean (opencode-go-usage.mjs) were
-// identical: trim strings, coerce empties/non-strings to null.
 export function cleanString(value) {
   const s = typeof value === 'string' ? value.trim() : '';
   return s || null;

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -50,20 +50,15 @@ function fileInfo(block) {
       String(source.media_type || source.mediaType || block.mimeType || block.mediaType || 'application/pdf')
         .trim()
         .toLowerCase() || 'application/pdf';
-    const filename =
-      typeof block.title === 'string' && block.title
-        ? block.title
-        : typeof block.filename === 'string' && block.filename
-          ? block.filename
-          : '';
+    let filename = '';
+    if (typeof block.title === 'string' && block.title) filename = block.title;
+    else if (typeof block.filename === 'string' && block.filename) filename = block.filename;
     return { data: source.data, mimeType, filename };
   }
   if (block.type !== 'file') return null;
-  const data = isAttachmentReference(block)
-    ? readAttachmentBase64(block)
-    : typeof block.data === 'string'
-      ? block.data
-      : '';
+  let data = '';
+  if (isAttachmentReference(block)) data = readAttachmentBase64(block);
+  else if (typeof block.data === 'string') data = block.data;
   if (!data) return null;
   const mimeType =
     String(block.mimeType || block.mediaType || 'application/pdf')
@@ -397,13 +392,10 @@ export function normalizeContentForAnthropic(content) {
       return { type: 'text', text: `[unsupported image content: ${stringifyFallback(part)}]` };
     }
     if (part?.type === 'tool_result') {
-      const nested = Array.isArray(part.content)
-        ? normalizeContentForAnthropic(part.content)
-        : typeof part.content === 'string'
-          ? part.content
-          : part.content == null
-            ? ''
-            : stringifyFallback(part.content);
+      let nested;
+      if (Array.isArray(part.content)) nested = normalizeContentForAnthropic(part.content);
+      else if (typeof part.content === 'string') nested = part.content;
+      else nested = part.content == null ? '' : stringifyFallback(part.content);
       return { ...part, content: nested };
     }
     if (part?.type === 'input_text' || part?.type === 'output_text') {

package/src/runtime/agent/orchestrator/providers/model-cache.mjs

@@ -1,5 +1,5 @@
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 

package/src/runtime/agent/orchestrator/providers/model-catalog-projection.mjs

@@ -23,11 +23,11 @@
  */
 
 // ── models.dev ──────────────────────────────────────────────────────────────
-// Readers: _modelsDevRowToOverride (cost/limit/reasoning/reasoning_options/
+// Readers: _modelsDevMetadata (cost/limit/reasoning/reasoning_options/
 // interleaved.field/tool_call/modalities.input), _applyCodingUnfit
 // (tool_call, modalities.output), _releaseEpoch (release_date),
-// _stalenessFamily (family). `id`/`name` are NOT kept: both call sites pass
-// the model id explicitly, so the row-level copy would only duplicate the key.
+// _stalenessFamily (family). `id` is not kept: callers pass the model id
+// explicitly, so the row-level copy would only duplicate the key.
 const MODELSDEV_COST_FIELDS = ['input', 'output', 'cache_read', 'cache_write', 'tiers', 'context_over_200k'];
 const MODELSDEV_LIMIT_FIELDS = ['context', 'output'];
 const MODELSDEV_MODALITY_FIELDS = ['input', 'output'];
@@ -40,7 +40,8 @@ function pickPresent(source, fields) {
   for (const field of fields) {
     const value = source[field];
     if (value == null) continue;
-    (out ||= {})[field] = value;
+    out ||= {};
+    out[field] = value;
   }
   return out;
 }
@@ -51,7 +52,8 @@ function pickArrays(source, fields) {
   for (const field of fields) {
     const value = source[field];
     if (!Array.isArray(value)) continue;
-    (out ||= {})[field] = value;
+    out ||= {};
+    out[field] = value;
   }
   return out;
 }
@@ -59,8 +61,8 @@ function pickArrays(source, fields) {
 function projectModelsDevRow(row) {
   if (!row || typeof row !== 'object') return null;
   const out = {};
-  // `cost` gates _modelsDevMetadataSync entirely — a row without it yields no
-  // metadata, so an absent cost must stay absent rather than become {}.
+  // An absent cost must stay absent rather than become {}, which would
+  // incorrectly mark models.dev as the row's pricing source.
   const cost = pickPresent(row.cost, MODELSDEV_COST_FIELDS);
   if (cost) out.cost = cost;
   const limit = pickPresent(row.limit, MODELSDEV_LIMIT_FIELDS);