mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/providers/lib/wire-pairing.mjs

@@ -25,10 +25,21 @@ function isObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+// A server-executed tool search (execution:'server', or call_id null) is
+// answered by the server inside the same response. It is never a client call
+// awaiting a client output, so the guard neither pairs nor synthesizes it.
+function isServerToolSearch(item) {
+  return (
+    (item.type === 'tool_search_call' || item.type === 'tool_search_output') &&
+    (item.execution === 'server' || item.call_id === null)
+  );
+}
+
 function responsesCallId(item) {
   if (!isObject(item)) return null;
   if (item.type !== 'function_call' && item.type !== 'custom_tool_call' && item.type !== 'tool_search_call')
     return null;
+  if (isServerToolSearch(item)) return null;
   const id = item.call_id || item.id || '';
   return typeof id === 'string' && id ? id : null;
 }
@@ -41,6 +52,7 @@ function responsesOutputId(item) {
     item.type !== 'tool_search_output'
   )
     return null;
+  if (isServerToolSearch(item)) return null;
   const id = item.call_id || item.id || '';
   return typeof id === 'string' && id ? id : null;
 }
@@ -50,7 +62,6 @@ function syntheticResponsesOutput(call) {
     return {
       type: 'custom_tool_call_output',
       call_id: call.call_id || call.id || '',
-      ...(typeof call.name === 'string' && call.name ? { name: call.name } : {}),
       output: WIRE_PAIRING_STUB,
     };
   }
@@ -117,33 +128,50 @@ function chatResultId(message) {
 }
 
 /**
- * Ensure every chat assistant `tool_calls` entry has a following tool
- * message. Returns the original array when already paired, otherwise a new
- * array with synthetic tool messages inserted right after their assistant
- * message (providers require the results to follow the call message).
+ * Ensure every chat assistant `tool_calls` entry is answered by a tool
+ * message in the run immediately following that assistant message (OpenAI
+ * function calling / Meta chat contract), and that no tool message exists
+ * anywhere else. A result after an intervening user/assistant message, or one
+ * answering another occurrence of the same id, does not pair the call; the
+ * call gets a synthetic stub right after its assistant message and the
+ * misplaced tool message is DROPPED (Chat Completions rejects a tool message
+ * that does not follow its tool_calls block; a late result is not relocated).
+ * Within the run, results for ids the block did not call and repeated results
+ * for one id are dropped too. Returns the original array when already valid.
  */
 export function ensureChatToolPairs(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
-  const resultIds = new Set();
-  for (const message of messages) {
-    const id = chatResultId(message);
-    if (id) resultIds.add(id);
-  }
-  let missing = 0;
-  for (const message of messages) {
-    for (const id of chatToolCallIds(message)) {
-      if (!resultIds.has(id)) missing += 1;
-    }
-  }
-  if (missing === 0) return messages;
   const out = [];
-  for (const message of messages) {
+  let changed = false;
+  for (let i = 0; i < messages.length; i += 1) {
+    const message = messages[i];
+    if (isObject(message) && message.role === 'tool') {
+      changed = true;
+      continue;
+    }
     out.push(message);
-    for (const id of chatToolCallIds(message)) {
-      if (resultIds.has(id)) continue;
+    const callIds = chatToolCallIds(message);
+    if (!callIds.length) continue;
+    let end = i + 1;
+    while (end < messages.length && isObject(messages[end]) && messages[end].role === 'tool') end += 1;
+    const answered = new Set();
+    const kept = [];
+    for (const result of messages.slice(i + 1, end)) {
+      const id = chatResultId(result);
+      if (id && callIds.includes(id) && !answered.has(id)) {
+        answered.add(id);
+        kept.push(result);
+      } else {
+        changed = true;
+      }
+    }
+    for (const id of callIds) {
+      if (answered.has(id)) continue;
+      changed = true;
       out.push({ role: 'tool', tool_call_id: id, content: WIRE_PAIRING_STUB });
-      resultIds.add(id);
     }
+    out.push(...kept);
+    i = end - 1;
   }
-  return out;
+  return changed ? out : messages;
 }

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

@@ -167,7 +167,11 @@ function officeTextForFile(file) {
     });
   if (file.ref) return memoized(officeTextMemo, `ref:${file.ref}\0${file.filename || ''}`, compute);
   if (file.part && inlineOfficeText.has(file.part)) return inlineOfficeText.get(file.part);
-  const key = createHash('sha256').update(file.filename || '').update('\0').update(file.data).digest('hex');
+  const key = createHash('sha256')
+    .update(file.filename || '')
+    .update('\0')
+    .update(file.data)
+    .digest('hex');
   const text = memoized(officeTextMemo, key, compute);
   if (file.part) inlineOfficeText.set(file.part, text);
   return text;
@@ -338,6 +342,24 @@ export function degradeMediaParts(parts) {
   return changed ? next : parts;
 }
 
+// The text of a document whose source is not base64 bytes: a text source is
+// its data, a content source its text blocks. A url / file-id source has no
+// bytes to read, so the request is rejected rather than silently dropped.
+function documentSourceText(part) {
+  const source = part.source;
+  let text = null;
+  if (part.type === 'document' && source?.type === 'text' && typeof source.data === 'string') text = source.data;
+  else if (part.type === 'document' && source?.type === 'content') {
+    text = contentToText(source.content, '');
+  }
+  if (text === null) {
+    const kind = part.type === 'document' ? `${source?.type || 'unknown'} source` : 'format';
+    throw new TypeError(`This provider accepts no document blocks and cannot read a document with a ${kind}.`);
+  }
+  const title = typeof part.title === 'string' && part.title ? part.title : '';
+  return title ? `--- ${title} ---\n${text}` : text;
+}
+
 function replacePdfParts(content, texts) {
   if (Array.isArray(content)) {
     let changed = false;
@@ -368,8 +390,12 @@ function replacePdfParts(content, texts) {
  * read error or a pdf.js environment failure propagates and nothing is cached.
  */
 export async function preparePdfTextForProvider(messages, provider) {
-  if (providerTakesNativePdf(provider) || !Array.isArray(messages)) return messages;
+  // A provider that declares `nativeDocuments === false` takes no document
+  // block of any kind: every document variant becomes text (or is rejected).
+  const noDocuments = provider?.nativeDocuments === false;
+  if ((providerTakesNativePdf(provider) && !noDocuments) || !Array.isArray(messages)) return messages;
   const found = [];
+  const texts = new Map();
   for (const message of messages) {
     for (const part of walkContentParts(message?.content)) {
       if (part.type !== 'file' && part.type !== 'document') continue;
@@ -381,14 +407,19 @@ export async function preparePdfTextForProvider(messages, provider) {
         continue;
       }
       if (file && fileKind(file) === 'pdf') found.push({ part, file });
+      else if (noDocuments && (file || part.type === 'document'))
+        texts.set(part, file ? textFormOfFilePart(part) : documentSourceText(part));
     }
   }
-  if (!found.length) return messages;
+  if (!found.length && !texts.size) return messages;
   const extracted = await Promise.all(found.map(({ file }) => pdfTextFor(file)));
-  const texts = new Map(found.map(({ part, file }, i) => [part, `--- ${fileLabel(file)} ---\n${extracted[i]}`]));
+  found.forEach(({ part, file }, i) => {
+    texts.set(part, `--- ${fileLabel(file)} ---\n${extracted[i]}`);
+  });
   return messages.map((message) => {
     // A message whose content is one bare part becomes a one-part array.
-    if (texts.has(message?.content)) return { ...message, content: [{ type: 'text', text: texts.get(message.content) }] };
+    if (texts.has(message?.content))
+      return { ...message, content: [{ type: 'text', text: texts.get(message.content) }] };
     const content = replacePdfParts(message?.content, texts);
     return content === message?.content ? message : { ...message, content };
   });
@@ -658,7 +689,10 @@ export function contentMediaBytes(content, { nativePdf = true } = {}) {
     if (!part || typeof part !== 'object') continue;
     if (isAttachmentReference(part)) {
       if (part.type === 'image') bytes += Math.ceil((Number(part.sizeBytes) || 0) / 3) * 4;
-      else if (part.type === 'file' && countsAsMedia(String(part.mimeType || part.mediaType || 'application/pdf'), '')) {
+      else if (
+        part.type === 'file' &&
+        countsAsMedia(String(part.mimeType || part.mediaType || 'application/pdf'), '')
+      ) {
         bytes += Math.ceil((Number(part.sizeBytes) || 0) / 3) * 4;
       }
       continue;
@@ -882,6 +916,11 @@ function normalizeAnthropicPart(part) {
     } else {
       out = { type: 'text', text: fileFallbackText(file, kind) };
     }
+    // Citation settings and the model-only context belong to the document block.
+    if (out.type === 'document') {
+      if (part.citations) out.citations = part.citations;
+      if (part.context) out.context = part.context;
+    }
     if (part.cache_control) out.cache_control = part.cache_control;
     return out;
   }
@@ -941,7 +980,12 @@ function normalizeAnthropicPart(part) {
 // `nativePdf: false` marks a provider that takes a PDF as text: its PDFs were
 // converted by preparePdfTextForProvider, so a PDF part reaching these
 // normalizers is an error rather than a file block the provider cannot read.
-export function normalizeContentForOpenAIChat(content, { role = 'user', nativePdf = true } = {}) {
+//
+// `cacheControl: true` is a capability the caller grants to a gateway that
+// accepts Anthropic-style cache directives on text blocks (OpenRouter): text
+// parts keep their `cache_control`, and multipart system content stays an
+// array instead of being flattened. Off by default.
+export function normalizeContentForOpenAIChat(content, { role = 'user', nativePdf = true, cacheControl = false } = {}) {
   const parts = contentParts(content);
   if (!parts) return content;
   const out = [];
@@ -968,22 +1012,29 @@ export function normalizeContentForOpenAIChat(content, { role = 'user', nativePd
       }
       const fileUri = imageFileUriFromPart(part);
       if (fileUri) {
-        out.push({ type: 'image_url', image_url: { url: fileUri.fileUri } });
+        out.push({ type: 'image_url', image_url: { url: fileUri.fileUri, ...imageDetailField(part) } });
         continue;
       }
       const url = imageUrlFromPart(part);
       if (url) {
-        out.push({ type: 'image_url', image_url: { url } });
+        out.push({ type: 'image_url', image_url: { url, ...imageDetailField(part) } });
         continue;
       }
       const text = jsonFallbackFromPart(part, nativePdf);
-      if (text) out.push({ type: 'text', text });
+      if (text) {
+        const cache = cacheControl && part?.cache_control ? { cache_control: part.cache_control } : {};
+        out.push({ type: 'text', text, ...cache });
+      }
     } catch (error) {
       const unavailable = unavailableAttachmentText(part, error);
       if (unavailable === null) throw error;
       out.push({ type: 'text', text: unavailable });
     }
   }
+  if (cacheControl && role === 'system') {
+    const blocks = out.filter((part) => part.type === 'text' && part.text);
+    if (blocks.length > 1 || blocks.some((part) => part.cache_control)) return blocks;
+  }
   if (role !== 'user')
     return out
       .map((part) => part.text || '')
@@ -992,6 +1043,15 @@ export function normalizeContentForOpenAIChat(content, { role = 'user', nativePd
   return out.length ? out : contentToText(content, '');
 }
 
+const RESPONSES_IMAGE_DETAILS = new Set(['low', 'high', 'auto', 'original']);
+
+// A caller-supplied image detail rides through; an unknown value is left out.
+function imageDetailField(part) {
+  const raw = part.detail ?? part.image_url?.detail ?? part.source?.detail;
+  const detail = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+  return RESPONSES_IMAGE_DETAILS.has(detail) ? { detail } : {};
+}
+
 export function normalizeContentForOpenAIResponses(content, { role = 'user', nativePdf = true } = {}) {
   const textType = role === 'assistant' ? 'output_text' : 'input_text';
   if (typeof content === 'string') return content ? [{ type: textType, text: content }] : [];
@@ -1020,17 +1080,17 @@ export function normalizeContentForOpenAIResponses(content, { role = 'user', nat
       }
       const fileId = imageFileIdFromPart(part);
       if (fileId) {
-        out.push({ type: 'input_image', file_id: fileId });
+        out.push({ type: 'input_image', file_id: fileId, ...imageDetailField(part) });
         continue;
       }
       const fileUri = imageFileUriFromPart(part);
       if (fileUri) {
-        out.push({ type: 'input_image', image_url: fileUri.fileUri });
+        out.push({ type: 'input_image', image_url: fileUri.fileUri, ...imageDetailField(part) });
         continue;
       }
       const url = imageUrlFromPart(part);
       if (url) {
-        out.push({ type: 'input_image', image_url: url });
+        out.push({ type: 'input_image', image_url: url, ...imageDetailField(part) });
         continue;
       }
       const text = jsonFallbackFromPart(part, nativePdf);
@@ -1044,6 +1104,58 @@ export function normalizeContentForOpenAIResponses(content, { role = 'user', nat
   return out;
 }
 
+// Image types the Gemini API documents; an extension outside this map yields
+// no MIME type at all (FileData.mimeType is optional) instead of a guess.
+const GEMINI_IMAGE_EXTENSION_MIME = {
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  webp: 'image/webp',
+  heic: 'image/heic',
+  heif: 'image/heif',
+};
+
+function mimeFromImageUrl(url) {
+  let pathname = '';
+  try {
+    pathname = new URL(url).pathname;
+  } catch {
+    return undefined;
+  }
+  const ext = /\.([a-z0-9]+)$/i.exec(pathname)?.[1]?.toLowerCase();
+  return ext ? GEMINI_IMAGE_EXTENSION_MIME[ext] : undefined;
+}
+
+function trimmedMime(value) {
+  const mime = typeof value === 'string' ? value.trim().toLowerCase() : '';
+  return mime || undefined;
+}
+
+// Part-level metadata the Gemini API accepts beside inlineData/fileData.
+/** Supported Gemini part metadata (mediaResolution, videoMetadata) a caller put on `part`, camelCased. */
+export function geminiPartMetadata(part) {
+  const out = {};
+  if (!part || typeof part !== 'object') return out;
+  const mediaResolution = part.mediaResolution ?? part.media_resolution;
+  if (mediaResolution !== undefined && mediaResolution !== null) out.mediaResolution = mediaResolution;
+  const videoMetadata = part.videoMetadata ?? part.video_metadata;
+  if (videoMetadata !== undefined && videoMetadata !== null) out.videoMetadata = videoMetadata;
+  return out;
+}
+
+// FileData for an external URI: the MIME type comes from the part's own
+// declaration, else the URL's extension, else it is omitted.
+function geminiFileDataInfo(part, url) {
+  const fileData = part?.fileData || part?.file_data;
+  const declared = fileData
+    ? fileData.mimeType || fileData.mime_type || fileData.mediaType || fileData.media_type
+    : part?.mime_type || part?.mimeType || part?.media_type || part?.mediaType;
+  const fileUri = fileData?.fileUri || fileData?.file_uri || (part?.type === 'image' && part.uri) || url;
+  if (typeof fileUri !== 'string' || !fileUri) return null;
+  const mimeType = trimmedMime(declared) || trimmedMime(part?.image_url?.mime_type) || mimeFromImageUrl(fileUri);
+  return { fileUri, ...(mimeType ? { mimeType } : {}) };
+}
+
 export function normalizeContentForGeminiParts(content) {
   if (typeof content === 'string') return content ? [{ text: content }] : [];
   const parts = contentParts(content);
@@ -1054,21 +1166,21 @@ export function normalizeContentForGeminiParts(content) {
   const out = [];
   for (const part of parts) {
     try {
+      const meta = geminiPartMetadata(part);
       const file = fileInfo(part);
       if (file) {
         const kind = fileKind(file);
-        if (kind === 'pdf') out.push({ inlineData: { mimeType: 'application/pdf', data: file.data } });
+        if (kind === 'pdf') out.push({ inlineData: { mimeType: 'application/pdf', data: file.data }, ...meta });
         else out.push({ text: fileFallbackText(file, kind) });
         continue;
       }
       const inlineInfo = geminiInlineInfo(part);
       if (inlineInfo) {
-        out.push({ inlineData: { mimeType: inlineInfo.mimeType, data: inlineInfo.data } });
+        out.push({ inlineData: { mimeType: inlineInfo.mimeType, data: inlineInfo.data }, ...meta });
         continue;
       }
-      const fileUri = imageFileUriFromPart(part);
-      if (fileUri) {
-        out.push({ fileData: { mimeType: fileUri.mimeType, fileUri: fileUri.fileUri } });
+      if (imageFileUriFromPart(part)) {
+        out.push({ fileData: geminiFileDataInfo(part), ...meta });
         continue;
       }
       const fileId = imageFileIdFromPart(part);
@@ -1078,17 +1190,17 @@ export function normalizeContentForGeminiParts(content) {
       }
       const info = imageInfo(part);
       if (info) {
-        out.push({ inlineData: { mimeType: info.mimeType, data: info.data } });
+        out.push({ inlineData: { mimeType: info.mimeType, data: info.data }, ...meta });
         continue;
       }
       const url = imageUrlFromPart(part);
       const dataUrlInfo = imageInfoFromDataUrl(url);
       if (dataUrlInfo) {
-        out.push({ inlineData: { mimeType: dataUrlInfo.mimeType, data: dataUrlInfo.data } });
+        out.push({ inlineData: { mimeType: dataUrlInfo.mimeType, data: dataUrlInfo.data }, ...meta });
         continue;
       }
       if (url && !url.startsWith('data:')) {
-        out.push({ fileData: { mimeType: DEFAULT_IMAGE_MIME, fileUri: url } });
+        out.push({ fileData: geminiFileDataInfo(part, url), ...meta });
         continue;
       }
       const text = jsonFallbackFromPart(part);

package/src/runtime/agent/orchestrator/providers/mimo-oauth-profile.mjs

@@ -11,6 +11,7 @@ import { MIMO_SEED_MODELS, mimoSeedRow as seedRow } from '../../../shared/llm/pr
 const MIMO_EFFORT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high']);
 const MIMO_DEFAULT_TEMPERATURE = 1.0;
 const MIMO_DEFAULT_MAX_OUTPUT_TOKENS = 128_000;
+const MIMO_MAX_OUTPUT_TOKENS = 131_072;
 // Slow reasoning can stay silent for minutes: wait for the first byte as long
 // as the agent stall watchdog allows, and tolerate long gaps between events.
 export const MIMO_FIRST_BYTE_TIMEOUT_MS = Math.min(300_000, PROVIDER_MAX_BEFORE_WARN_MS);
@@ -79,12 +80,6 @@ function thinkingDisabled(thinking, effort) {
   return thinking === false || mode === 'disabled' || mode === 'off' || mode === 'none' || effort === 'none';
 }
 
-function namedToolChoice(choice) {
-  if (!choice || typeof choice !== 'object') return null;
-  const name = choice.function?.name || choice.name;
-  return typeof name === 'string' && name ? name : null;
-}
-
 function applyMimoParams(params, { opts = {}, config = {}, modelInfo = null } = {}) {
   const temperature = Number(opts.temperature);
   params.temperature = Number.isFinite(temperature) && temperature >= 0 ? temperature : MIMO_DEFAULT_TEMPERATURE;
@@ -97,9 +92,12 @@ function applyMimoParams(params, { opts = {}, config = {}, modelInfo = null } =
     if ((opts[key] ?? config?.[key]) != null && Number.isFinite(value) && value >= 0) params[wire] = value;
   }
 
+  // MiMo's output limit is `max_completion_tokens` (visible + reasoning
+  // tokens, 1..131072); it documents no `max_tokens`.
   const limit = Number(modelInfo?.outputTokens);
-  const requested = params.max_tokens || MIMO_DEFAULT_MAX_OUTPUT_TOKENS;
-  params.max_tokens = Number.isFinite(limit) && limit > 0 ? Math.min(requested, limit) : requested;
+  const requested = Math.min(params.max_tokens || MIMO_DEFAULT_MAX_OUTPUT_TOKENS, MIMO_MAX_OUTPUT_TOKENS);
+  delete params.max_tokens;
+  params.max_completion_tokens = Number.isFinite(limit) && limit > 0 ? Math.min(requested, limit) : requested;
 
   const thinking = opts.thinking ?? config?.thinking;
   const rawEffort = opts.effort ?? config?.reasoningEffort;
@@ -114,13 +112,11 @@ function applyMimoParams(params, { opts = {}, config = {}, modelInfo = null } =
     if (level) params.reasoning_effort = level;
   }
 
-  if (params.tools?.length) {
-    if (opts.toolChoice === 'required') params.tool_choice = 'required';
-    else {
-      const name = namedToolChoice(opts.toolChoice);
-      if (name) params.tool_choice = { type: 'function', function: { name } };
-    }
-  }
+  // MiMo documents `tool_choice: auto` only: any other value is dropped by the
+  // backend and the call behaves as auto. `none` is honored by sending no tools
+  // at all; `required` / a named tool cannot be forced, so nothing is sent.
+  if (params.tool_choice === 'none') delete params.tools;
+  delete params.tool_choice;
   return params;
 }
 
@@ -178,6 +174,8 @@ function refineMimoError(err) {
 
 export const MIMO_CHAT_PROFILE = Object.freeze({
   replaysReasoningContent: true,
+  // MiMo documents the `developer` role next to system.
+  developerRole: true,
   firstByteTimeoutMs: MIMO_FIRST_BYTE_TIMEOUT_MS,
   semanticIdleTimeoutMs: MIMO_SEMANTIC_IDLE_TIMEOUT_MS,
   resolveModelInfo: (provider, model) => provider.getCachedModelInfo(model) || seedRow(model),

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

@@ -9,7 +9,7 @@
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { fileMtimeMs, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
-import { COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
+import { COMPAT_RETRY_POLICY, compatFirstResponseBudget } from './openai-compat-retry-profile.mjs';
 import { fetchCompatModelItems, listCompatModels } from './openai-compat-models.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import {
@@ -152,6 +152,12 @@ export class MimoOAuthProvider {
     return this.tokens;
   }
 
+  // The inner client's chat profile sets a longer first-byte window; the
+  // budget needs no credentials, so it is read from the profile directly.
+  firstResponseBudget() {
+    return compatFirstResponseBudget(this.name, MIMO_CHAT_PROFILE);
+  }
+
   _ensureInner() {
     const { apiKey, baseUrl } = this.ensureAuth();
     const key = `${baseUrl}:${apiKey}`;

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.d.mts

@@ -5,7 +5,7 @@ export const MODEL_PROXY_OPERATIONS: Readonly<{
   resolve: 'modelProxyResolve';
   heartbeat: 'modelProxyHeartbeat';
 }>;
-export type ModelProxyMethod = 'send' | 'listModels' | 'refreshModels' | 'isAvailable' | 'providerConfig';
+export type ModelProxyMethod = 'send' | 'listModels' | 'refreshModels' | 'isAvailable' | 'resolveWireRoute' | 'providerConfig';
 export const MODEL_PROXY_METHODS: ReadonlyArray<ModelProxyMethod>;
 export const MODEL_PROXY_HEARTBEAT_MS: number;
 export const MODEL_PROXY_LEASE_MS: number;

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.mjs

@@ -34,6 +34,7 @@ export const MODEL_PROXY_METHODS = Object.freeze([
   'listModels',
   'refreshModels',
   'isAvailable',
+  'resolveWireRoute',
   'providerConfig',
 ]);
 /** PC heartbeat cadence while it runs calls; well inside the lease. */