mixdog 1.2.3 → 1.2.5

package/src/session-runtime/services/provider-admin.mjs

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { renameSync } from 'node:fs';
+import { modelProxyClientMode, serverModelCredentialsDisabledError } from '../../runtime/shared/model-proxy-mode.mjs';
 import { sameAccountIdentity } from '../../runtime/agent/orchestrator/providers/lib/oauth-token-utils.mjs';
 import {
   AGENT_PROVIDER_ENV,
@@ -502,6 +503,7 @@ function customProviderRows(providers, checkSecrets) {
 }
 
 export async function providerSetup(config = {}, options = {}) {
+  if (modelProxyClientMode()) return modelProxyProviderSetup(options);
   const providers = config.providers || {};
   const checkSecrets = options?.checkSecrets !== false;
   const keychain = checkSecrets ? keychainIssueFor(true) : null;
@@ -516,6 +518,59 @@ export async function providerSetup(config = {}, options = {}) {
   };
 }
 
+// The desktop's hidden custom models, in the override shape pickers already read.
+function hiddenModelOverrides(entry) {
+  const ids = Array.isArray(entry?.hiddenModels) ? entry.hiddenModels : [];
+  return Object.fromEntries(ids.filter((id) => typeof id === 'string').map((id) => [id, { hidden: true }]));
+}
+
+// SSH servers have no model credentials. Project only the PC's advertised
+// availability; account identities and credential management stay on the PC.
+async function modelProxyProviderSetup(options) {
+  const { loadModelProxyProviderConfig } = await import(
+    '../../runtime/agent/orchestrator/providers/model-proxy-provider.mjs'
+  );
+  let providers;
+  try {
+    providers = await loadModelProxyProviderConfig({ force: options.force === true, waitMs: 1_000 });
+  } catch (error) {
+    if (error?.code !== 'MODEL_PROXY_UNAVAILABLE') throw error;
+    return { managedByClient: true, unavailable: true, api: [], oauth: [], local: [] };
+  }
+  const project = (definitions, group, type) =>
+    definitions
+      .filter(({ id }) => Object.hasOwn(providers, id))
+      .map(({ id, name }) => {
+        const enabled = providers[id]?.enabled === true;
+        const authState = providers[id]?.authState;
+        // Older desktops advertise only enabled; new desktops distinguish a
+        // missing credential from a transiently unreadable, preserved adapter.
+        const authenticated = authState == null ? enabled : authState === 'present';
+        const usable = enabled && authState !== 'absent';
+        let status = usable ? 'Connected' : 'Not connected';
+        if (enabled && authState === 'unreadable') status = 'Checking…';
+        // Signed in but switched off on the desktop.
+        else if (!enabled && authState === 'present') status = 'Off';
+        return {
+          id, name, group, type, enabled,
+          authenticated,
+          usable,
+          ...(group === 'local' ? { detected: enabled } : {}),
+          ...(type === 'custom' ? { custom: true, modelOverrides: hiddenModelOverrides(providers[id]) } : {}),
+          status,
+        };
+      });
+  const custom = Object.entries(providers)
+    .filter(([id, entry]) => isCustomProviderId(id) && entry?.type === 'custom')
+    .map(([id]) => ({ id, name: id }));
+  return {
+    managedByClient: true,
+    api: [...project(API_PROVIDERS, 'api', 'api-key'), ...project(custom, 'api', 'custom')],
+    oauth: project(OAUTH_PROVIDERS, 'oauth', 'oauth'),
+    local: project([{ id: 'mixdog-local', name: 'Local Provider' }], 'local', 'local'),
+  };
+}
+
 function apiProviderStatusRow(p, config) {
   const configured = config.providers?.[p.id] || {};
   const envName = AGENT_PROVIDER_ENV[p.id] || p.env;
@@ -584,7 +639,12 @@ export function renderProviderStatus(config = {}) {
     .join('\n');
 }
 
+function requireLocalProviderManagement() {
+  if (modelProxyClientMode()) throw serverModelCredentialsDisabledError('Provider account management');
+}
+
 export async function authenticateProvider(provider, secret) {
+  requireLocalProviderManagement();
   const id = String(provider || '').trim();
   if (!id) throw new Error('provider id is required');
 
@@ -605,6 +665,7 @@ export async function authenticateProvider(provider, secret) {
 }
 
 export async function loginOAuthProvider(cfgMod, provider) {
+  requireLocalProviderManagement();
   const id = String(provider || '').trim();
   const oauth = availableOAuthProvider(id);
   if (!oauth) throw new Error(`unknown OAuth provider "${id}"`);
@@ -691,6 +752,7 @@ async function settleOAuthLogin(
 }
 
 export async function beginOAuthProviderLogin(cfgMod, provider, options = {}) {
+  requireLocalProviderManagement();
   const id = String(provider || '').trim();
   const oauth = availableOAuthProvider(id);
   if (!oauth) throw new Error(`unknown OAuth provider "${id}"`);
@@ -763,6 +825,10 @@ export async function beginOAuthProviderLogin(cfgMod, provider, options = {}) {
 }
 
 export function listProviderAccounts(provider) {
+  if (!OAUTH_BY_ID.has(provider)) throw new TypeError('Unknown OAuth provider.');
+  // Client mode: accounts live on the desktop, so this server's roster is
+  // empty whatever this server's own provider availability says.
+  if (modelProxyClientMode()) return { provider, auto: true, useCredits: false, selectedId: null, accounts: [] };
   const oauth = availableOAuthProvider(provider);
   if (!oauth) throw new TypeError('Unknown OAuth provider.');
   const pool = readProviderAccountPool(provider);
@@ -807,6 +873,7 @@ function defaultAccountRows(provider, oauth) {
 // Store the implicit signed-in `default` account in the roster, so a change or
 // a usage measurement has a row to land on. Returns the current roster view.
 export async function materializeProviderAccounts(provider) {
+  requireLocalProviderManagement();
   const current = listProviderAccounts(provider);
   if (readProviderAccountPool(provider).accounts.length || !current.accounts.length) return current;
   await registerProviderAccount(provider, 'default', { label: 'Account 1' });
@@ -814,6 +881,7 @@ export async function materializeProviderAccounts(provider) {
 }
 
 export async function updateProviderAccounts(provider, change) {
+  requireLocalProviderManagement();
   await materializeProviderAccounts(provider);
   await changeProviderAccounts(provider, change);
   // Picking an account by hand is a decision to use it NOW, so the refusal
@@ -825,6 +893,7 @@ export async function updateProviderAccounts(provider, change) {
 }
 
 export async function saveProviderApiKey(cfgMod, provider, secret) {
+  requireLocalProviderManagement();
   const id = String(provider || '').trim();
   if (!API_PROVIDER_IDS.has(id)) throw new Error(`unknown API-key provider "${id}"`);
   const value = String(secret || '').trim();
@@ -945,6 +1014,7 @@ async function resolveCustomInput(cfgMod, rawInput, options) {
 }
 
 export async function saveCustomProvider(cfgMod, rawInput) {
+  requireLocalProviderManagement();
   const {
     id: existingId,
     config,
@@ -999,6 +1069,7 @@ function plainPatch(value, allowed, label) {
 // removes the whole override; reasoning is merged key by key with the same
 // tri-state rules. Semantic validation is the runtime normalizer's.
 export async function updateCustomProviderModel(cfgMod, rawId, rawModelId, patch) {
+  requireLocalProviderManagement();
   const id = String(rawId || '').trim();
   const modelId = typeof rawModelId === 'string' ? rawModelId.trim() : '';
   if (!modelId) throw new TypeError('model id is required');
@@ -1079,6 +1150,7 @@ function withoutProviderReferences(config, id) {
 }
 
 export async function removeCustomProvider(cfgMod, rawId) {
+  requireLocalProviderManagement();
   const id = String(rawId || '').trim();
   existingCustomEntry(cfgMod, id);
   // Secret first: a real keychain failure (locked, permission) leaves the
@@ -1092,6 +1164,7 @@ export async function removeCustomProvider(cfgMod, rawId) {
 }
 
 export async function testCustomProvider(cfgMod, rawInput) {
+  requireLocalProviderManagement();
   const { id, config, apiKey } = await resolveCustomInput(cfgMod, rawInput, { requireModels: false });
   try {
     // The first visible manual model needs no discovery; otherwise the first
@@ -1128,6 +1201,7 @@ function customSecrets(apiKey, config) {
 }
 
 export async function discoverCustomProviderModels(cfgMod, rawInput) {
+  requireLocalProviderManagement();
   const { id, config, apiKey } = await resolveCustomInput(cfgMod, rawInput, { requireModels: false });
   try {
     const { createCustomProvider } = await loadCustomProviderModule();
@@ -1153,6 +1227,7 @@ function discoveryErrorView(error, secrets) {
 }
 
 export async function saveOpenAIUsageSessionKey(cfgMod, secret) {
+  requireLocalProviderManagement();
   const value = String(secret || '').trim();
   if (!value) throw new Error('OpenAI usage session key is required for credit lookup');
   await saveSecretAsync(SECRET_ACCOUNTS.openaiUsageSessionKey, value);
@@ -1161,6 +1236,7 @@ export async function saveOpenAIUsageSessionKey(cfgMod, secret) {
 }
 
 export async function saveOpenCodeGoUsageAuth(cfgMod, { apiKey } = {}) {
+  requireLocalProviderManagement();
   const secret = String(apiKey || '').trim();
   if (!secret) throw new Error('OpenCode console API key is required for usage lookup');
   // Subscription meters are read with a console service-account key holding the
@@ -1177,6 +1253,7 @@ export async function saveOpenCodeGoUsageAuth(cfgMod, { apiKey } = {}) {
 }
 
 export async function forgetProviderAuth(cfgModOrProvider, maybeProvider, requestedAccountId) {
+  requireLocalProviderManagement();
   const cfgMod = maybeProvider === undefined ? null : cfgModOrProvider;
   const id = String(maybeProvider === undefined ? cfgModOrProvider : maybeProvider || '').trim();
   const oauth = availableOAuthProvider(id);

package/src/session-runtime/session-create/session-options.mjs

@@ -16,6 +16,7 @@ function agentOwnedSessionFields(sessionProfile) {
     visibility: 'agent-only',
     agentTag: sessionProfile?.agentTag || null,
     taskType: sessionProfile?.taskType || null,
+    ...(sessionProfile?.routeFallbacks !== undefined ? { routeFallbacks: sessionProfile.routeFallbacks } : {}),
     permission: sessionProfile?.permission || undefined,
     permissionMode: sessionProfile?.permissionMode || undefined,
     schemaAllowedTools: Array.isArray(sessionProfile?.schemaAllowedTools)
@@ -38,6 +39,10 @@ export function sessionOptions(deps, coreMemoryContext) {
   const agentOwned = sessionProfile?.owner === 'agent' || sessionProfile?.visibility === 'agent-only';
   // Agent-owned sessions keep the Active Workflow block only.
   const workflowContext = agentOwned ? packContext : leadWorkflowContext;
+  const callerDisallowedTools = [
+    ...(agentOwned ? [] : LEAD_DISALLOWED_TOOLS),
+    ...(!agentOwned && rt.disallowDelegation ? ['agent'] : []),
+  ];
   const sessionOpts = {
     ...(rt.reservedSessionId ? { id: rt.reservedSessionId } : {}),
     provider: rt.route.provider,
@@ -59,11 +64,8 @@ export function sessionOptions(deps, coreMemoryContext) {
     ...(rt.approvalMode ? { approvalMode: rt.approvalMode } : {}),
     clientHostPid: sessionProfile?.clientHostPid || process.pid,
     mcpScopeId: rt.mcpScopeId,
-    disallowedTools: [
-      ...(agentOwned ? [] : LEAD_DISALLOWED_TOOLS),
-      ...(!agentOwned && rt.disallowDelegation ? ['agent'] : []),
-      ...featureDisallowedTools(),
-    ],
+    callerDisallowedTools,
+    disallowedTools: [...callerDisallowedTools, ...featureDisallowedTools()],
     cwd: rt.currentCwd,
     ...(rt.desktopSession && typeof rt.desktopSession === 'object' ? { desktopSession: rt.desktopSession } : {}),
     coreMemoryContext,

package/src/session-runtime/session-create/session-start-hook.mjs

@@ -1,6 +1,7 @@
 // session-create/session-start-hook.mjs — the SessionStart project hook:
 // best-effort dispatch whose additionalContext lands before the first turn.
 import { runAbortable, throwIfAborted } from '../../runtime/shared/abort-race.mjs';
+import { contextAckMessage } from '../../runtime/agent/orchestrator/session/compact/user-message-kind.mjs';
 
 function sessionStartSource(reason) {
   const reasonText = String(reason || '');
@@ -29,7 +30,7 @@ export async function dispatchSessionStart(deps, reason, signal) {
         role: 'user',
         content: `<system-reminder>\n# SessionStart Hook Context\n${startContext.trim()}\n</system-reminder>`,
       });
-      rt.session.messages.push({ role: 'assistant', content: '.' });
+      rt.session.messages.push(contextAckMessage());
       rt.session.updatedAt = Date.now();
     }
   } catch {

package/src/session-runtime/session-transcript.mjs

@@ -1,4 +1,4 @@
-// Session transcript writer: every user-facing main session owns a
+// Session transcript writer: every session owns a
 // conversation JSONL that the always-on memory watcher tails. The mutable
 // runtime-core locals it needs are injected as accessors.
 import { createTranscriptWriter } from '../runtime/shared/transcript-writer.mjs';
@@ -20,12 +20,10 @@ export function createSessionTranscript({ getSession, getCwd }) {
     ensureSessionTranscriptWriter,
   };
 
-  // Every user-facing main session owns a conversation JSONL. The always-on
-  // memory watcher tails this same file. Agent-owned sessions stay out of the
-  // user's recall pool and generate a session-local handoff when compacting.
+  // Agent conversations use the same writer but remain outside memory ingestion.
   function ensureSessionTranscriptWriter() {
     const session = getSession();
-    if (!session?.id || isAgentOwner(session)) return false;
+    if (!session?.id) return false;
     const cwd = getCwd();
     const key = `${session.id}\u0000${cwd}`;
     if (writerKey !== key) {
@@ -35,6 +33,7 @@ export function createSessionTranscript({ getSession, getCwd }) {
           sessionId: session.id,
           cwd,
           pid: process.pid,
+          memoryEligible: !isAgentOwner(session),
         });
         writerKey = key;
       } catch (error) {

package/src/session-runtime/session-turn-api.mjs

@@ -1,6 +1,6 @@
 /**
  * src/session-runtime/session-turn-api.mjs - turn execution (ask) plus the
- * between-turn session, sharing, and agent/tool-surface commands. Stateless
+ * between-turn session and agent/tool-surface commands. Stateless
  * helpers are imported by the groups; the runtime injects live
  * getters/setters for the mutable session/mode/turn-counter/transcript-writer
  * locals plus the closure callbacks.
@@ -8,7 +8,6 @@
 import { createTurnRunner } from './turn/turn-run.mjs';
 import { createSessionOps } from './turn/session-ops.mjs';
 import { createCompactionGate } from './turn/compaction-gate.mjs';
-import { createShareOps } from './turn/share-ops.mjs';
 import { createAgentOps } from './turn/agent-ops.mjs';
 import { createSideQuestionOps } from './turn/side-question-ops.mjs';
 
@@ -19,13 +18,11 @@ export function createSessionTurnApi(deps) {
   const afterCompaction = gate.after;
   const runner = createTurnRunner({ ...deps, runPendingCompact: gate.run });
   const session = createSessionOps(deps);
-  const share = createShareOps(deps);
   const agent = createAgentOps(deps);
   const side = createSideQuestionOps(deps);
   return {
     askSide: side.askSide,
     cancelSide: side.cancelSide,
-    enqueueRemoteAttachedPrompt: runner.enqueueRemoteAttachedPrompt,
     getTurnLiveness: runner.getTurnLiveness,
     ask: afterCompaction(runner.ask),
     clear: afterCompaction(session.clear),
@@ -36,14 +33,11 @@ export function createSessionTurnApi(deps) {
     interruptTaskWait: session.interruptTaskWait,
     readModelMessages: session.readModelMessages,
     onAgentStatusChange: session.onAgentStatusChange,
-    takeRemoteInjections: share.takeRemoteInjections,
-    pendingSpoolPath: share.pendingSpoolPath,
-    publishSessionPresence: share.publishSessionPresence,
-    clearSessionPresence: share.clearSessionPresence,
-    sessionOwnerGone: share.sessionOwnerGone,
     agentControl: agent.agentControl,
     taskControl: agent.taskControl,
     stopShellJob: agent.stopShellJob,
+    releaseShellJob: agent.releaseShellJob,
+    listShellJobs: agent.listShellJobs,
     onNotification: agent.onNotification,
     toolsStatus: agent.toolsStatus,
     selectTools: agent.selectTools,

package/src/session-runtime/settings-builtin-tools-api.mjs

@@ -9,10 +9,7 @@ import {
 } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { featureEnvOverride, moduleEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { LOCAL_PROVIDER_ID } from '../runtime/local-provider/managed-runtime.mjs';
-import {
-  INSTRUCTION_FILES_MODES,
-  normalizeInstructionFilesMode,
-} from '../runtime/shared/instruction-files-mode.mjs';
+import { INSTRUCTION_FILES_MODES, normalizeInstructionFilesMode } from '../runtime/shared/instruction-files-mode.mjs';
 import { getEmbeddingInfo } from '../runtime/memory/lib/embedding-provider.mjs';
 import { onnxRuntimeSupported } from '../runtime/shared/onnx-runtime-support.mjs';
 import {
@@ -24,7 +21,7 @@ import {
   shutdownEffortJudge,
 } from '../runtime/effort-judge/judge-client.mjs';
 
-const TOGGLEABLE_BUILTINS = ['git', 'office', 'tidy', 'localProvider', 'autoEffort', 'visualize'];
+const TOGGLEABLE_BUILTINS = ['git', 'office', 'tidy', 'localProvider', 'autoEffort', 'visualize', 'media'];
 
 function setLocalProviderEnabledInConfig(configLike, enabled) {
   const next = { ...(configLike || {}) };
@@ -113,6 +110,12 @@ export function createBuiltinToolSettings(
           enabled: featureEnvOverride('MIXDOG_FEATURE_VISUALIZE') ?? moduleEnabled(config, 'visualize', true),
           installed: true,
         },
+        // Image and video generation ships with the runtime and is on unless
+        // switched off; the image/video skills follow it (`requires: media`).
+        media: {
+          enabled: featureEnvOverride('MIXDOG_FEATURE_MEDIA') ?? moduleEnabled(config, 'media', true),
+          installed: true,
+        },
         localProvider: {
           ...localProvider,
           ...localSettings.status(),
@@ -168,7 +171,7 @@ export function createBuiltinToolSettings(
     },
     async setBuiltinToolEnabled(name, enabled) {
       if (!TOGGLEABLE_BUILTINS.includes(name)) {
-        throw new TypeError('Built-in tool must be git, office, tidy, localProvider, autoEffort, or visualize.');
+        throw new TypeError('Built-in tool must be git, office, tidy, localProvider, autoEffort, visualize, or media.');
       }
       if (name === 'autoEffort' && enabled !== false && !onnxRuntimeSupported()) {
         throw new Error(EFFORT_JUDGE_UNSUPPORTED);

package/src/session-runtime/setup-tool/executor.mjs

@@ -97,6 +97,7 @@ function routeInput(source) {
   if (Object.hasOwn(source, 'contextPercent')) next.contextPercent = source.contextPercent;
   if (Object.hasOwn(source, 'contextTokens')) next.contextTokens = source.contextTokens;
   if (Object.hasOwn(source, 'disabled')) next.disabled = source.disabled;
+  if (Object.hasOwn(source, 'fallbacks')) next.fallbacks = source.fallbacks.map(routeInput);
   return next;
 }
 
@@ -119,6 +120,7 @@ function publicProviderRows(setup) {
     ...extra,
   });
   return {
+    ...(setup?.managedByClient === true ? { managedByClient: true, unavailable: setup.unavailable === true } : {}),
     pendingSecrets: setup?.pendingSecrets === true,
     api: (setup?.api || []).map((row) =>
       pick(row, {
@@ -143,7 +145,8 @@ function publicProviderRows(setup) {
 }
 
 /** Minimal provider rows for the model: only providers with a credential (or
- *  one needing re-authentication), counts instead of account rosters. */
+ *  one needing re-authentication), counts instead of account rosters. Without
+ *  `accountCount` (desktop-owned accounts) no counts are reported. */
 function configuredProviderRows(rows, accountCount) {
   const providers = [];
   let notConfigured = 0;
@@ -157,13 +160,15 @@ function configuredProviderRows(rows, accountCount) {
         notConfigured += 1;
         continue;
       }
+      let accounts = {};
+      if (kind === 'oauth' && accountCount) accounts = { accounts: row.authenticated ? accountCount(row.id) : 0 };
       providers.push({
         id: row.id,
         kind,
         authenticated: row.authenticated,
         status: row.status,
         ...(row.reauthRequired ? { reauthRequired: true } : {}),
-        ...(kind === 'oauth' ? { accounts: row.authenticated ? accountCount(row.id) : 0 } : {}),
+        ...accounts,
       });
     }
   }
@@ -331,6 +336,11 @@ const SETUP_STATUS_READERS = {
   shell: (rt) => rt.getSystemShell?.() || {},
   providers: async (rt, { detail }) => {
     const rows = publicProviderRows(await rt.getProviderSetup?.({}));
+    // Client mode: the desktop owns accounts, so the server roster is never read.
+    if (rows.managedByClient) {
+      if (detail) return rows;
+      return { managedByClient: true, unavailable: rows.unavailable, ...configuredProviderRows(rows) };
+    }
     if (!detail) return configuredProviderRows(rows, (id) => rt.getProviderAccounts(id).accounts.length);
     rows.oauth = rows.oauth.map((row) =>
       row.authenticated ? { ...row, accounts: publicAccounts(rt.getProviderAccounts(row.id)) } : row
@@ -369,6 +379,9 @@ function validateSetupInput(args) {
     if (action !== 'set_agent_route' && Object.hasOwn(args.route, 'disabled')) {
       throw new Error('route.disabled is only accepted by set_agent_route');
     }
+    if (Object.hasOwn(args.route, 'fallbacks') && !['set_agent_route', 'set_web_search_route'].includes(action)) {
+      throw new Error('route.fallbacks is only accepted by set_agent_route and set_web_search_route');
+    }
     for (const field of ['contextPercent', 'contextTokens', 'autoEffort']) {
       if (action !== 'set_route' && action !== 'set_agent_route' && Object.hasOwn(args.route, field)) {
         throw new Error(`route.${field} is only accepted by set_route and set_agent_route`);
@@ -436,7 +449,7 @@ const SETUP_ACTION_HANDLERS = {
   open: (_rt, args, { openSurface }) => openSurface(args.target),
   set_route: async (rt, args) => {
     const route = routeInput(args.route);
-    const next = await rt.setRoute(route);
+    const next = await rt.setRoute(route, { keepMainModel: false });
     return { route: next, appliesTo: 'next session (a conversation keeps its frozen route)' };
   },
   set_agent_route: async (rt, args) => {
@@ -554,6 +567,7 @@ const SETUP_ACTION_HANDLERS = {
   forget_provider_auth: async (rt, args) => {
     const name = requireText(args.name, 'name');
     const setup = await rt.getProviderSetup({});
+    if (setup?.managedByClient) throw new Error('Manage provider accounts in the local desktop window.');
     if (!(setup?.oauth || []).some((row) => row.id === name)) {
       if (Object.hasOwn(args, 'accountId')) throw new Error('accountId applies only to OAuth providers');
       return rt.forgetProviderAuth(name);
@@ -566,8 +580,12 @@ const SETUP_ACTION_HANDLERS = {
     const accountId = Object.hasOwn(args, 'accountId') ? requireText(args.accountId, 'accountId') : accounts[0].id;
     return { ...(await rt.forgetProviderAuth(name, accountId)), accountId };
   },
-  set_provider_account: async (rt, args) =>
-    publicAccounts(await rt.updateProviderAccounts(requireText(args.name, 'name'), args.providerAccount)),
+  set_provider_account: async (rt, args) => {
+    if ((await rt.getProviderSetup?.({}))?.managedByClient) {
+      throw new Error('Manage provider accounts in the local desktop window.');
+    }
+    return publicAccounts(await rt.updateProviderAccounts(requireText(args.name, 'name'), args.providerAccount));
+  },
   add_mcp_server: async (rt, args) => {
     const server = mcpServerInput(args);
     requireText(server.name, 'server.name');

package/src/session-runtime/setup-tool/extended-actions.mjs

@@ -33,10 +33,7 @@ function compactModelRow(row) {
 }
 
 const isPresent = (value) =>
-  value != null &&
-  value !== '' &&
-  value !== false &&
-  !(typeof value === 'object' && !Object.keys(value).length);
+  value != null && value !== '' && value !== false && !(typeof value === 'object' && !Object.keys(value).length);
 
 /** Everything set_route can use for one model; empty and false fields omitted. */
 function modelDetail(row) {
@@ -69,10 +66,13 @@ function modelDetail(row) {
 function findModel(rows, id, provider) {
   const matches = rows.filter((row) => row.id === id && (!provider || row.provider === provider));
   if (!matches.length) {
-    throw new Error(`model "${id}" not found${provider ? ` for provider "${provider}"` : ''}; list_models with catalog.provider returns its model ids`);
+    throw new Error(
+      `model "${id}" not found${provider ? ` for provider "${provider}"` : ''}; list_models with catalog.provider returns its model ids`
+    );
   }
   const providers = [...new Set(matches.map((row) => row.provider))];
-  if (providers.length > 1) throw new Error(`model "${id}" is offered by ${providers.join(', ')}; pass catalog.provider`);
+  if (providers.length > 1)
+    throw new Error(`model "${id}" is offered by ${providers.join(', ')}; pass catalog.provider`);
   return matches[0];
 }
 

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -116,7 +116,7 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
   catalog: object({
     provider: {
       ...text,
-      description: 'list_models: omit for the provider index; set for that provider\'s compact model rows.',
+      description: "list_models: omit for the provider index; set for that provider's compact model rows.",
     },
     model: {
       ...text,
@@ -124,7 +124,12 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
         'list_models: one model id; returns its full options (efforts, fast, service tiers, modelParameterOptions, parameterVariants) for set_route. Add provider when several offer the id.',
     },
     page: { type: 'integer', minimum: 1, description: 'list_models with provider: 1-based page; default 1.' },
-    limit: { type: 'integer', minimum: 1, maximum: 100, description: 'list_models with provider: rows per page; default 25.' },
+    limit: {
+      type: 'integer',
+      minimum: 1,
+      maximum: 100,
+      description: 'list_models with provider: rows per page; default 25.',
+    },
     webSearch: { ...boolean, description: 'list_models: native-search capable models only.' },
     refresh: { ...boolean, description: 'list_models: refresh the catalog first.' },
   }),

package/src/session-runtime/setup-tool/tool-defs.mjs

@@ -156,6 +156,17 @@ const ROUTE_SCHEMA = {
   },
 };
 
+ROUTE_SCHEMA.properties.fallbacks = {
+  type: 'array',
+  description: 'Agent and Web Search routes only: ordered fallback models; [] clears the list.',
+  items: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['provider', 'model'],
+    properties: Object.fromEntries(Object.entries(ROUTE_SCHEMA.properties).filter(([key]) => key !== 'disabled')),
+  },
+};
+
 export const SETUP_TOOL_DEFS = Object.freeze([
   {
     name: 'setup',
@@ -272,7 +283,8 @@ export const SETUP_TOOL_DEFS = Object.freeze([
               properties: { id: { type: 'string' }, label: { type: 'string', maxLength: 80 } },
             },
           },
-          description: 'set_provider_account: OAuth account change; account ids from status providers with detail:true.',
+          description:
+            'set_provider_account: OAuth account change; account ids from status providers with detail:true.',
         },
         modelId: {
           type: 'string',