mixdog 1.2.2 → 1.2.3

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

@@ -338,6 +338,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 +386,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,11 +403,12 @@ 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) }] };
@@ -882,6 +905,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 +969,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 +1001,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 +1032,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 +1069,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 +1093,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 +1155,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 +1179,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/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. */

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

@@ -93,6 +93,7 @@ export function inlineModelProxyAttachments(messages, { maxBytes = MODEL_PROXY_I
 export class ModelProxyProvider {
   #channel;
   #modelInfo = new Map();
+  #noWireRoute = new Set();
 
   constructor(name, config = {}, channel = getModelProxyChannel()) {
     this.name = name;
@@ -109,7 +110,7 @@ export class ModelProxyProvider {
   async send(messages, model, tools, sendOpts) {
     const { options, callbacks } = splitModelProxySendOptions(sendOpts);
     const finalized = isFinalizedProviderRequestTools(tools);
-    return this.#call(
+    const result = await this.#call(
       'send',
       {
         model: model ?? null,
@@ -121,6 +122,22 @@ export class ModelProxyProvider {
       },
       { signal: sendOpts?.signal || null, callbacks }
     );
+    // The PC rerouted the wire (a clear "unsupported" refusal) and reports the
+    // route it used: the daemon's own session adopts it, so the next proxied
+    // turn starts on the new wire instead of repeating the refusal.
+    const rerouted = result?.wireReroute;
+    const session = sendOpts?.session;
+    if (
+      rerouted?.source === 'reroute' &&
+      session?.wireRoute &&
+      session.wireRoute.provider === this.name &&
+      session.wireRoute.model === (model ?? null) &&
+      rerouted.provider === this.name &&
+      rerouted.model === session.wireRoute.model
+    ) {
+      session.wireRoute = rerouted;
+    }
+    return result;
   }
 
   #adoptCatalog(catalog) {
@@ -145,6 +162,21 @@ export class ModelProxyProvider {
   getCachedModelInfo(model) {
     return this.#modelInfo.get(String(model ?? '')) ?? null;
   }
+
+  /** The PC adapter's wire route for `model` (its config and roster decide);
+   *  null for a single-wire adapter, which is remembered so every later turn
+   *  skips the round trip. */
+  async resolveWireRoute(model, ctx = {}) {
+    const key = String(model ?? '');
+    if (this.#noWireRoute.has(key)) return null;
+    const route = await this.#call('resolveWireRoute', {
+      model: model ?? null,
+      context: { agent: ctx.agent === true, legacy: ctx.legacy === true },
+    });
+    if (route && typeof route === 'object') return route;
+    this.#noWireRoute.add(key);
+    return null;
+  }
 }
 
 /** A proxy instance whose class carries the PC adapter's usage convention. */

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -252,6 +252,8 @@ function cursorOAuthState() {
       return resolveProbeState(paths, (docs) =>
         docs.some((own) => {
           if (!own?.access_token) return false;
+          // Cursor permanently rejected the refresh token: signed out until a new login.
+          if (own.reauth_required === true) return false;
           const expiresAt = Number(own.expires_at) || 0;
           return expiresAt === 0 || expiresAt > Date.now() || Boolean(own.refresh_token);
         })

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

@@ -101,6 +101,8 @@ function _codexMetadataBase({ poolKey, cacheKey, sendOpts, handshake = false } =
       sendOpts?.codexSessionId ||
         sendOpts?.session?.codexWireSessionId ||
         sendOpts?.session?.codexSessionId ||
+        // A forked transport scope keeps its session's wire identity.
+        (sendOpts?.transportScope ? sendOpts?.sessionId : '') ||
         poolKey ||
         cacheKey
     ) || 'mixdog-session';