mixdog 1.1.2 → 1.2.1

package/src/runtime/shared/llm/provider-catalog-registry.mjs

@@ -0,0 +1,162 @@
+// Where each mixdog provider's model metadata comes from. One table read by
+// both lookup paths (async list enrichment and the sync lookup), so every
+// provider resolves effort ladders, limits, capabilities and pricing in the
+// same precedence order (see lookupModelMetadata in model-catalog.mjs).
+//
+// Fields:
+//   modelsDev     models.dev provider id holding this provider's rows.
+//   sameEndpoint  true when that models.dev entry describes the endpoint this
+//                 provider actually calls; its effort ladders, limits and
+//                 capabilities then apply. Otherwise it is only the same
+//                 vendor (another endpoint/account plan): it prices the model
+//                 and is a first guess for capabilities and the effort ladder
+//                 the provider's own sources leave undeclared — never limits.
+//   relay         sells other vendors' models; the serving vendor (read off
+//                 the model id) is likewise a first guess for capabilities
+//                 and the effort ladder, and prices a model with no own rates.
+//   rosterFiles   live-roster cache files the provider's listModels persists.
+//   rosterLimitsAuthoritative
+//                 live-roster limits beat catalog limits (the roster reflects
+//                 the account/backend window); otherwise they only fill gaps.
+//   rosterLadderFinal
+//                 a roster row's effort ladder is complete, empty included:
+//                 no guessed ladder is added to a model the roster lists.
+//   seedRow       offline seed row for a model id, applied after fetched data.
+import { mimoSeedRow, museSeedRow } from './provider-seed-rosters.mjs';
+
+function mimoSeedMetadata(model) {
+  const seed = mimoSeedRow(model);
+  return seed
+    ? {
+        contextWindow: seed.contextWindow,
+        outputTokens: seed.outputTokens,
+        supportsReasoning: seed.reasoning === true,
+        supportsVision: seed.vision === true,
+      }
+    : null;
+}
+
+const PROVIDER_CATALOGS = Object.freeze({
+  // api.openai.com — the endpoint models.dev `openai` describes.
+  openai: { modelsDev: 'openai', sameEndpoint: true },
+  // chatgpt.com/backend-api/codex: subscription backend, not the public API.
+  'openai-oauth': {
+    modelsDev: 'openai',
+    sameEndpoint: false,
+    rosterFiles: ['openai-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+  },
+  // api.anthropic.com with a subscription token: account-scoped windows and
+  // effort surface differ from the public API SKU.
+  'anthropic-oauth': {
+    modelsDev: 'anthropic',
+    sameEndpoint: false,
+    rosterFiles: ['anthropic-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+  },
+  // api.anthropic.com with an API key. Shares the OAuth roster file.
+  anthropic: { modelsDev: 'anthropic', sameEndpoint: true, rosterFiles: ['anthropic-oauth-models.json'] },
+  // generativelanguage.googleapis.com — the endpoint models.dev `google` describes.
+  gemini: { modelsDev: 'google', sameEndpoint: true, rosterFiles: ['gemini-models.json'] },
+  // cli-chat-proxy.grok.com, not api.x.ai.
+  'grok-oauth': {
+    modelsDev: 'xai',
+    sameEndpoint: false,
+    rosterFiles: ['grok-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+  },
+  // api.meta.ai/v1 — the endpoint models.dev `meta` describes.
+  'muse-code-oauth': {
+    modelsDev: 'meta',
+    sameEndpoint: true,
+    rosterFiles: ['muse-code-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+    seedRow: museSeedRow,
+  },
+  // token-plan-*.xiaomimimo.com subscription gateway, not the public API.
+  'mimo-oauth': {
+    modelsDev: 'xiaomi',
+    sameEndpoint: false,
+    rosterFiles: ['mimo-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+    seedRow: mimoSeedMetadata,
+  },
+  // Relays: their own models.dev id (when published) is their own endpoint.
+  // Effort tiers live in the wire id; a row without levels has no effort
+  // surface (resolveAntigravityWireModel drops the effort).
+  'antigravity-oauth': { relay: true, rosterFiles: ['antigravity-oauth-models.json'], rosterLadderFinal: true },
+  // api.commandcode.ai/provider/v1 relays other vendors' models.
+  'command-code-oauth': {
+    relay: true,
+    rosterFiles: ['command-code-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+  },
+  'cursor-oauth': { relay: true },
+  'cursor-api': { relay: true },
+  'opencode-go': { relay: true },
+});
+
+// Confirmed upstream catalog gaps, keyed provider → model. Each entry patches
+// the mapped models.dev row; a live roster that declares the field still wins.
+const VERIFIED_CORRECTIONS = Object.freeze({
+  'muse-code-oauth': Object.freeze({
+    // models.dev `meta` stops this ladder at xhigh; the Muse OAuth endpoint
+    // accepts reasoning.effort "max" for the contributor tier as for 1.3.
+    'muse-spark-1.3-contributor': Object.freeze({
+      reasoningOptions: Object.freeze([
+        Object.freeze({ type: 'effort', values: Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']) }),
+      ]),
+    }),
+  }),
+});
+
+const key = (provider) =>
+  String(provider || '')
+    .trim()
+    .toLowerCase();
+
+/** Registry entry with defaults; an unlisted provider is its own models.dev id and endpoint. */
+export function providerCatalogEntry(provider) {
+  const p = key(provider);
+  if (!p) return null;
+  const entry = PROVIDER_CATALOGS[p] || {};
+  return {
+    provider: p,
+    modelsDev: entry.modelsDev || p,
+    sameEndpoint: entry.sameEndpoint !== false,
+    relay: entry.relay === true,
+    rosterFiles: entry.rosterFiles || [],
+    rosterLimitsAuthoritative: entry.rosterLimitsAuthoritative === true,
+    rosterLadderFinal: entry.rosterLadderFinal === true,
+    seedRow: entry.seedRow || null,
+  };
+}
+
+export function modelsDevProviderId(provider) {
+  return providerCatalogEntry(provider)?.modelsDev || null;
+}
+
+export function providerRosterFiles(provider) {
+  return providerCatalogEntry(provider)?.rosterFiles || [];
+}
+
+/** Providers owning a live-roster file; a provider reading another's file is skipped. */
+export function rosterProviders() {
+  const seen = new Set();
+  const out = [];
+  for (const [provider, entry] of Object.entries(PROVIDER_CATALOGS)) {
+    const files = entry.rosterFiles || [];
+    if (!files.length || files.every((file) => seen.has(file))) continue;
+    for (const file of files) seen.add(file);
+    out.push(provider);
+  }
+  return out;
+}
+
+export function providerSeedRow(provider, model) {
+  return providerCatalogEntry(provider)?.seedRow?.(String(model || '')) || null;
+}
+
+export function providerMetadataCorrection(provider, model) {
+  return VERIFIED_CORRECTIONS[key(provider)]?.[String(model || '')] || null;
+}

package/src/runtime/shared/llm/provider-seed-rosters.mjs

@@ -0,0 +1,130 @@
+// Offline seed rosters for providers whose discovery endpoint lists bare ids.
+// A seed is the cold-start fallback only: the metadata lookup applies it to
+// fields nothing fetched (live roster, models.dev) supplied, and provider
+// rows never let it override discovered data. Pure data, no provider imports,
+// so the shared sync lookup and the provider transports read one copy.
+
+// ── Muse Code (Meta Muse Spark) ─────────────────────────────────────────────
+export const MUSE_DEFAULT_EFFORT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh']);
+const MUSE_SIX_LEVELS = Object.freeze([...MUSE_DEFAULT_EFFORT_LEVELS, 'max']);
+const MUSE_SPARK_CONTEXT = 1_048_576;
+export const MUSE_SPARK_MAX_OUTPUT = 131_072;
+const STANDARD_COST = { inputCostPerM: 1.25, outputCostPerM: 4.25, cacheReadCostPerM: 0.15, cacheWriteCostPerM: 0 };
+const CONTRIBUTOR_COST = { inputCostPerM: 0.1, outputCostPerM: 0.2, cacheReadCostPerM: 0.002, cacheWriteCostPerM: 0 };
+
+// Only the 1.3 revisions accept `max`.
+const MUSE_SEEDS = Object.freeze({
+  'muse-spark-1.1': { name: 'Muse Spark 1.1', levels: MUSE_DEFAULT_EFFORT_LEVELS, cost: STANDARD_COST },
+  'muse-spark-1.2': { name: 'Muse Spark 1.2', levels: MUSE_DEFAULT_EFFORT_LEVELS, cost: STANDARD_COST },
+  'muse-spark-1.2-contributor': {
+    name: 'Muse Spark 1.2 (C)',
+    levels: MUSE_DEFAULT_EFFORT_LEVELS,
+    cost: CONTRIBUTOR_COST,
+  },
+  'muse-spark-1.3': { name: 'Muse Spark 1.3', levels: MUSE_SIX_LEVELS, cost: STANDARD_COST },
+  'muse-spark-1.3-contributor': { name: 'Muse Spark 1.3 (C)', levels: MUSE_SIX_LEVELS, cost: CONTRIBUTOR_COST },
+});
+export const MUSE_SEED_IDS = Object.freeze(Object.keys(MUSE_SEEDS));
+
+function museEffortRow(id, name, levels, cost) {
+  return {
+    id,
+    name,
+    provider: 'muse-code-oauth',
+    family: 'muse-spark',
+    contextWindow: MUSE_SPARK_CONTEXT,
+    outputTokens: MUSE_SPARK_MAX_OUTPUT,
+    supportsReasoning: true,
+    supportsVision: true,
+    supportsFunctionCalling: true,
+    reasoningLevels: [...levels],
+    reasoningOptions: [{ type: 'effort', values: [...levels] }],
+    ...cost,
+  };
+}
+
+// Revisioned Spark ids the seed does not list inherit the newest seeded
+// revision of their tier (limits, vision, pricing) but take the five-level
+// ladder: only reviewed seeds advertise `max`.
+const SPARK_ID_RE = /^muse-spark-(\d+)\.(\d+)(?:\.(\d+))?(-contributor)?$/i;
+
+function revisionOf(id) {
+  const m = SPARK_ID_RE.exec(id);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3] || 0)] : null;
+}
+
+function compareRevision(a, b) {
+  for (let i = 0; i < 3; i += 1) if (a[i] !== b[i]) return a[i] - b[i];
+  return 0;
+}
+
+function museLineageRow(id) {
+  const match = SPARK_ID_RE.exec(id);
+  if (!match) return null;
+  const contributor = Boolean(match[4]);
+  let template = null;
+  let templateRevision = null;
+  for (const seedId of MUSE_SEED_IDS) {
+    if (SPARK_ID_RE.exec(seedId)[4] ? !contributor : contributor) continue;
+    const candidate = revisionOf(seedId);
+    if (!templateRevision || compareRevision(candidate, templateRevision) > 0) {
+      template = seedId;
+      templateRevision = candidate;
+    }
+  }
+  if (!template) return null;
+  const revision =
+    match[3] && Number(match[3]) !== 0 ? `${match[1]}.${match[2]}.${match[3]}` : `${match[1]}.${match[2]}`;
+  return museEffortRow(
+    id,
+    `Muse Spark ${revision}${contributor ? ' (C)' : ''}`,
+    MUSE_DEFAULT_EFFORT_LEVELS,
+    MUSE_SEEDS[template].cost
+  );
+}
+
+/** Seed row for a seeded id, else the lineage row of a revisioned Spark id, else null. */
+export function museSeedRow(id) {
+  const key = String(id || '');
+  const seed = MUSE_SEEDS[key];
+  if (seed) return museEffortRow(key, seed.name, seed.levels, seed.cost);
+  return museLineageRow(key);
+}
+
+// ── Xiaomi MiMo ─────────────────────────────────────────────────────────────
+const MIMO_SEED_CONTEXT = 1_048_576;
+const MIMO_SEED_OUTPUT = 131_072;
+export const MIMO_SEED_MODELS = Object.freeze(
+  [
+    ['mimo-v2.6-pro', 'MiMo-V2.6-Pro', MIMO_SEED_CONTEXT],
+    ['mimo-v2.6-flash', 'MiMo-V2.6-Flash', MIMO_SEED_CONTEXT],
+    ['mimo-v2.6-pro-ultraspeed', 'MiMo-V2.6-Pro-Ultraspeed', MIMO_SEED_CONTEXT],
+    ['mimo-v2.5-pro', 'MiMo-V2.5-Pro', MIMO_SEED_CONTEXT],
+    ['mimo-v2.5', 'MiMo-V2.5', MIMO_SEED_CONTEXT],
+    ['mimo-v2-pro', 'MiMo-V2-Pro', MIMO_SEED_CONTEXT],
+    ['mimo-v2-omni', 'MiMo-V2-Omni', 262_144],
+  ].map(([id, display_name, context_window]) =>
+    Object.freeze({ id, display_name, context_window, max_output_tokens: MIMO_SEED_OUTPUT })
+  )
+);
+
+/** Exact seed id, else the longest seed whose id is a lineage prefix of the
+ *  model (dated or suffixed variants of a seeded model). */
+export function mimoSeedRow(model) {
+  const id = String(model || '').toLowerCase();
+  let seed = MIMO_SEED_MODELS.find((item) => item.id === id) || null;
+  if (!seed) {
+    for (const item of MIMO_SEED_MODELS) {
+      if (id.startsWith(`${item.id}-`) && (!seed || item.id.length > seed.id.length)) seed = item;
+    }
+  }
+  if (!seed) return null;
+  return {
+    id: String(model),
+    contextWindow: seed.context_window,
+    outputTokens: seed.max_output_tokens,
+    reasoning: true,
+    vision: true,
+    inputModalities: ['text', 'image'],
+  };
+}

package/src/runtime/shared/model-proxy-mode.d.mts

@@ -0,0 +1,3 @@
+export const MODEL_PROXY_ENV: 'MIXDOG_MODEL_PROXY';
+export function modelProxyClientMode(env?: Record<string, string | undefined>): boolean;
+export function serverModelCredentialsDisabledError(what?: string): Error & { code: string };

package/src/runtime/shared/model-proxy-mode.mjs

@@ -0,0 +1,19 @@
+// Remote (SSH) mode switch. With MIXDOG_MODEL_PROXY=client the daemon runs on
+// a server that must never hold model credentials: every model call is
+// executed by the connected desktop client on the user's PC and streamed back
+// (providers/model-proxy-channel.mjs). Read per call so a test or host can
+// flip the environment without reloading modules.
+export const MODEL_PROXY_ENV = 'MIXDOG_MODEL_PROXY';
+
+export function modelProxyClientMode(env = process.env) {
+  return env?.[MODEL_PROXY_ENV] === 'client';
+}
+
+/** The refusal every server-side credential refresh raises in this mode. */
+export function serverModelCredentialsDisabledError(what = 'model credentials') {
+  const error = new Error(
+    `${what} are not available on this server: ${MODEL_PROXY_ENV}=client runs every model call on the client PC.`
+  );
+  error.code = 'MODEL_CREDENTIALS_DISABLED';
+  return error;
+}

package/src/runtime/shared/plugin-manifest.mjs

@@ -7,10 +7,19 @@
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { readJsonSafe } from './json-file.mjs';
 
-/** `.codex-plugin/plugin.json` wins over a root-level `plugin.json`; a plugin
- *  without either is an empty manifest, never an error. */
+/** Manifest files in precedence order: `.codex-plugin/plugin.json`, a
+ *  root-level `plugin.json`, then Claude Code's `.claude-plugin/plugin.json`. */
+export const PLUGIN_MANIFEST_FILES = ['.codex-plugin/plugin.json', 'plugin.json', '.claude-plugin/plugin.json'];
+
+/** First readable manifest in `PLUGIN_MANIFEST_FILES` order; a plugin without
+ *  any is an empty manifest, never an error. A Claude Code manifest's `skills`
+ *  is a plugin-relative path (e.g. `./.claude/skills/`). */
 export function pluginManifest(root) {
-  return readJsonSafe(join(root, '.codex-plugin', 'plugin.json')) || readJsonSafe(join(root, 'plugin.json')) || {};
+  for (const rel of PLUGIN_MANIFEST_FILES) {
+    const manifest = readJsonSafe(join(root, ...rel.split('/')));
+    if (manifest) return manifest;
+  }
+  return {};
 }
 
 /** Resolve a manifest-relative path, refusing absolute paths and anything
@@ -21,22 +30,22 @@ export function resolveContainedPluginPath(root, rel) {
   const base = resolve(root);
   const abs = resolve(base, trimmed);
   const relToBase = relative(base, abs);
-  if (relToBase.startsWith('..') || isAbsolute(relToBase)) return null;
+  if (relToBase.split(/[\\/]/)[0] === '..' || isAbsolute(relToBase)) return null;
   return abs;
 }
 
-/** Skill roots a plugin contributes: the conventional `<root>/skills/` plus an
- *  optional manifest `skills` path. Deduplicated, absolute, root-contained. */
+/** Skill roots a plugin contributes: the conventional `<root>/skills/` plus the
+ *  manifest `skills` field, a path or a list of paths. Deduplicated, absolute,
+ *  root-contained. */
 export function pluginSkillsRoots(root) {
   const manifest = pluginManifest(root);
   const roots = new Set();
   const add = (rel) => {
+    if (typeof rel !== 'string' || !rel.trim()) return;
     const abs = resolveContainedPluginPath(root, rel);
     if (abs) roots.add(abs);
   };
   add('./skills/');
-  if (typeof manifest.skills === 'string' && manifest.skills.trim()) {
-    add(manifest.skills.trim());
-  }
+  for (const rel of Array.isArray(manifest.skills) ? manifest.skills : [manifest.skills]) add(rel);
   return [...roots];
 }

package/src/runtime/shared/pristine-execution-contract.json

@@ -66,11 +66,18 @@
     },
     "muse-code-oauth": {
       "credentialFile": "muse-code-oauth.json",
-      "credentialPathEnv": "MUSE_CODE_OAUTH_CREDENTIALS_PATH"
+      "credentialPathEnv": "MUSE_CODE_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "muse-code-oauth-models.json"
+    },
+    "command-code-oauth": {
+      "credentialFile": "command-code-oauth.json",
+      "credentialPathEnv": "COMMAND_CODE_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "command-code-oauth-models.json"
     },
     "mimo-oauth": {
       "credentialFile": "mimo-oauth.json",
-      "credentialPathEnv": "MIMO_OAUTH_CREDENTIALS_PATH"
+      "credentialPathEnv": "MIMO_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "mimo-oauth-models.json"
     },
     "cursor-oauth": {
       "credentialFile": "cursor-oauth.json",

package/src/runtime/shared/pristine-execution.mjs

@@ -8,6 +8,12 @@ import { ACCOUNT_PROVIDERS, providerAccountPath, readProviderAccountPool } from
 import { AGENT_PROVIDER_ENV_ALIASES, getAgentApiKey } from './provider-api-key.mjs';
 import { platformEntryKey } from './native-asset.mjs';
 import { clean } from './clean.mjs';
+import { MODEL_PROXY_ENV, modelProxyClientMode } from './model-proxy-mode.mjs';
+import { installModelProxyChannel } from '../agent/orchestrator/providers/model-proxy-channel.mjs';
+import {
+  ModelProxyBridgeChannel,
+  readModelProxyBridgeDiscovery,
+} from '../agent/orchestrator/providers/model-proxy-bridge.mjs';
 
 const contractPath = fileURLToPath(new URL('./pristine-execution-contract.json', import.meta.url));
 
@@ -205,6 +211,12 @@ export function createPristineExecutionBoundary({
 
   const contract = PRISTINE_EXECUTION_CONTRACT;
   const hostEnv = { ...env };
+  // Remote (SSH) mode: this server holds no model credentials, so the child
+  // runtime's model calls go through the daemon's model proxy bridge. Its
+  // endpoint is read from the HOST runtime root, before it is retargeted
+  // below; a missing or stale one fails closed (never a local credential).
+  const proxyMode = modelProxyClientMode(hostEnv);
+  const bridgeEndpoint = proxyMode ? readModelProxyBridgeDiscovery(hostEnv.MIXDOG_RUNTIME_ROOT) : null;
   const originalEnv = new Map();
   const touchedKeys = new Set();
   const rememberEnv = (name) => {
@@ -227,6 +239,8 @@ export function createPristineExecutionBoundary({
   mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
   let cleaned = false;
   let restoreAuthBindings = () => {};
+  let bridgeChannel = null;
+  let restoreModelProxyChannel = () => {};
   // rmSync backs off linearly (retryDelay × attempt), so 50 retries at 100ms
   // is a ≈128s budget per attempt. Callers whose result is already complete
   // (headless exec) pass a smaller budget and leave stragglers to the sweep.
@@ -238,6 +252,8 @@ export function createPristineExecutionBoundary({
       else env[name] = value;
     }
     restoreAuthBindings();
+    restoreModelProxyChannel();
+    bridgeChannel?.dispose('the headless run finished');
     const removal = { recursive: true, force: true, maxRetries: rootRemovalRetries, retryDelay: 100 };
     // Windows releases file handles (pg.log, sockets) a beat after the owning
     // process exits; rmSync retries absorb that EBUSY/EPERM window.
@@ -280,7 +296,7 @@ export function createPristineExecutionBoundary({
     const oauth = contract.oauthProviders[selectedProvider];
     const apiKeyEnv = contract.apiKeyProviders[selectedProvider];
     let selectedApiKey = null;
-    if (apiKeyEnv) {
+    if (apiKeyEnv && !proxyMode) {
       // Resolve before scrubbing so the selected provider may use its standard,
       // MIXDOG_AGENT_*, alias, or one provider-scoped keychain account. No
       // general config loader or all-provider credential scan is involved.
@@ -311,7 +327,15 @@ export function createPristineExecutionBoundary({
 
     let authMode = 'provider-managed';
     let catalogCount = 0;
-    if (oauth) {
+    if (proxyMode) {
+      // No API key, OAuth account or credential binding: the PC behind the
+      // daemon runs every call. The runtime root stays the pristine one, for
+      // the services this run owns; only model calls reach the daemon.
+      setEnv(MODEL_PROXY_ENV, 'client');
+      bridgeChannel = new ModelProxyBridgeChannel(bridgeEndpoint);
+      restoreModelProxyChannel = installModelProxyChannel(bridgeChannel);
+      authMode = 'model-proxy-bridge';
+    } else if (oauth) {
       // Sign-in writes the selected account of the host's provider-accounts
       // pool; the single legacy file remains for hosts that predate the pool.
       // An explicit credential path still overrides both. Read the pool from
@@ -340,8 +364,8 @@ export function createPristineExecutionBoundary({
         [selectedProvider]: sourceCredential,
       });
       authMode = 'in-process-host-oauth-binding';
-      const sourceCatalog = join(sourceDataDir, oauth.modelCatalogFile);
-      if (oauth.modelCatalogFile && existsSync(sourceCatalog)) {
+      const sourceCatalog = oauth.modelCatalogFile && join(sourceDataDir, oauth.modelCatalogFile);
+      if (sourceCatalog && existsSync(sourceCatalog)) {
         copyFileSync(sourceCatalog, join(dataDir, oauth.modelCatalogFile));
         catalogCount = 1;
       }