mixdog 0.9.174 → 1.0.0

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

@@ -1,4 +1,4 @@
-import { providerNativeToolPrefixCount } from '../../../../../session-runtime/provider-request-tools.mjs';
+import { providerNativeToolPrefixCount } from '../../runtime-core/provider-request-tools.mjs';
 import { actionInputContract } from './action-input-contract.mjs';
 import { isNativeServerToolBlockType } from './anthropic-native-blocks.mjs';
 import { isAnthropicThinkingBlock, sanitizeAnthropicReplayBlocks } from './anthropic-replay-blocks.mjs';
@@ -330,6 +330,10 @@ export function normalizeAnthropicNonStreamingResponse(message, fallbackModel =
   };
 }
 
+// Anthropic's tool spec forbids oneOf / allOf / anyOf at the TOP level of
+// input_schema (nested usage inside properties is allowed). External MCP
+// servers sometimes emit such schemas; convert them to a flat object schema
+// so the API never sees a 400.
 export function sanitizeAnthropicInputSchema(schema, toolName, logTag) {
   if (!schema || typeof schema !== 'object') {
     return { type: 'object', properties: {} };
@@ -407,6 +411,18 @@ function toAnthropicTools(tools, logTag) {
   });
 }
 
+// Map the orchestrator-level opts.toolChoice into Anthropic's tool_choice.
+// Only 'none' is activated: it lets the hard-cap final turn keep the tool
+// DEFINITIONS in-request (so the tools->system->messages prefix — and its
+// prompt-cache prefix — stay byte-identical to prior turns) while forbidding
+// tool USE, so the model can only emit text. Forced values
+// ('required'->{type:'any'}, {name}->{type:'tool'}) are deliberately NOT
+// mapped: Anthropic returns a 400 for any forced tool_choice while
+// extended/adaptive thinking is enabled, and the only caller that sets
+// opts.toolChoice='required' (the forced-first-tool turn) runs with
+// effort/thinking active on reasoning models — activating it would convert a
+// previously-harmless no-op into a hard 400 on exactly that turn. Attached
+// only when the request actually carries tools.
 export function toAnthropicToolChoice(toolChoice) {
   return toolChoice === 'none' ? { type: 'none' } : undefined;
 }
@@ -464,6 +480,19 @@ export function requestAnthropicTools(tools, messages, opts, provider) {
   return [...nativeTools, ...toAnthropicTools([...activeTools, ...deferredTools], provider)];
 }
 
+// Applies cache_control markers to the FINAL, already-sanitized Anthropic
+// message array — by INVARIANT, never by pre-sanitize index. Because
+// sanitizeAnthropicContentPairs has already run (and must NOT run again
+// after this), the blocks we mark here are exactly the blocks the provider
+// sees, so the cache breakpoint is stable across turns.
+//   message-anchor: prefer a safe tool_result tail, then a previous real user
+//                   text turn if another slot remains. Synthetic
+//                   <system-reminder> messages and current pure-text prompts
+//                   are excluded so first-turn prompts do not create a fresh
+//                   BP4 write on every new session.
+// messageTtl === null disables the tail. BP3 (tier3) rides a system block,
+// so it is not marked here. ANTHROPIC_MSG_SLOTS=0 is honoured upstream by
+// passing messageTtl = null.
 export function applyAnthropicCacheMarkers(
   sanitizedMessages,
   { messageTtl = ANTHROPIC_CACHE_TTL_VOLATILE, messageSlots = 1 } = {}

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

@@ -0,0 +1,6 @@
+/**
+ * How an Anthropic stream names its provider in errors (`display`) and stderr
+ * lines (`tag`). The OAuth provider is the default; the API-key provider
+ * passes its own.
+ */
+export const OAUTH_STREAM_LABELS = Object.freeze({ display: 'Anthropic OAuth', tag: 'anthropic-oauth' });

package/src/runtime/agent/orchestrator/providers/lib/anthropic-system-blocks.mjs

@@ -0,0 +1,17 @@
+// System blocks carry their own cache tier; anything else is the default tier.
+const SYSTEM_CACHE_TIERS = new Set(['tier3', 'env']);
+const systemCacheTier = (cacheTier) => (SYSTEM_CACHE_TIERS.has(cacheTier) ? cacheTier : 'system');
+
+/** Non-empty system messages as `{ text, tier }` block items; a non-array yields none. */
+export function systemBlockItems(systemMsgs) {
+  const items = [];
+  for (const m of Array.isArray(systemMsgs) ? systemMsgs : []) {
+    const text = typeof m?.content === 'string' ? m.content.trim() : '';
+    if (text) items.push({ text, tier: systemCacheTier(m?.cacheTier) });
+  }
+  return items;
+}
+/** cacheTier:'env' (volatile session/project environment) is never marked —
+ *  it rides the messages-tail breakpoint; a null TTL leaves the block uncached. */
+export const systemBlockTtl = (tier, { tier3Ttl, systemTtl }) =>
+  ({ tier3: tier3Ttl, env: null, system: systemTtl })[tier];

package/src/runtime/agent/orchestrator/providers/{anthropic-leaked-toolcall.mjs → lib/leaked-toolcall.mjs}

@@ -17,7 +17,7 @@
  * content is ever lost.
  */
 
-import { traceHash, stableTraceStringify } from './trace-utils.mjs';
+import { traceHash, stableTraceStringify } from '../trace-utils.mjs';
 
 // Opener strings (lowercased) used only for partial-tail hold detection —
 // so a sentinel split across text_delta chunk boundaries is still caught.
@@ -347,6 +347,12 @@ export function scanLeakedToolCalls(buffer, { isKnownTool, final, harmony = fals
   return { emit, calls, rest: buf.slice(pos), fenceState: fence };
 }
 
+/** The known tool names as a Set, whatever shape the caller handed in. */
+export function knownToolNameSet(knownToolNames) {
+  if (knownToolNames instanceof Set) return knownToolNames;
+  return new Set(Array.isArray(knownToolNames) ? knownToolNames : []);
+}
+
 /**
  * Stateful convenience wrapper around `scanLeakedToolCalls` for the streaming
  * parsers. Holds the minimal rolling text window across chunk boundaries and
@@ -360,12 +366,6 @@ export function scanLeakedToolCalls(buffer, { isKnownTool, final, harmony = fals
  * @param {boolean} [opts.harmony]  Opt-in gpt-oss/harmony channel detection.
  * @returns {{ enabled:boolean, push:(delta:string, final?:boolean)=>{text:string,calls:Array<{name:string,arguments:object}>}, flush:()=>{text:string,calls:Array<{name:string,arguments:object}>} }}
  */
-/** The known tool names as a Set, whatever shape the caller handed in. */
-export function knownToolNameSet(knownToolNames) {
-  if (knownToolNames instanceof Set) return knownToolNames;
-  return new Set(Array.isArray(knownToolNames) ? knownToolNames : []);
-}
-
 export function createLeakGuard({ knownToolNames, harmony = false } = {}) {
   const known = knownToolNameSet(knownToolNames);
   const enabled = known.size > 0;

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

@@ -14,6 +14,50 @@ export function expiryFromAccessToken(token) {
   return Number.isFinite(exp) && exp > 0 ? exp * 1000 : 0;
 }
 
+// expires_at may arrive as a unix number (seconds or milliseconds) or an
+// ISO-8601 string. Normalize to epoch milliseconds; 0 means unknown.
+export function normalizeExpiresAtMs(value) {
+  if (typeof value === 'string') {
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : 0;
+  }
+  const n = Number(value || 0);
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return n < 1e12 ? n * 1000 : n;
+}
+
+/**
+ * Status record for a stored OAuth credential that has an access token.
+ * `expiresAt` is epoch ms (0 = unknown); `detail` labels the credential source.
+ */
+export function oauthCredentialStatus({ hasRefresh, expiresAt, detail, refreshSkewMs }) {
+  const expired = expiresAt > 0 && expiresAt <= Date.now();
+  const expiring = expiresAt > 0 && expiresAt < Date.now() + refreshSkewMs;
+  if (!hasRefresh) {
+    return {
+      authenticated: expiresAt === 0 || !expired,
+      usable: expiresAt === 0 || !expired,
+      refreshable: false,
+      reauthRequired: expired,
+      status: expired ? 'Reauth Required' : 'Access Only',
+      detail: `${detail}; no refresh token`,
+      expiresAt,
+    };
+  }
+  let status = 'Valid';
+  if (expired) status = 'Refresh Required';
+  else if (expiring) status = 'Refresh Soon';
+  return {
+    authenticated: true,
+    usable: !expired,
+    refreshable: true,
+    reauthRequired: false,
+    status,
+    detail,
+    expiresAt,
+  };
+}
+
 export function scrubOAuthSecrets(text, secretValues = []) {
   let scrubbed = String(text || '')
     .replace(/Bearer [A-Za-z0-9._-]+/gi, 'Bearer [REDACTED]')

package/src/runtime/agent/orchestrator/providers/lib/send-callbacks.mjs

@@ -0,0 +1,12 @@
+const functionOrNull = (value) => (typeof value === 'function' ? value : null);
+
+/** The caller-supplied stream/stage hooks of a send, each a function or null. */
+export function streamCallbacks(opts) {
+  return {
+    onStageChange: functionOrNull(opts.onStageChange),
+    onStreamDelta: functionOrNull(opts.onStreamDelta),
+    onToolCall: functionOrNull(opts.onToolCall),
+    onTextDelta: functionOrNull(opts.onTextDelta),
+    onTextReset: functionOrNull(opts.onTextReset),
+  };
+}

package/src/runtime/agent/orchestrator/providers/lib/sse-framing.mjs

@@ -9,12 +9,13 @@
  * the event loop and inside the provider stream worker (a worker failure can
  * therefore always be re-run inline with identical results).
  *
- * Framing rules are byte-identical to the previous inline Anthropic loop:
+ * Framing rules:
  *   - `:`-prefixed lines are comment/keepalive frames and are dropped.
  *   - blank lines are record separators and are dropped.
- *   - `event: ` sets the current event name, which persists (across chunks)
- *     until the next `event: ` line.
- *   - `data: ` payloads are trimmed; empty payloads are dropped.
+ *   - `event:` sets the current event name, which persists (across chunks)
+ *     until the next `event:` line.
+ *   - `data:` payloads are trimmed; empty payloads are dropped. The space
+ *     after the colon is optional (`data:{}` and `data: {}` are equal).
  *   - any other line is ignored.
  * CRLF transports behave as before: the trailing `\r` is removed by trim() on
  * the value lines, and a bare `\r` line matches no prefix and is ignored.
@@ -50,12 +51,12 @@ export function frameSseRegion(text, currentEvent = '') {
     index = end + 1;
     if (end === start) continue; // record separator
     if (text.charCodeAt(start) === COLON_CODE) continue; // comment / ping keepalive
-    if (text.startsWith('event: ', start)) {
-      name = text.slice(start + 7, end).trim();
+    if (text.startsWith('event:', start)) {
+      name = text.slice(start + 6, end).trim();
       continue;
     }
-    if (!text.startsWith('data: ', start)) continue;
-    const data = text.slice(start + 6, end).trim();
+    if (!text.startsWith('data:', start)) continue;
+    const data = text.slice(start + 5, end).trim();
     if (!data) continue;
     frames.push({ name, data });
   }

package/src/runtime/agent/orchestrator/providers/lib/transport-fallback-trace.mjs

@@ -0,0 +1,25 @@
+import { appendAgentTrace } from '../../agent-trace.mjs';
+
+/** Best-effort trace of a dead stream re-issued as a non-streaming request. */
+export function traceNonStreamingFallback({ provider, model, opts, streamErr }) {
+  try {
+    appendAgentTrace({
+      sessionId: opts?.sessionId || opts?.session?.id || null,
+      iteration: Number.isFinite(Number(opts?.iteration)) ? Number(opts.iteration) : null,
+      kind: 'transport_fallback',
+      provider,
+      model,
+      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 */
+  }
+}

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

@@ -1,181 +1 @@
-/**
- * Memory-resident shape of the overlay catalogs.
- *
- * The published catalogs are large: models.dev ships 211 providers / 7,488
- * models (4.2MB on disk) and LiteLLM 3,408 rows (1.4MB), and both carry prose
- * and metadata no lookup in model-catalog.mjs ever reads — `description`
- * alone dominates the models.dev payload. Holding the parsed originals
- * resident measured 21.4MB of heap in every process that loads them, for a
- * useful surface of about a dozen fields.
- *
- * So a row is narrowed to exactly the fields its readers touch the moment it
- * arrives, and the parsed original becomes garbage. Nested values that survive
- * (arrays, strings) are kept BY REFERENCE: the original container is
- * unreachable either way, so copying them would only duplicate live bytes.
- *
- * Disk caches keep the FULL payload. A projection is a memory shape, not a
- * storage format, so widening it later never forces a refetch — the next warm
- * simply reads more fields out of the file already on disk.
- *
- * Every field below is here because a reader exists for it; the reader is
- * named beside it. Adding a field without a reader re-grows the very cost this
- * module exists to remove.
- */
-
-// ── models.dev ──────────────────────────────────────────────────────────────
-// Readers: _modelsDevMetadata (cost/limit/reasoning/reasoning_options/
-// interleaved.field/tool_call/modalities.input), _applyCodingUnfit
-// (tool_call, modalities.output), _releaseEpoch (release_date),
-// _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'];
-
-/** Copy the listed keys when present. Returns undefined when none survive, so
- *  callers can drop the container entirely rather than store an empty object. */
-function pickPresent(source, fields) {
-  if (!source || typeof source !== 'object') return undefined;
-  let out;
-  for (const field of fields) {
-    const value = source[field];
-    if (value == null) continue;
-    out ||= {};
-    out[field] = value;
-  }
-  return out;
-}
-
-function pickArrays(source, fields) {
-  if (!source || typeof source !== 'object') return undefined;
-  let out;
-  for (const field of fields) {
-    const value = source[field];
-    if (!Array.isArray(value)) continue;
-    out ||= {};
-    out[field] = value;
-  }
-  return out;
-}
-
-function projectModelsDevRow(row) {
-  if (!row || typeof row !== 'object') return null;
-  const out = {};
-  // 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);
-  if (limit) out.limit = limit;
-  const modalities = pickArrays(row.modalities, MODELSDEV_MODALITY_FIELDS);
-  if (modalities) out.modalities = modalities;
-  if (row.reasoning === true) out.reasoning = true;
-  if (Array.isArray(row.reasoning_options) && row.reasoning_options.length > 0) {
-    out.reasoning_options = row.reasoning_options;
-  }
-  const interleavedField = row.interleaved?.field;
-  if (interleavedField) out.interleaved = { field: interleavedField };
-  // tool_call is read as an explicit `=== false` drop signal, so the
-  // distinction between false and absent must survive.
-  if (typeof row.tool_call === 'boolean') out.tool_call = row.tool_call;
-  if (typeof row.family === 'string' && row.family) out.family = row.family;
-  if (typeof row.release_date === 'string' && row.release_date) out.release_date = row.release_date;
-  // Reader: opencode-go.mjs openCodeGoWireApi — models.dev names the SDK
-  // package a gateway model speaks (@ai-sdk/openai = Responses API,
-  // @ai-sdk/anthropic = Messages API, absent = chat/completions).
-  const npm = row.provider?.npm;
-  if (typeof npm === 'string' && npm) out.npm = npm;
-  // Reader: enrichModels (display label for gateway ids the id-based
-  // formatter cannot title, e.g. kimi-k2.7-code → "Kimi K2.7 Code").
-  if (typeof row.name === 'string' && row.name) out.name = row.name;
-  return out;
-}
-
-/**
- * Narrow a models.dev catalog to `{ [providerId]: { models } }`.
- * Providers without a models map are dropped: every lookup path reaches rows
- * through `.models`, so such an entry can never answer one.
- */
-export function projectModelsDevCatalog(data) {
-  if (!data || typeof data !== 'object') return data;
-  const out = {};
-  for (const [providerId, provider] of Object.entries(data)) {
-    const models = provider?.models;
-    if (!models || typeof models !== 'object') continue;
-    const projected = {};
-    for (const [modelId, row] of Object.entries(models)) {
-      const projectedRow = projectModelsDevRow(row);
-      if (projectedRow) projected[modelId] = projectedRow;
-    }
-    out[providerId] = { models: projected };
-  }
-  return out;
-}
-
-// ── LiteLLM ─────────────────────────────────────────────────────────────────
-// Readers: _normalize (limits, costs, capability flags, reasoning fields,
-// mode) and the provider guard in getModelMetadataSync / enrichModels
-// (litellm_provider).
-const LITELLM_NUMBER_FIELDS = [
-  'max_input_tokens',
-  'max_tokens',
-  'max_output_tokens',
-  'input_cost_per_token',
-  'output_cost_per_token',
-  'cache_read_input_token_cost',
-  'cache_creation_input_token_cost',
-];
-// _normalize tests each of these with `=== true`, so only a true value carries
-// information; anything else is indistinguishable from absent.
-const LITELLM_FLAG_FIELDS = [
-  'supports_vision',
-  'supports_function_calling',
-  'supports_web_search',
-  'supports_websearch',
-  'supports_prompt_caching',
-  'supports_reasoning',
-];
-const LITELLM_STRING_FIELDS = ['mode', 'litellm_provider', 'reasoning_content_field'];
-
-function projectLitellmRow(row) {
-  if (!row || typeof row !== 'object') return null;
-  const out = {};
-  for (const field of LITELLM_NUMBER_FIELDS) {
-    const value = row[field];
-    if (typeof value === 'number' && Number.isFinite(value)) out[field] = value;
-  }
-  // Preserve the published context-rate columns, not just the base price.
-  for (const [field, value] of Object.entries(row)) {
-    if (
-      /^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)_above_\d+k_tokens$/.test(
-        field
-      ) &&
-      typeof value === 'number' &&
-      Number.isFinite(value)
-    )
-      out[field] = value;
-  }
-  for (const field of LITELLM_FLAG_FIELDS) {
-    if (row[field] === true) out[field] = true;
-  }
-  for (const field of LITELLM_STRING_FIELDS) {
-    const value = row[field];
-    if (typeof value === 'string' && value) out[field] = value;
-  }
-  if (Array.isArray(row.reasoning_options) && row.reasoning_options.length > 0) {
-    out.reasoning_options = row.reasoning_options;
-  }
-  return out;
-}
-
-/** Narrow a LiteLLM catalog in place of its parsed original. Keys are the
- *  lookup surface and are preserved exactly; only row shape narrows. */
-export function projectLitellmCatalog(data) {
-  if (!data || typeof data !== 'object') return data;
-  const out = {};
-  for (const [key, row] of Object.entries(data)) {
-    const projectedRow = projectLitellmRow(row);
-    if (projectedRow) out[key] = projectedRow;
-  }
-  return out;
-}
+export * from '../../../shared/llm/model-catalog-projection.mjs';