mixdog 0.9.170 → 0.9.172

package/src/runtime/agent/orchestrator/providers/cursor-wire-normalization.mjs

@@ -8,13 +8,62 @@ export const FALLBACK_MODELS = [
   { id: 'grok-4.6-high', name: 'Grok 4.6', reasoning: true, contextWindow: 128_000 },
 ];
 
-export const AUTO_MODEL = {
+const AUTO_MODEL = {
   id: 'auto',
   name: 'Auto',
   reasoning: false,
   contextWindow: 200_000,
 };
 
+export function isCursorAutoModelId(id) {
+  const value = String(id || '')
+    .trim()
+    .toLowerCase();
+  return value === 'auto' || value === 'default';
+}
+
+export function canonicalCursorModelId(id) {
+  const value = String(id || '').trim();
+  return isCursorAutoModelId(value) ? 'auto' : value;
+}
+
+function autoModelRank(model) {
+  return (
+    (Array.isArray(model?.parameterDefinitions) && model.parameterDefinitions.length ? 2 : 0) +
+    (model?.supportsMaxMode === true || model?.supportsNonMaxMode === true || Number(model?.maxContextWindow) > 0
+      ? 1
+      : 0)
+  );
+}
+
+// Cursor still ships Auto as both `auto` and `default`. The picker shows the
+// display name, so those two rows look identical unless we fold them first.
+export function withCanonicalAutoModels(models) {
+  const others = [];
+  let auto = null;
+  for (const model of models || []) {
+    if (isCursorAutoModelId(model?.id)) {
+      const aliases = [
+        ...new Set(
+          [...(Array.isArray(model.aliases) ? model.aliases : []), model.id]
+            .map((value) => String(value || '').trim())
+            .filter((value) => value && value !== 'auto')
+        ),
+      ];
+      const next = {
+        ...model,
+        id: 'auto',
+        name: model.name || AUTO_MODEL.name,
+        ...(aliases.length ? { aliases } : {}),
+      };
+      if (!auto || autoModelRank(next) >= autoModelRank(auto)) auto = next;
+      continue;
+    }
+    others.push(model);
+  }
+  return [auto || AUTO_MODEL, ...others];
+}
+
 export function isCursorEffortParameterId(id) {
   const key = String(id || '')
     .trim()
@@ -25,12 +74,15 @@ export function isCursorEffortParameterId(id) {
 export function normalizeModels(models) {
   const byId = new Map();
   for (const model of models || []) {
-    const id = String(model.modelId || '').trim();
-    if (!id) continue;
+    const rawId = String(model.modelId || '').trim();
+    if (!rawId) continue;
+    const id = canonicalCursorModelId(rawId);
     const aliases = Array.isArray(model.aliases) ? model.aliases : [];
     byId.set(id, {
       id,
-      name: model.displayName || model.displayNameShort || model.displayModelId || aliases[0] || id,
+      name: isCursorAutoModelId(rawId)
+        ? 'Auto'
+        : model.displayName || model.displayNameShort || model.displayModelId || aliases[0] || id,
       reasoning: Boolean(model.thinkingDetails),
       contextWindow: 200_000,
     });
@@ -38,57 +90,80 @@ export function normalizeModels(models) {
   return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
 }
 
+function parameterValueLabel(raw, isBoolean) {
+  if (!isBoolean) return raw;
+  const text = String(raw);
+  if (text === 'true') return 'On';
+  if (text === 'false') return 'Off';
+  return raw;
+}
+
+function parameterDefinitionsOf(model) {
+  return (model.parameterDefinitions || [])
+    .map((definition) => {
+      const booleanValues = definition.parameterType?.booleanParameter?.values || [];
+      const enumValues = definition.parameterType?.enumParameter?.values || [];
+      const values = [...booleanValues, ...enumValues]
+        .filter((value) => value?.blockedByAdminAllowlist !== true && String(value?.value || '').trim())
+        .map((value) => ({
+          value: String(value.value),
+          label: String(value.displayName || parameterValueLabel(value.value, booleanValues.length > 0)),
+          ...(value.markdownTooltip ? { description: value.markdownTooltip } : {}),
+        }));
+      return {
+        id: String(definition.id || '').trim(),
+        name: String(definition.name || definition.id || '').trim(),
+        kind: booleanValues.length ? 'boolean' : 'enum',
+        values,
+        ...(definition.markdownTooltip ? { description: definition.markdownTooltip } : {}),
+      };
+    })
+    .filter((definition) => definition.id && definition.values.length);
+}
+
+function variantsOf(model) {
+  return (model.variants || []).map((variant) => ({
+    parameters: Object.fromEntries(
+      (variant.parameterValues || [])
+        .map((value) => [String(value.id || '').trim(), String(value.value ?? '')])
+        .filter(([key]) => key)
+    ),
+    displayName: String(variant.displayNameOutsidePicker || variant.displayName || '').trim(),
+    maxMode: variant.isMaxMode === true,
+    defaultMax: variant.isDefaultMaxConfig === true,
+    defaultNonMax: variant.isDefaultNonMaxConfig === true,
+    variantString: String(variant.variantStringRepresentation || '').trim(),
+    legacySlug: String(variant.legacySlug || '').trim(),
+  }));
+}
+
+function modelAliases(model, variants, rawId, id) {
+  return [
+    ...new Set(
+      [
+        ...(model.legacySlugs || []),
+        ...(model.idAliases || []),
+        ...variants.flatMap((variant) => (variant.legacySlug ? [variant.legacySlug] : [])),
+        ...(rawId !== id ? [rawId] : []),
+      ]
+        .map((value) => String(value || '').trim())
+        .filter((value) => value && value !== id)
+    ),
+  ];
+}
+
 export function normalizeParameterizedModels(models) {
   const byId = new Map();
   for (const model of models || []) {
-    const id = String(model.name || model.serverModelName || '').trim();
-    if (!id || model.isHidden === true) continue;
-    const parameterDefinitions = (model.parameterDefinitions || [])
-      .map((definition) => {
-        const booleanValues = definition.parameterType?.booleanParameter?.values || [];
-        const enumValues = definition.parameterType?.enumParameter?.values || [];
-        const values = [...booleanValues, ...enumValues]
-          .filter((value) => value?.blockedByAdminAllowlist !== true && String(value?.value || '').trim())
-          .map((value) => ({
-            value: String(value.value),
-            label: String(
-              value.displayName ||
-                (booleanValues.length
-                  ? String(value.value) === 'true'
-                    ? 'On'
-                    : String(value.value) === 'false'
-                      ? 'Off'
-                      : value.value
-                  : value.value)
-            ),
-            ...(value.markdownTooltip ? { description: value.markdownTooltip } : {}),
-          }));
-        return {
-          id: String(definition.id || '').trim(),
-          name: String(definition.name || definition.id || '').trim(),
-          kind: booleanValues.length ? 'boolean' : 'enum',
-          values,
-          ...(definition.markdownTooltip ? { description: definition.markdownTooltip } : {}),
-        };
-      })
-      .filter((definition) => definition.id && definition.values.length);
-    const variants = (model.variants || []).map((variant) => ({
-      parameters: Object.fromEntries(
-        (variant.parameterValues || [])
-          .map((value) => [String(value.id || '').trim(), String(value.value ?? '')])
-          .filter(([key]) => key)
-      ),
-      displayName: String(variant.displayNameOutsidePicker || variant.displayName || '').trim(),
-      maxMode: variant.isMaxMode === true,
-      defaultMax: variant.isDefaultMaxConfig === true,
-      defaultNonMax: variant.isDefaultNonMaxConfig === true,
-      variantString: String(variant.variantStringRepresentation || '').trim(),
-      legacySlug: String(variant.legacySlug || '').trim(),
-    }));
+    const rawId = String(model.name || model.serverModelName || '').trim();
+    if (!rawId || model.isHidden === true) continue;
+    const id = canonicalCursorModelId(rawId);
+    const parameterDefinitions = parameterDefinitionsOf(model);
+    const variants = variantsOf(model);
     const tooltip = model.tooltipData || {};
-    byId.set(id, {
+    const next = {
       id,
-      name: model.clientDisplayName || model.inputboxShortModelName || id,
+      name: isCursorAutoModelId(rawId) ? 'Auto' : model.clientDisplayName || model.inputboxShortModelName || id,
       description: model.tagline || tooltip.markdownContent || tooltip.secondaryText || '',
       contextWindow: Number(model.contextTokenLimit || model.autoContextMaxTokens || 0) || undefined,
       maxContextWindow:
@@ -101,18 +176,10 @@ export function normalizeParameterizedModels(models) {
         model.supportsThinking === true,
       parameterDefinitions,
       variants,
-      aliases: [
-        ...new Set(
-          [
-            ...(model.legacySlugs || []),
-            ...(model.idAliases || []),
-            ...variants.flatMap((variant) => (variant.legacySlug ? [variant.legacySlug] : [])),
-          ]
-            .map((value) => String(value || '').trim())
-            .filter(Boolean)
-        ),
-      ],
-    });
+      aliases: modelAliases(model, variants, rawId, id),
+    };
+    const current = byId.get(id);
+    if (!current || autoModelRank(next) >= autoModelRank(current)) byId.set(id, next);
   }
   return [...byId.values()];
 }
@@ -129,6 +196,54 @@ function usagePercent(value) {
   return Math.round(normalized * 10_000) / 10_000;
 }
 
+// The included-plan windows: per-lane progress percentages when the dashboard
+// reports them, else one dollar window over the included balance.
+function includedUsageWindows(included, plan, includedBalance, resetAt) {
+  const progressWindows = [
+    ['Basic', included.autoPercentUsed],
+    ['API', included.apiPercentUsed],
+  ].filter(([, value]) => Number.isFinite(Number(value)));
+  if (progressWindows.length) {
+    return progressWindows.map(([label, value]) => ({
+      label,
+      source: 'cursor-dashboard',
+      usedPct: usagePercent(value),
+      ...(resetAt ? { resetAt } : {}),
+    }));
+  }
+  if (!includedBalance) return [];
+  return [
+    {
+      label: plan.planName ? `${plan.planName} included` : 'Included usage',
+      source: 'cursor-dashboard',
+      limitUsd: includedBalance.limitUsd,
+      usedUsd: includedBalance.usedUsd,
+      remainingUsd: includedBalance.remainingUsd,
+      ...(resetAt ? { resetAt } : {}),
+    },
+  ];
+}
+
+// The usage-based spend window; null when the account has no spend limit data.
+function usageBasedSpendWindow(spendLimit, resetAt) {
+  const limitCents = Number(spendLimit.overallLimit || spendLimit.individualLimit || spendLimit.pooledLimit || 0);
+  const usedCents = Number(
+    spendLimit.overallUsed || spendLimit.individualUsed || spendLimit.pooledUsed || spendLimit.totalSpend || 0
+  );
+  const remainingCents = Number(
+    spendLimit.overallRemaining || spendLimit.individualRemaining || spendLimit.pooledRemaining || 0
+  );
+  if (limitCents <= 0 && usedCents <= 0 && remainingCents <= 0) return null;
+  return {
+    label: 'Usage-based spend',
+    source: 'cursor-dashboard',
+    limitUsd: centsToUsd(limitCents),
+    usedUsd: centsToUsd(usedCents),
+    remainingUsd: centsToUsd(remainingCents),
+    ...(resetAt ? { resetAt } : {}),
+  };
+}
+
 export function normalizeCursorUsage(usage = {}, planResponse = {}) {
   const plan = planResponse.planInfo || {};
   const included = usage.planUsage || {};
@@ -146,47 +261,11 @@ export function normalizeCursorUsage(usage = {}, planResponse = {}) {
         limitUsd: centsToUsd(includedLimitCents),
       }
     : null;
-  const quotaWindows = [];
-  const progressWindows = [
-    ['Basic', included.autoPercentUsed],
-    ['API', included.apiPercentUsed],
-  ].filter(([, value]) => Number.isFinite(Number(value)));
-  if (progressWindows.length) {
-    for (const [label, value] of progressWindows) {
-      quotaWindows.push({
-        label,
-        source: 'cursor-dashboard',
-        usedPct: usagePercent(value),
-        ...(resetAt ? { resetAt } : {}),
-      });
-    }
-  } else if (hasIncludedBalance) {
-    quotaWindows.push({
-      label: plan.planName ? `${plan.planName} included` : 'Included usage',
-      source: 'cursor-dashboard',
-      limitUsd: includedBalance.limitUsd,
-      usedUsd: includedBalance.usedUsd,
-      remainingUsd: includedBalance.remainingUsd,
-      ...(resetAt ? { resetAt } : {}),
-    });
-  }
-  const extraLimitCents = Number(spendLimit.overallLimit || spendLimit.individualLimit || spendLimit.pooledLimit || 0);
-  const extraUsedCents = Number(
-    spendLimit.overallUsed || spendLimit.individualUsed || spendLimit.pooledUsed || spendLimit.totalSpend || 0
-  );
-  const extraRemainingCents = Number(
-    spendLimit.overallRemaining || spendLimit.individualRemaining || spendLimit.pooledRemaining || 0
-  );
-  if (extraLimitCents > 0 || extraUsedCents > 0 || extraRemainingCents > 0) {
-    quotaWindows.push({
-      label: 'Usage-based spend',
-      source: 'cursor-dashboard',
-      limitUsd: centsToUsd(extraLimitCents),
-      usedUsd: centsToUsd(extraUsedCents),
-      remainingUsd: centsToUsd(extraRemainingCents),
-      ...(resetAt ? { resetAt } : {}),
-    });
-  }
+  const spendWindow = usageBasedSpendWindow(spendLimit, resetAt);
+  const quotaWindows = [
+    ...includedUsageWindows(included, plan, includedBalance, resetAt),
+    ...(spendWindow ? [spendWindow] : []),
+  ];
   return {
     source: 'cursor-dashboard',
     quotaWindows,

package/src/runtime/agent/orchestrator/providers/cursor-wire-protobuf.mjs

@@ -676,7 +676,6 @@ function scalarBytes(type, value) {
 
 function shouldWrite(type, value) {
   if (value == null) return false;
-  if (isMessageType(type) || type === 'raw' || type === 'bytes') return true;
   if (type === 'string') return value !== '';
   return true;
 }
@@ -707,7 +706,8 @@ export function encodeMessage(type, value = {}) {
       parts.push(...encodeMapField(descriptor.no, descriptor.type.map, fieldValue));
       continue;
     }
-    const values = descriptor.repeated ? (Array.isArray(fieldValue) ? fieldValue : []) : [fieldValue];
+    let values = [fieldValue];
+    if (descriptor.repeated) values = Array.isArray(fieldValue) ? fieldValue : [];
     for (const item of values) {
       if (shouldWrite(descriptor.type, item)) parts.push(encodeField(descriptor.no, descriptor.type, item));
     }

package/src/runtime/agent/orchestrator/providers/cursor-wire-request.mjs

@@ -0,0 +1,197 @@
+// Chat-completion request shaping for Cursor: message/content parsing, tool
+// definitions and the per-run request context.
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { encodeJsonValue } from './cursor-wire-protobuf.mjs';
+import { prepareCursorToolDefinition } from './cursor-wire-guards.mjs';
+
+export function deterministicUuid(seed) {
+  const hex = createHash('sha256').update(seed).digest('hex').slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${(8 | (parseInt(hex[16], 16) & 3)).toString(16)}${hex.slice(17, 20)}-${hex.slice(20)}`;
+}
+
+export function textContent(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  return content
+    .filter((part) => part?.type === 'text' && part.text)
+    .map((part) => part.text)
+    .join('\n');
+}
+
+function imageUrlOf(value) {
+  if (value?.type === 'image_url') {
+    return typeof value.image_url === 'string' ? value.image_url : value.image_url?.url;
+  }
+  if (value?.type === 'image' && value.data) {
+    return `data:${value.mimeType || value.media_type || 'application/octet-stream'};base64,${value.data}`;
+  }
+  return '';
+}
+
+function imagePart(value) {
+  const url = imageUrlOf(value);
+  const match = String(url || '').match(/^data:([^;,]+);base64,([\s\S]+)$/i);
+  if (!match) return null;
+  return {
+    url,
+    mimeType: match[1],
+    data: new Uint8Array(Buffer.from(match[2], 'base64')),
+  };
+}
+
+function rootContent(content) {
+  if (typeof content === 'string') return content ? [{ type: 'text', text: content }] : [];
+  const output = [];
+  for (const part of Array.isArray(content) ? content : []) {
+    if (part?.type === 'text' && part.text) output.push({ type: 'text', text: part.text });
+    else {
+      const image = imagePart(part);
+      if (image) output.push({ type: 'image', image: image.url, mediaType: image.mimeType });
+    }
+  }
+  return output;
+}
+
+// A tool message as the resumable result plus its history entry; the tool
+// name comes from the assistant call recorded earlier under the same id.
+function toolResultEntry(message, text, toolNames) {
+  const toolCallId = message.tool_call_id || '';
+  const media = (message.mixdog_tool_media || []).map(imagePart).filter(Boolean);
+  const isError = message.mixdog_tool_error === true;
+  const toolName = toolNames.get(toolCallId) || '';
+  return {
+    toolResult: { toolCallId, content: text, media, isError },
+    entry: {
+      role: 'tool',
+      id: toolCallId,
+      content: [
+        {
+          type: 'tool-result',
+          toolName,
+          toolCallId,
+          result: [text, ...media.map((item) => `[${item.mimeType} image]`)].filter(Boolean).join('\n'),
+          ...(isError ? { isError: true } : {}),
+        },
+      ],
+    },
+  };
+}
+
+// An assistant turn's root content with its tool calls appended; records
+// each call's name under its id for the results that follow.
+function assistantContent(message, toolNames) {
+  const content = rootContent(message.content);
+  for (const call of message.tool_calls || []) {
+    const id = call?.id || '';
+    const name = call?.function?.name || '';
+    let args = {};
+    try {
+      args = JSON.parse(call?.function?.arguments || '{}');
+    } catch {}
+    if (id) toolNames.set(id, name);
+    content.push({ type: 'tool-call', toolCallId: id, toolName: name, args });
+  }
+  return content;
+}
+
+// Pops a trailing user turn off the history as the active request.
+function activeUserTurn(history) {
+  if (history.at(-1)?.role !== 'user') return { userText: '', userImages: [] };
+  const active = history.pop();
+  return {
+    userText: active.text || '',
+    userImages: active.content
+      .map((part) => (part.type === 'image' ? imagePart({ type: 'image_url', image_url: { url: part.image } }) : null))
+      .filter(Boolean),
+  };
+}
+
+export function parseMessages(messages = []) {
+  const systems = [];
+  const history = [];
+  const toolResults = [];
+  const toolNames = new Map();
+  for (const message of messages) {
+    const text = textContent(message.content);
+    if (message.role === 'system' || message.role === 'developer') {
+      systems.push(text);
+    } else if (message.role === 'tool') {
+      const { toolResult, entry } = toolResultEntry(message, text, toolNames);
+      toolResults.push(toolResult);
+      history.push(entry);
+    } else if (message.role === 'assistant') {
+      const content = assistantContent(message, toolNames);
+      if (content.length) history.push({ role: 'assistant', content });
+    } else if (message.role === 'user') {
+      history.push({ role: 'user', content: rootContent(message.content), text });
+    }
+  }
+  return { systems: systems.filter(Boolean), history, toolResults, ...activeUserTurn(history) };
+}
+
+export function buildToolDefinitions(tools = []) {
+  return tools
+    .map((tool) => {
+      const prepared = prepareCursorToolDefinition(tool);
+      return {
+        name: prepared.name,
+        description: prepared.description,
+        inputSchema: encodeJsonValue(prepared.inputSchema),
+        inputSchemaJson: JSON.stringify(prepared.inputSchema),
+        inputSchemaObject: prepared.inputSchema,
+        providerIdentifier: 'mixdog',
+        toolName: prepared.name,
+      };
+    })
+    .filter((tool) => tool.name);
+}
+
+export function selectToolsForChoice(tools = [], toolChoice) {
+  if (toolChoice === 'none') return [];
+  const name = toolChoice && typeof toolChoice === 'object' ? toolChoice.function?.name || toolChoice.name : null;
+  return typeof name === 'string' && name ? tools.filter((tool) => tool?.function?.name === name) : tools;
+}
+
+export function requestModelParameters(body) {
+  return (Array.isArray(body?.mixdog_model_parameters) ? body.mixdog_model_parameters : [])
+    .map((entry) => ({
+      id: String(entry?.id || '').trim(),
+      value: String(entry?.value ?? ''),
+    }))
+    .filter((entry) => entry.id);
+}
+
+export function buildRequestContext(tools, cloudRule) {
+  return {
+    tools,
+    mcpInstructions: tools.length
+      ? [
+          {
+            serverName: 'mixdog',
+            instructions:
+              'Use the tools provided by the mixdog MCP server for this task. ' +
+              'Follow their descriptions and input schemas. Prefer them over Cursor native tools; ' +
+              'native tools do not directly access the Mixdog environment. ' +
+              'If a needed tool is not available, use the provided tool discovery mechanism rather than inventing a tool.',
+          },
+        ]
+      : [],
+    ...(cloudRule ? { cloudRule } : {}),
+    fileContents: {},
+  };
+}
+
+export function canReuseRun(active, { tools, cloudRule, modelParameters, maxMode }) {
+  const toolContract = (definitions) =>
+    new Map(
+      definitions.map((tool) => [tool.name, { description: tool.description, inputSchema: tool.inputSchemaObject }])
+    );
+  const parameters = (values) => new Map(values.map(({ id, value }) => [id, value]));
+  return (
+    (active.cloudRule || '') === (cloudRule || '') &&
+    isDeepStrictEqual(toolContract(active.tools), toolContract(tools)) &&
+    isDeepStrictEqual(parameters(active.modelParameters || []), parameters(modelParameters)) &&
+    (active.maxMode === true) === maxMode
+  );
+}