mixdog 1.3.4 → 1.4.0

package/src/runtime/agent/orchestrator/providers/devin-wire-families.mjs

@@ -0,0 +1,187 @@
+// Reviewed Devin model families: logical models the Cascade catalog serves as
+// one wire uid per effort tier. Each family lists its member uids in default
+// priority order, the uid each effort routes to ('off' = thinking disabled),
+// and its effort ladder. Families the server also declares through
+// `modelFamilyMetadata` are collapsed from that live metadata first; this
+// table then covers accounts and models that ship none.
+
+const SUFFIX_ROUTE = Object.freeze({
+  none: 'off',
+  minimal: 'minimal',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  xhigh: 'xhigh',
+  max: 'max',
+});
+
+// `${base}-${tier}${lane}` members for every tier, routed by their tier.
+function ladder(base, tiers, lane = '') {
+  const members = tiers.map((tier) => `${base}-${tier}${lane}`);
+  const routing = Object.fromEntries(tiers.map((tier, index) => [SUFFIX_ROUTE[tier], members[index]]));
+  return { members, routing };
+}
+
+// `${PREFIX}_${TIER}` enum-style members (e.g. MODEL_GPT_5_2_HIGH).
+function enumLadder(prefix, tiers) {
+  const members = tiers.map((tier) => `${prefix}_${tier.toUpperCase()}`);
+  const routing = Object.fromEntries(tiers.map((tier, index) => [SUFFIX_ROUTE[tier], members[index]]));
+  return { members, routing };
+}
+
+function family(id, name, { members, routing }, { efforts, requiresEffort = false, defaultLevel, defaultMember } = {}) {
+  return Object.freeze({
+    id,
+    name,
+    members,
+    routing,
+    ...(defaultMember ? { defaultMember } : {}),
+    thinking: {
+      mode: 'effort',
+      efforts,
+      ...(defaultLevel ? { defaultLevel } : {}),
+      ...(requiresEffort ? { requiresEffort: true } : {}),
+    },
+  });
+}
+
+const CLAUDE_TIERS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const CLAUDE = { efforts: CLAUDE_TIERS, requiresEffort: true };
+const GPT_TIERS = ['none', 'low', 'medium', 'high', 'xhigh'];
+const GPT = { efforts: ['low', 'medium', 'high', 'xhigh'] };
+const GPT_REQUIRED = { efforts: ['low', 'medium', 'high', 'xhigh'], requiresEffort: true };
+const GPT_56_TIERS = ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
+const GPT_56 = { efforts: ['low', 'medium', 'high', 'xhigh', 'max'] };
+const FLASH_TIERS = ['minimal', 'low', 'medium', 'high'];
+const FLASH = { efforts: FLASH_TIERS, requiresEffort: true };
+
+export const DEVIN_REVIEWED_FAMILIES = Object.freeze([
+  family('claude-opus-5', 'Claude Opus 5', ladder('claude-opus-5', CLAUDE_TIERS), CLAUDE),
+  family('claude-opus-5-fast', 'Claude Opus 5 Fast', ladder('claude-opus-5', CLAUDE_TIERS, '-fast'), CLAUDE),
+  family('claude-fable-5', 'Claude Fable 5', ladder('claude-5-fable', CLAUDE_TIERS), CLAUDE),
+  family('claude-sonnet-5', 'Claude Sonnet 5', ladder('claude-sonnet-5', CLAUDE_TIERS), CLAUDE),
+  family('claude-opus-4-7', 'Claude Opus 4.7', ladder('claude-opus-4-7', CLAUDE_TIERS), CLAUDE),
+  family('claude-opus-4-7-fast', 'Claude Opus 4.7 Fast', ladder('claude-opus-4-7', CLAUDE_TIERS, '-fast'), CLAUDE),
+  family('claude-opus-4-8', 'Claude Opus 4.8', ladder('claude-opus-4-8', CLAUDE_TIERS), CLAUDE),
+  family('claude-opus-4-8-fast', 'Claude Opus 4.8 Fast', ladder('claude-opus-4-8', CLAUDE_TIERS, '-fast'), CLAUDE),
+  family('gpt-5-2', 'GPT-5.2', enumLadder('MODEL_GPT_5_2', GPT_TIERS), GPT),
+  family('gpt-5-3-codex', 'GPT-5.3 Codex', ladder('gpt-5-3-codex', GPT_TIERS.slice(1)), GPT_REQUIRED),
+  family(
+    'gpt-5-3-codex-fast',
+    'GPT-5.3 Codex Fast',
+    ladder('gpt-5-3-codex', GPT_TIERS.slice(1), '-priority'),
+    GPT_REQUIRED
+  ),
+  family('gpt-5-4', 'GPT-5.4', ladder('gpt-5-4', GPT_TIERS), GPT),
+  family('gpt-5-4-fast', 'GPT-5.4 Fast', ladder('gpt-5-4', GPT_TIERS, '-priority'), GPT),
+  family('gpt-5-4-mini', 'GPT-5.4 Mini', ladder('gpt-5-4-mini', GPT_TIERS.slice(1)), GPT_REQUIRED),
+  family('gpt-5-5', 'GPT-5.5', ladder('gpt-5-5', GPT_TIERS), GPT),
+  family('gpt-5-5-fast', 'GPT-5.5 Fast', ladder('gpt-5-5', GPT_TIERS, '-priority'), GPT),
+  family('gpt-5-6-luna', 'GPT-5.6 Luna', ladder('gpt-5-6-luna', GPT_56_TIERS), GPT_56),
+  family('gpt-5-6-luna-fast', 'GPT-5.6 Luna Fast', ladder('gpt-5-6-luna', GPT_56_TIERS, '-priority'), GPT_56),
+  family('gpt-5-6-sol', 'GPT-5.6 Sol', ladder('gpt-5-6-sol', GPT_56_TIERS), GPT_56),
+  family('gpt-5-6-sol-fast', 'GPT-5.6 Sol Fast', ladder('gpt-5-6-sol', GPT_56_TIERS, '-priority'), GPT_56),
+  family('gpt-5-6-terra', 'GPT-5.6 Terra', ladder('gpt-5-6-terra', GPT_56_TIERS), GPT_56),
+  family('gpt-5-6-terra-fast', 'GPT-5.6 Terra Fast', ladder('gpt-5-6-terra', GPT_56_TIERS, '-priority'), GPT_56),
+  family('kimi-k3', 'Kimi K3', ladder('kimi-k3', ['low', 'high', 'max']), {
+    efforts: ['low', 'high', 'max'],
+    requiresEffort: true,
+  }),
+  family(
+    'swe-1-7',
+    'SWE-1.7',
+    { members: ['swe-1-7-medium', 'swe-1-7'], routing: { medium: 'swe-1-7-medium', max: 'swe-1-7' } },
+    { efforts: ['medium', 'max'], requiresEffort: true }
+  ),
+  family('grok-4-5', 'Grok 4.5', ladder('grok-4-5', ['low', 'medium', 'high']), {
+    efforts: ['low', 'medium', 'high'],
+    requiresEffort: true,
+  }),
+  family('inkling', 'Inkling', ladder('inkling', GPT_56_TIERS), GPT_56),
+  family('gemini-3-1-pro', 'Gemini 3.1 Pro', ladder('gemini-3-1-pro', ['low', 'high']), {
+    efforts: ['low', 'high'],
+    requiresEffort: true,
+  }),
+  family('gemini-3-5-flash', 'Gemini 3.5 Flash', ladder('gemini-3-5-flash', FLASH_TIERS), FLASH),
+  family('gemini-3-6-flash', 'Gemini 3.6 Flash', ladder('gemini-3-6-flash', FLASH_TIERS), FLASH),
+  family('gemini-3-flash', 'Gemini 3 Flash', enumLadder('MODEL_GOOGLE_GEMINI_3_0_FLASH', FLASH_TIERS), FLASH),
+  family(
+    'glm-5-2',
+    'GLM-5.2',
+    { members: ['glm-5-2', 'glm-5-2-none', 'glm-5-2-max'], routing: { high: 'glm-5-2', xhigh: 'glm-5-2' } },
+    { efforts: ['high', 'xhigh'], requiresEffort: true }
+  ),
+  family(
+    'glm-5-2-1m',
+    'GLM-5.2 1M',
+    {
+      members: ['glm-5-2-none-1m', 'glm-5-2-1m', 'glm-5-2-max-1m'],
+      routing: { off: 'glm-5-2-none-1m', high: 'glm-5-2-1m', xhigh: 'glm-5-2-max-1m' },
+    },
+    { efforts: ['high', 'xhigh'] }
+  ),
+  family(
+    'gemini-3-7-flash',
+    'Gemini 3.7 Flash',
+    {
+      members: ['gemini-3-7-flash-medium', 'gemini-3-7-flash-minimal', 'gemini-3-7-flash-low', 'gemini-3-7-flash-high'],
+      routing: ladder('gemini-3-7-flash', FLASH_TIERS).routing,
+    },
+    { ...FLASH, defaultLevel: 'medium', defaultMember: 'gemini-3-7-flash-medium' }
+  ),
+  family(
+    'swe-1-7-lightning',
+    'SWE-1.7 Lightning',
+    {
+      members: ['swe-1-7-lightning-medium', 'swe-1-7-lightning'],
+      routing: { medium: 'swe-1-7-lightning-medium', max: 'swe-1-7-lightning' },
+    },
+    {
+      efforts: ['medium', 'max'],
+      requiresEffort: true,
+      defaultLevel: 'medium',
+      defaultMember: 'swe-1-7-lightning-medium',
+    }
+  ),
+  family(
+    'grok-4-6',
+    'Grok 4.6',
+    {
+      members: ['grok-4-6-medium', 'grok-4-6-low', 'grok-4-6-high', 'grok-4-6-xhigh'],
+      routing: ladder('grok-4-6', ['low', 'medium', 'high', 'xhigh']).routing,
+    },
+    {
+      efforts: ['low', 'medium', 'high', 'xhigh'],
+      requiresEffort: true,
+      defaultLevel: 'medium',
+      defaultMember: 'grok-4-6-medium',
+    }
+  ),
+  ...['flash', 'pro'].map((size) =>
+    family(
+      `deepseek-v4-${size}`,
+      `DeepSeek V4 ${size === 'pro' ? 'Pro' : 'Flash'}`,
+      {
+        members: [`deepseek-v4-${size}-high`, `deepseek-v4-${size}-low`, `deepseek-v4-${size}-max`],
+        routing: ladder(`deepseek-v4-${size}`, ['low', 'high', 'max']).routing,
+      },
+      {
+        efforts: ['low', 'high', 'max'],
+        requiresEffort: true,
+        defaultLevel: 'high',
+        defaultMember: `deepseek-v4-${size}-high`,
+      }
+    )
+  ),
+  family(
+    'nemotron-3-ultra',
+    'Nemotron 3 Ultra',
+    {
+      members: ['nemotron-3-ultra-high', 'nemotron-3-ultra-none', 'nemotron-3-ultra-medium'],
+      routing: ladder('nemotron-3-ultra', ['none', 'medium', 'high']).routing,
+    },
+    { efforts: ['medium', 'high'], defaultLevel: 'high', defaultMember: 'nemotron-3-ultra-high' }
+  ),
+  // A single-uid rename: no effort surface.
+  Object.freeze({ id: 'claude-haiku-4-5', name: 'Claude Haiku 4.5', members: ['MODEL_PRIVATE_11'], routing: {} }),
+]);

package/src/runtime/agent/orchestrator/providers/devin-wire-identity.mjs

@@ -0,0 +1,342 @@
+// Model-class identity for Devin wire decisions: which backend family a model
+// id names (Gemini tool-schema rules) and the thinking form another model's
+// reasoning is demoted into when it replays as plain text.
+//
+// Class matchers rank exact(4) > bounded(3) > namespace(2) > prefix(1) >
+// glob(0), token length breaking ties; an equal rank across two classes
+// resolves to 'unknown'. A trailing effort/thinking suffix is collapsed off
+// the id before matching.
+
+const MATCHER_RANK = Object.freeze({ exact: 4, bounded: 3, namespace: 2, prefix: 1, glob: 0 });
+
+// [class, [[kind, token, boundedNamespace?], ...]]
+const CLASS_MATCHERS = Object.freeze([
+  [
+    'ai21',
+    [
+      ['bounded', 'jamba'],
+      ['namespace', 'ai21'],
+    ],
+  ],
+  [
+    'amazon',
+    [
+      ['bounded', 'nova'],
+      ['bounded', 'titan'],
+      ['namespace', 'amazon', true],
+    ],
+  ],
+  [
+    'anthropic',
+    [
+      ['namespace', 'anthropic', true],
+      ['bounded', 'anthropic'],
+      ['bounded', 'claude'],
+    ],
+  ],
+  ['baidu', [['bounded', 'ernie']]],
+  ['bytedance', [['bounded', 'doubao']]],
+  [
+    'cohere',
+    [
+      ['bounded', 'command'],
+      ['namespace', 'cohere'],
+    ],
+  ],
+  [
+    'deepseek',
+    [
+      ['namespace', 'deepseek', true],
+      ['bounded', 'deepseek'],
+    ],
+  ],
+  ['gemini', [['bounded', 'gemini']]],
+  ['gemma', [['bounded', 'gemma']]],
+  [
+    'glm',
+    [
+      ['bounded', 'glm'],
+      ['bounded', 'zai-glm'],
+    ],
+  ],
+  [
+    'gpt-oss',
+    [
+      ['namespace', 'gpt-oss', true],
+      ['bounded', 'gpt-oss'],
+    ],
+  ],
+  [
+    'kimi',
+    [
+      ['namespace', 'moonshotai'],
+      ['bounded', 'kimi'],
+      ['exact', 'k3'],
+      ['exact', 'k3-256k'],
+    ],
+  ],
+  [
+    'meta',
+    [
+      ['bounded', 'muse-spark'],
+      ['bounded', 'muse-wonder'],
+      ['bounded', 'llama'],
+      ['bounded', 'meta-llama'],
+      ['namespace', 'meta-llama'],
+    ],
+  ],
+  ['mimo', [['bounded', 'mimo']]],
+  [
+    'minimax',
+    [
+      ['namespace', 'minimax'],
+      ['bounded', 'minimax'],
+      ['bounded', 'hailuo'],
+    ],
+  ],
+  [
+    'mistral',
+    [
+      ['bounded', 'mistral'],
+      ['bounded', 'mixtral'],
+    ],
+  ],
+  [
+    'openai',
+    [
+      ['namespace', 'openai'],
+      ['namespace', 'openai', true],
+      ['prefix', 'gpt-'],
+      ['prefix', 'chatgpt-'],
+      ['prefix', 'codex-'],
+      ['exact', 'o1'],
+      ['prefix', 'o1-'],
+      ['prefix', 'o1.'],
+      ['exact', 'o3'],
+      ['prefix', 'o3-'],
+      ['prefix', 'o3.'],
+      ['exact', 'o4'],
+      ['prefix', 'o4-'],
+      ['prefix', 'o4.'],
+    ],
+  ],
+  [
+    'qwen',
+    [
+      ['bounded', 'qwen'],
+      ['bounded', 'deepseek-r1-distill-qwen'],
+      ['glob', '*distill-qwen*'],
+    ],
+  ],
+  ['stepfun', [['bounded', 'step']]],
+  [
+    'xai',
+    [
+      ['prefix', 'cursor-grok-'],
+      ['bounded', 'grok'],
+      ['namespace', 'x-ai'],
+      ['namespace', 'xai', true],
+    ],
+  ],
+]);
+
+// Reviewed provider-agnostic identity overrides (exact bare id or glob).
+const EXACT_OVERRIDES = Object.freeze(
+  new Map([
+    ['daybreak-blue-latest', 'unknown'],
+    ['daybreak-red-latest', 'unknown'],
+    ['gpt-daybreak-blue-latest', 'openai'],
+    ['gpt-daybreak-red-latest', 'openai'],
+  ])
+);
+const GLOB_OVERRIDES = Object.freeze([
+  ['*bonsai-27b*', 'qwen'],
+  ['*bonsai-2-27b*', 'qwen'],
+]);
+
+// Trailing variant suffixes collapsed off an id before class matching.
+const COLLAPSE_SUFFIXES = Object.freeze([
+  ['-thinking'],
+  ['-extra-high'],
+  ['-none'],
+  ['-minimal'],
+  ['-medium'],
+  ['-xhigh'],
+  ['-high'],
+  ['-low'],
+  ['-max', 'qwen'],
+]);
+
+function bareOf(id) {
+  const slash = id.lastIndexOf('/');
+  return slash === -1 ? id : id.slice(slash + 1);
+}
+
+function globMatch(pattern, value) {
+  const segments = pattern.split('*');
+  if (segments.length === 1) return value === pattern;
+  const head = segments[0];
+  if (!value.startsWith(head)) return false;
+  let remainder = value.slice(head.length);
+  for (let i = 1; i < segments.length - 1; i += 1) {
+    const segment = segments[i];
+    if (!segment) continue;
+    const found = remainder.indexOf(segment);
+    if (found === -1) return false;
+    remainder = remainder.slice(found + segment.length);
+  }
+  const last = segments.at(-1);
+  return last === '' || remainder.endsWith(last);
+}
+
+// `token` itself, or `token` followed by - _ . : or a digit.
+function boundedMatch(value, token) {
+  if (value === token) return true;
+  if (!value.startsWith(token)) return false;
+  const next = value.charCodeAt(token.length);
+  return next === 45 || next === 95 || next === 46 || next === 58 || (next >= 48 && next <= 57);
+}
+
+function matcherMatches([kind, token, boundedNamespace], lower, bare) {
+  switch (kind) {
+    case 'exact':
+      return bare === token;
+    case 'bounded':
+      return boundedMatch(bare, token);
+    case 'namespace':
+      return (boundedNamespace ? lower.split(/[/.:]/) : lower.split('/')).some(
+        (part) => part && (boundedNamespace ? boundedMatch(part, token) : part === token)
+      );
+    case 'prefix':
+      return bare.startsWith(token);
+    default:
+      return globMatch(token, bare);
+  }
+}
+
+function classOfLogicalId(model) {
+  const lower = model.trim().toLowerCase();
+  const bare = bareOf(lower);
+  let winner = null;
+  let tied = false;
+  for (const [cls, matchers] of CLASS_MATCHERS) {
+    for (const matcher of matchers) {
+      if (!matcherMatches(matcher, lower, bare)) continue;
+      const rank = [MATCHER_RANK[matcher[0]], matcher[1].length];
+      if (winner && winner.rank[0] === rank[0] && winner.rank[1] === rank[1] && winner.cls !== cls) {
+        tied = true;
+      } else if (!winner || winner.rank[0] < rank[0] || (winner.rank[0] === rank[0] && winner.rank[1] < rank[1])) {
+        winner = { rank, cls };
+        tied = false;
+      }
+    }
+  }
+  return tied || !winner ? 'unknown' : winner.cls;
+}
+
+function collapsedId(model) {
+  const lower = model.toLowerCase();
+  const bare = bareOf(lower);
+  let winner = null;
+  for (const [suffix, exceptBarePrefix] of COLLAPSE_SUFFIXES) {
+    if (!lower.endsWith(suffix)) continue;
+    if (exceptBarePrefix && bare.startsWith(exceptBarePrefix)) continue;
+    if (!winner || suffix.length > winner.length) winner = suffix;
+  }
+  return winner ? model.slice(0, model.length - winner.length) : model;
+}
+
+/** The model class a wire or catalog id names ('gemini', 'anthropic', 'openai', …, or 'unknown'). */
+export function devinModelClass(modelId) {
+  const raw = String(modelId || '');
+  const trimmed = raw.trim();
+  const bare = bareOf(trimmed).toLowerCase();
+  const exact = EXACT_OVERRIDES.get(bare);
+  if (exact) return exact;
+  const glob = GLOB_OVERRIDES.filter(([pattern]) => globMatch(pattern, bare)).sort(
+    (a, b) => b[0].replaceAll('*', '').length - a[0].replaceAll('*', '').length
+  );
+  if (glob.length && !(glob[1] && glob[1][0].replaceAll('*', '').length === glob[0][0].replaceAll('*', '').length)) {
+    return glob[0][1];
+  }
+  return classOfLogicalId(trimmed.length === raw.length ? collapsedId(trimmed) : trimmed);
+}
+
+/** Whether the catalog id or the concrete wire uid runs on a Gemini backend. */
+export function isDevinGeminiModel(...ids) {
+  return ids.some(
+    (id) => typeof id === 'string' && (devinModelClass(id) === 'gemini' || id.startsWith('MODEL_GOOGLE_GEMINI_'))
+  );
+}
+
+const isAsciiWhitespace = (code) =>
+  code === 9 || code === 10 || code === 11 || code === 12 || code === 13 || code === 32;
+
+function trimAsciiStart(text, start, end) {
+  let cursor = start;
+  while (cursor < end && isAsciiWhitespace(text.charCodeAt(cursor))) cursor += 1;
+  return cursor;
+}
+
+function trimAsciiEnd(text, start, end) {
+  let cursor = end;
+  while (cursor > start && isAsciiWhitespace(text.charCodeAt(cursor - 1))) cursor -= 1;
+  return cursor;
+}
+
+function delimitedClose(open, close, text, start, end) {
+  let depth = 1;
+  let cursor = start;
+  while (cursor < end) {
+    const nextClose = text.indexOf(close, cursor);
+    if (nextClose < 0 || nextClose >= end) return -1;
+    const nextOpen = text.indexOf(open, cursor);
+    if (nextOpen >= 0 && nextOpen < nextClose) {
+      depth += 1;
+      cursor = nextOpen + open.length;
+      continue;
+    }
+    depth -= 1;
+    if (depth === 0) return nextClose;
+    cursor = nextClose + close.length;
+  }
+  return -1;
+}
+
+// Text already wrapped in `open`…`close` blocks is unwrapped so it is not
+// wrapped twice.
+function unwrapDelimited(open, close, text) {
+  const end = trimAsciiEnd(text, 0, text.length);
+  let cursor = trimAsciiStart(text, 0, end);
+  if (cursor >= end || !text.startsWith(open, cursor)) return text;
+  const segments = [];
+  while (cursor < end) {
+    if (!text.startsWith(open, cursor)) return text;
+    const innerStart = cursor + open.length;
+    const innerEnd = delimitedClose(open, close, text, innerStart, end);
+    if (innerEnd < 0) return text;
+    const trimmedEnd = trimAsciiEnd(text, innerStart, innerEnd);
+    const trimmedStart = trimAsciiStart(text, innerStart, trimmedEnd);
+    segments.push(unwrapDelimited(open, close, text.slice(trimmedStart, trimmedEnd)));
+    cursor = trimAsciiStart(text, innerEnd + close.length, end);
+  }
+  return segments.join('\n');
+}
+
+const THINK_BLOCK_CLASSES = new Set(['glm', 'kimi', 'qwen', 'deepseek', 'openai', 'gpt-oss', 'gemma']);
+
+/**
+ * Another model's reasoning as plain text in the target model's own thinking
+ * form: bare prose for Claude (tagged reasoning is refused there), a fenced
+ * ```thinking block for Gemini, <think> for the <think>-dialect families, and
+ * <thinking> otherwise. No trailing delimiter.
+ */
+export function devinDemotedThinking(targetModelId, text) {
+  if (!text) return '';
+  const value = text.toWellFormed();
+  const cls = devinModelClass(targetModelId);
+  if (cls === 'anthropic') return value;
+  if (cls === 'gemini') return `\`\`\`thinking\n${value}\n\`\`\``;
+  if (THINK_BLOCK_CLASSES.has(cls)) return `<think>\n${value}\n</think>`;
+  return `<thinking>\n${unwrapDelimited('<thinking>', '</thinking>', value)}\n</thinking>`;
+}