mixdog 1.3.4 → 1.4.0

package/src/session-runtime/model-route/route-tuning.mjs

@@ -17,10 +17,14 @@ export function createRouteTuning(deps, persist) {
    *  is already the Main model (persistAdoptedModelSettings: tunesNonMainModel),
    *  so the lead preset's model is rewritten with itself and never changes. A
    *  live route without a model normalizes to nothing and writes no preset. */
-  async function commitRouteTuning(fastCapable, modelMeta) {
-    persist.saveRouteModelSettings(getRoute(), fastCapable);
-    const leadRoute = persist.persistAdoptedModelSettings(getRoute());
-    if (leadRoute) setRouteState(resolveRoute(getConfig(), { model: workflowPresetId('lead') }));
+  async function commitRouteTuning(fastCapable, modelMeta, { sessionOnly = false } = {}) {
+    // sessionOnly: the live route and session change; the saved model
+    // settings and the config stay as the user left them.
+    if (!sessionOnly) {
+      persist.saveRouteModelSettings(getRoute(), fastCapable);
+      const leadRoute = persist.persistAdoptedModelSettings(getRoute());
+      if (leadRoute) setRouteState(resolveRoute(getConfig(), { model: workflowPresetId('lead') }));
+    }
     await refreshRouteEffort(modelMeta);
     persist.applySessionTuning();
   }
@@ -65,7 +69,7 @@ export function createRouteTuning(deps, persist) {
     async toggleFast() {
       return await setFast(!(getRoute().fast === true));
     },
-    async setEffort(value) {
+    async setEffort(value, { sessionOnly = false } = {}) {
       const normalized = normalizeEffortInput(value);
       // An explicit level is the user's choice for this route: Auto effort
       // would replace it on the next turn (its base is fixed), so the pick
@@ -73,7 +77,7 @@ export function createRouteTuning(deps, persist) {
       setRouteState({ ...getRoute(), effort: normalized, ...(normalized ? { autoEffort: false } : {}) });
       const modelMeta = await lookupModelMeta(getRoute().provider, getRoute().model);
       const fastCapable = selectionFastCapable(getRoute().provider, modelMeta, normalized, getRoute().modelParameters);
-      await commitRouteTuning(fastCapable, modelMeta);
+      await commitRouteTuning(fastCapable, modelMeta, { sessionOnly });
       return getRoute();
     },
   };

package/src/session-runtime/notification-bus.mjs

@@ -3,27 +3,17 @@
 // pending queue so the model sees it next turn. The delivered registry keeps
 // those two paths from double-injecting the same completion.
 import { modelVisibleToolCompletionMessage } from '../runtime/shared/tool-execution-contract.mjs';
-import {
-  PENDING_MODE_TASK_NOTIFICATION,
-  markCompletionEntry,
-} from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
-import {
-  isDeliveredCompletion,
-  logDuplicateSkip,
-  recordDeliveredCompletion,
-} from '../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+import { PENDING_MODE_TASK_NOTIFICATION } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
+import { recordDeliveredCompletion } from '../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
 import { shouldMirrorCompletionToPendingQueue } from './runtime-tool-routing.mjs';
 import { notifyTrace } from '../runtime/shared/notify-trace.mjs';
+import { cleanSessionId, createListenerBindings, sessionListenersOf } from './notification-listeners.mjs';
+import { createCompletionQueue } from './notification-completion-queue.mjs';
 
-const sessionNotificationListeners = new Map();
 // A completion that waits this long between enqueue and wake is reported: the
 // queue is durable, so the delay is a scheduling symptom, not a lost message.
 const WAKE_DELAY_REPORT_MS = 1_000;
 
-function cleanSessionId(value) {
-  return String(value || '').trim();
-}
-
 // A queued completion only reaches the model on the next turn, so a session
 // with no user input pending is woken with an empty turn. One wake per session
 // runs at a time, and a completion suppressed by that in-flight wake is
@@ -63,7 +53,9 @@ export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi,
         if (typeof beforeWake === 'function') {
           try {
             await beforeWake(ownerSessionId);
-          } catch {}
+          } catch {
+            // The pre-wake hook is best-effort; the wake proceeds without it.
+          }
           if (cleanSessionId(getCurrentSessionId()) !== ownerSessionId || !ownerOpen(ownerSessionId)) return;
         }
         // The wake continues the user turn that launched the worker, so its
@@ -102,10 +94,15 @@ export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi,
   };
 }
 
-function emitToListeners(source, content, meta = {}) {
+function emitToListeners(source, content, meta = {}, origin = null) {
   const text = String(content || '').trim();
   if (!text) return { handled: false, modelVisibleDelivered: false };
-  const event = { content: text, meta: meta && typeof meta === 'object' ? meta : {} };
+  const event = {
+    content: text,
+    meta: meta && typeof meta === 'object' ? meta : {},
+    // The notification's provenance apart from its meta (PROMPT_ORIGIN_CHANNEL).
+    ...(origin ? { origin } : {}),
+  };
   let handled = false;
   for (const listener of [...source]) {
     try {
@@ -118,8 +115,9 @@ function emitToListeners(source, content, meta = {}) {
 }
 
 export function createNotificationBus({ listeners, mgr, onCompletionQueued, getOwnerLifecycle }) {
-  const boundSessionListeners = new Map();
-  const queuedCompletionIds = new Map();
+  const { subscribeRuntimeNotification, bindRuntimeNotificationSession, clearRuntimeNotifications } =
+    createListenerBindings({ listeners });
+  const enqueueCompletion = createCompletionQueue({ mgr, onCompletionQueued });
 
   // Owner identity + lifecycle generation. A closing/terminal owner (or a
   // callback captured under an earlier generation) keeps its result for
@@ -137,12 +135,14 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
     return emitToListeners(listeners, content, meta);
   }
 
-  function notifySession(sessionId, content, meta = {}) {
+  // `origin`: the notification's provenance (PROMPT_ORIGIN_CHANNEL for an
+  // inbound channel message), carried to the queue beside its mode.
+  function notifySession(sessionId, content, meta = {}, { origin = null } = {}) {
     const targetSessionId = cleanSessionId(sessionId);
     if (!targetSessionId) return false;
-    const targetListeners = sessionNotificationListeners.get(targetSessionId) || [];
+    const targetListeners = sessionListenersOf(targetSessionId);
     const open = ownerOpen(targetSessionId);
-    const { handled } = emitToListeners(targetListeners, content, open ? meta : closedMeta(meta));
+    const { handled } = emitToListeners(targetListeners, content, open ? meta : closedMeta(meta), origin);
     if (handled) return true;
     if (!open) return false;
     if (typeof mgr.enqueuePendingMessage !== 'function') return false;
@@ -151,7 +151,13 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
       // is the runtime reporting, exactly as an attached TUI queues it: a
       // task notification, so text inside it — fenced external webhook values
       // included — never drives explicit skill selection.
-      return mgr.enqueuePendingMessage(targetSessionId, { content, mode: PENDING_MODE_TASK_NOTIFICATION }) > 0;
+      return (
+        mgr.enqueuePendingMessage(targetSessionId, {
+          content,
+          mode: PENDING_MODE_TASK_NOTIFICATION,
+          ...(origin ? { origin } : {}),
+        }) > 0
+      );
     } catch {
       return false;
     }
@@ -164,50 +170,14 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
   function notifySessionUi(sessionId, content, meta = {}) {
     const targetSessionId = cleanSessionId(sessionId);
     if (!targetSessionId) return false;
-    const targetListeners = sessionNotificationListeners.get(targetSessionId) || [];
+    const targetListeners = sessionListenersOf(targetSessionId);
     return emitToListeners(targetListeners, content, meta).handled;
   }
 
-  // Enqueue the model-visible twin unless it was already delivered; returns
-  // true when the caller may treat the completion as delivered.
-  function enqueueCompletion(callerSessionId, text, meta, path) {
-    const visible = modelVisibleToolCompletionMessage(text, meta);
-    // Non-completion notifications yield '' here and are never queued.
-    if (!visible) return false;
-    if (isDeliveredCompletion({ executionId: meta?.execution_id, text: visible })) {
-      // Delivered + ACKed on the TUI path: suppress the duplicate but report
-      // DELIVERED so the caller stops retrying.
-      logDuplicateSkip(path, { executionId: meta?.execution_id, text: visible });
-      return true;
-    }
-    const entry = markCompletionEntry(visible, { executionId: meta?.execution_id, meta });
-    const queueKey = `${callerSessionId}:${entry.id}`;
-    if (queuedCompletionIds.has(queueKey)) {
-      logDuplicateSkip(`${path}-queued`, { executionId: meta?.execution_id, text: visible });
-      return true;
-    }
-    const enqueued = mgr.enqueuePendingMessage(callerSessionId, entry) > 0;
-    if (!enqueued) return false;
-    queuedCompletionIds.set(queueKey, Date.now());
-    while (queuedCompletionIds.size > 512) queuedCompletionIds.delete(queuedCompletionIds.keys().next().value);
-    if (typeof onCompletionQueued === 'function') {
-      try {
-        onCompletionQueued({
-          sessionId: callerSessionId,
-          executionId: meta?.execution_id || null,
-          enqueuedAt: entry.enqueuedAt,
-        });
-      } catch {
-        /* wake-up is best-effort; the durable queue remains authoritative */
-      }
-    }
-    return true;
-  }
-
   function notifySessionCompletion(sessionId, text, meta = {}, capturedGeneration = undefined) {
     const targetSessionId = cleanSessionId(sessionId);
     if (!targetSessionId) return false;
-    const targetListeners = sessionNotificationListeners.get(targetSessionId) || [];
+    const targetListeners = sessionListenersOf(targetSessionId);
     const open = ownerOpen(targetSessionId, capturedGeneration);
     const ownerMeta = {
       ...(meta && typeof meta === 'object' ? meta : {}),
@@ -262,62 +232,6 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
     return (text, meta = {}) => notifySessionCompletion(ownerSessionId, text, meta, generation);
   }
 
-  function bindListenerToSession(sessionId, listener) {
-    const ownerSessionId = cleanSessionId(sessionId);
-    if (!ownerSessionId || typeof listener !== 'function') return;
-    let bucket = sessionNotificationListeners.get(ownerSessionId);
-    if (!bucket) {
-      bucket = new Set();
-      sessionNotificationListeners.set(ownerSessionId, bucket);
-    }
-    bucket.add(listener);
-    let ownedBucket = boundSessionListeners.get(ownerSessionId);
-    if (!ownedBucket) {
-      ownedBucket = new Set();
-      boundSessionListeners.set(ownerSessionId, ownedBucket);
-    }
-    ownedBucket.add(listener);
-  }
-
-  function unbindListener(listener) {
-    for (const [sessionId, ownedBucket] of boundSessionListeners) {
-      if (!ownedBucket.delete(listener)) continue;
-      const bucket = sessionNotificationListeners.get(sessionId);
-      bucket?.delete(listener);
-      if (bucket?.size === 0) sessionNotificationListeners.delete(sessionId);
-      if (ownedBucket.size === 0) boundSessionListeners.delete(sessionId);
-    }
-  }
-
-  function subscribeRuntimeNotification(sessionId, listener) {
-    const ownerSessionId = cleanSessionId(sessionId);
-    if (typeof listener !== 'function') return () => {};
-    listeners.add(listener);
-    bindListenerToSession(ownerSessionId, listener);
-    return () => {
-      listeners.delete(listener);
-      unbindListener(listener);
-    };
-  }
-
-  function bindRuntimeNotificationSession(sessionId) {
-    const ownerSessionId = cleanSessionId(sessionId);
-    if (!ownerSessionId) return false;
-    for (const listener of listeners) bindListenerToSession(ownerSessionId, listener);
-    return true;
-  }
-
-  function clearRuntimeNotifications() {
-    for (const [sessionId, ownedBucket] of boundSessionListeners) {
-      const bucket = sessionNotificationListeners.get(sessionId);
-      if (!bucket) continue;
-      for (const listener of ownedBucket) bucket.delete(listener);
-      if (bucket.size === 0) sessionNotificationListeners.delete(sessionId);
-    }
-    boundSessionListeners.clear();
-    listeners.clear();
-  }
-
   return {
     emitRuntimeNotification,
     notifySession,

package/src/session-runtime/notification-completion-queue.mjs

@@ -0,0 +1,54 @@
+// The model-visible queue path of a terminal tool completion
+// (notification-bus.mjs): enqueue its twin once, skipping a completion the TUI
+// path already delivered or this bus already queued.
+import { modelVisibleToolCompletionMessage } from '../runtime/shared/tool-execution-contract.mjs';
+import { markCompletionEntry } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
+import {
+  isDeliveredCompletion,
+  logDuplicateSkip,
+} from '../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+
+// Bounded memory of `${session}:${entry id}` keys this bus queued.
+const QUEUED_COMPLETION_IDS_MAX = 512;
+
+export function createCompletionQueue({ mgr, onCompletionQueued }) {
+  const queuedCompletionIds = new Map();
+
+  // Enqueue the model-visible twin unless it was already delivered; returns
+  // true when the caller may treat the completion as delivered.
+  return function enqueueCompletion(callerSessionId, text, meta, path) {
+    const visible = modelVisibleToolCompletionMessage(text, meta);
+    // Non-completion notifications yield '' here and are never queued.
+    if (!visible) return false;
+    if (isDeliveredCompletion({ executionId: meta?.execution_id, text: visible })) {
+      // Delivered + ACKed on the TUI path: suppress the duplicate but report
+      // DELIVERED so the caller stops retrying.
+      logDuplicateSkip(path, { executionId: meta?.execution_id, text: visible });
+      return true;
+    }
+    const entry = markCompletionEntry(visible, { executionId: meta?.execution_id, meta });
+    const queueKey = `${callerSessionId}:${entry.id}`;
+    if (queuedCompletionIds.has(queueKey)) {
+      logDuplicateSkip(`${path}-queued`, { executionId: meta?.execution_id, text: visible });
+      return true;
+    }
+    const enqueued = mgr.enqueuePendingMessage(callerSessionId, entry) > 0;
+    if (!enqueued) return false;
+    queuedCompletionIds.set(queueKey, Date.now());
+    while (queuedCompletionIds.size > QUEUED_COMPLETION_IDS_MAX) {
+      queuedCompletionIds.delete(queuedCompletionIds.keys().next().value);
+    }
+    if (typeof onCompletionQueued === 'function') {
+      try {
+        onCompletionQueued({
+          sessionId: callerSessionId,
+          executionId: meta?.execution_id || null,
+          enqueuedAt: entry.enqueuedAt,
+        });
+      } catch {
+        /* wake-up is best-effort; the durable queue remains authoritative */
+      }
+    }
+    return true;
+  };
+}

package/src/session-runtime/notification-listeners.mjs

@@ -0,0 +1,76 @@
+// Session-bound runtime notification listeners (notification-bus.mjs). The
+// per-session listener sets are process-wide; each bus owns which of its
+// listeners it bound to which session, and unbinds only those.
+
+const sessionNotificationListeners = new Map();
+
+export function cleanSessionId(value) {
+  return String(value || '').trim();
+}
+
+/** The listeners bound to one session (an empty array when none). */
+export function sessionListenersOf(sessionId) {
+  return sessionNotificationListeners.get(sessionId) || [];
+}
+
+export function createListenerBindings({ listeners }) {
+  const boundSessionListeners = new Map();
+
+  function bindListenerToSession(sessionId, listener) {
+    const ownerSessionId = cleanSessionId(sessionId);
+    if (!ownerSessionId || typeof listener !== 'function') return;
+    let bucket = sessionNotificationListeners.get(ownerSessionId);
+    if (!bucket) {
+      bucket = new Set();
+      sessionNotificationListeners.set(ownerSessionId, bucket);
+    }
+    bucket.add(listener);
+    let ownedBucket = boundSessionListeners.get(ownerSessionId);
+    if (!ownedBucket) {
+      ownedBucket = new Set();
+      boundSessionListeners.set(ownerSessionId, ownedBucket);
+    }
+    ownedBucket.add(listener);
+  }
+
+  function unbindListener(listener) {
+    for (const [sessionId, ownedBucket] of boundSessionListeners) {
+      if (!ownedBucket.delete(listener)) continue;
+      const bucket = sessionNotificationListeners.get(sessionId);
+      bucket?.delete(listener);
+      if (bucket?.size === 0) sessionNotificationListeners.delete(sessionId);
+      if (ownedBucket.size === 0) boundSessionListeners.delete(sessionId);
+    }
+  }
+
+  function subscribeRuntimeNotification(sessionId, listener) {
+    const ownerSessionId = cleanSessionId(sessionId);
+    if (typeof listener !== 'function') return () => {};
+    listeners.add(listener);
+    bindListenerToSession(ownerSessionId, listener);
+    return () => {
+      listeners.delete(listener);
+      unbindListener(listener);
+    };
+  }
+
+  function bindRuntimeNotificationSession(sessionId) {
+    const ownerSessionId = cleanSessionId(sessionId);
+    if (!ownerSessionId) return false;
+    for (const listener of listeners) bindListenerToSession(ownerSessionId, listener);
+    return true;
+  }
+
+  function clearRuntimeNotifications() {
+    for (const [sessionId, ownedBucket] of boundSessionListeners) {
+      const bucket = sessionNotificationListeners.get(sessionId);
+      if (!bucket) continue;
+      for (const listener of ownedBucket) bucket.delete(listener);
+      if (bucket.size === 0) sessionNotificationListeners.delete(sessionId);
+    }
+    boundSessionListeners.clear();
+    listeners.clear();
+  }
+
+  return { subscribeRuntimeNotification, bindRuntimeNotificationSession, clearRuntimeNotifications };
+}

package/src/session-runtime/owned-automation-run.mjs

@@ -27,6 +27,21 @@ const defaultLog = (line) => process.stderr.write(`mixdog routines: ${line}\n`);
 // received webhooks and the app's "Run now" all come through here.
 const activeRuns = new Set();
 
+/**
+ * Reserve `kind:name` against runs in this process for a rename. Null when a
+ * run is in flight; otherwise a release function. The check and the reservation
+ * are one synchronous step, and a run that finds the reservation is skipped as
+ * an overlap (runOwnedAutomation), so none can start under the name meanwhile.
+ * "Run now" takes the same reservation to hold the name from its read of the
+ * row through its outcome stamps (runOwnedAutomation `reserved`).
+ */
+export function beginAutomationRename(kind, name, active = activeRuns) {
+  const key = `${kind}:${name}`;
+  if (active.has(key)) return null;
+  active.add(key);
+  return () => active.delete(key);
+}
+
 // The PG record of each kind, imported on first use.
 const RECORDS = {
   schedule: () =>
@@ -103,7 +118,8 @@ async function queueResult(row, item, entry, { deliver, recordDelivery, onDelive
  * result }` (`signal` is the caller's cancellation, if any). Resolves the
  * outcome, or `{ skipped: true, reason: 'owner' | 'overlap' | 'backoff' | 'paused' }`
  * (an owner skip also names `ownerProblem` and its `message`); a failed run
- * rejects.
+ * rejects. `reserved`: the caller already holds `kind:name` (beginAutomationRename)
+ * and releases it itself, so this run neither checks for nor releases it.
  */
 export async function runOwnedAutomation(kind, row, run, deps = {}) {
   if (!row?.name) throw new Error(`${kind} run: a ${kind} row is required`);
@@ -112,9 +128,11 @@ export async function runOwnedAutomation(kind, row, run, deps = {}) {
     active = activeRuns,
     limits = ROUTINE_LIMITS,
     attended = false,
+    reserved = false,
     signal = null,
     now = Date.now,
-    ownerProblem = routineOwnerProblem,
+    // `row` is stored: for Mixy, itself evidence of her (routine-owner.mjs).
+    ownerProblem = (ownerAgentId) => routineOwnerProblem(ownerAgentId, null, { stored: true }),
     log = defaultLog,
   } = deps;
   const name = row.name;
@@ -125,17 +143,21 @@ export async function runOwnedAutomation(kind, row, run, deps = {}) {
       .catch((error) => log(`${kind} "${name}": skip record failed: ${errorText(error)}`));
     return { name, skipped: true, reason, sessionId: null, result: '', ...extra };
   };
-  // A routine runs only in its own bot's thread: without that bot it waits.
-  const problem = await Promise.resolve()
-    .then(() => ownerProblem(row.ownerAgentId))
-    .catch(() => '');
-  if (problem) {
-    log(`${kind} "${name}": paused, ${ROUTINE_OWNER_PROBLEMS[problem]}`);
-    return skip('owner', { ownerProblem: problem, message: ROUTINE_OWNER_PROBLEMS[problem] });
-  }
-  if (active.has(key)) return skip('overlap');
-  active.add(key);
+  // The name is reserved before the owner check, so a rename can neither
+  // complete while it waits nor leave this run to start under the old name.
+  const overlap = !reserved && active.has(key);
+  const holds = !reserved && !overlap;
+  if (holds) active.add(key);
   try {
+    // A routine runs only in its own bot's thread: without that bot it waits.
+    const problem = await Promise.resolve()
+      .then(() => ownerProblem(row.ownerAgentId))
+      .catch(() => '');
+    if (problem) {
+      log(`${kind} "${name}": paused, ${ROUTINE_OWNER_PROBLEMS[problem]}`);
+      return await skip('owner', { ownerProblem: problem, message: ROUTINE_OWNER_PROBLEMS[problem] });
+    }
+    if (overlap) return await skip('overlap');
     if (!attended) {
       const record = await withRecord(kind, deps);
       const state = await Promise.resolve()
@@ -156,7 +178,7 @@ export async function runOwnedAutomation(kind, row, run, deps = {}) {
     }
     return await run({ signal });
   } finally {
-    active.delete(key);
+    if (holds) active.delete(key);
   }
 }
 

package/src/session-runtime/prewarm/channel-start.mjs

@@ -39,9 +39,7 @@ export function createChannelStart({
   async function onChannelStartTimer() {
     timers.channelStartTimer = null;
     if (isCloseRequested()) return;
-    // Channels-module and remote toggles gate MESSAGING; automation
-    // (enabled schedules/webhooks) keeps the worker boot alive — its
-    // channel worker runs headless: only active automation boots it.
+    // Only active automation (enabled schedules/webhooks) boots the worker.
     const automation = await hasActiveAutomation().catch(() => false);
     if (!automation) {
       bootProfile('channels:start-disabled');
@@ -69,10 +67,8 @@ export function createChannelStart({
     timers.channelStartTimer.unref?.();
   }
 
-  // Boot-time automation autostart. Automation decoupling (user decision):
-  // enabled schedules/webhooks boot the worker on their own — no messaging
-  // provider. The worker runs headless (scheduler/webhooks/voice only).
-  // Unlike scheduleChannelStart this probes once at the boot delay and never
+  // Boot-time automation autostart: enabled schedules/webhooks boot the worker
+  // on their own (scheduler/webhooks/voice only). Unlike scheduleChannelStart this probes once at the boot delay and never
   // re-arms. The probe itself is shared process-wide (channel-admin
   // hasActiveAutomation), so N runtimes booting together check once.
   function scheduleAutomationAutostart(delayMs) {

package/src/session-runtime/provider-auth/login.mjs

@@ -8,6 +8,7 @@ import {
   saveOpenAIUsageSessionKey,
   saveProviderApiKey,
   saveCustomProvider,
+  saveCustomProviderKey,
   removeCustomProvider,
   updateCustomProviderModel,
   saveModelPreferences,
@@ -76,6 +77,12 @@ export function createLoginApi({ cfgMod, awaitKeychainPrewarm, reloadFullConfig,
       refresh.afterCredentialChange();
       return result;
     },
+    async saveCustomProviderKey(providerId, secret) {
+      await awaitKeychainPrewarm();
+      const result = await saveCustomProviderKey(cfgMod, providerId, secret);
+      refresh.afterCredentialChange();
+      return result;
+    },
     async updateCustomProviderModel(providerId, modelId, patch) {
       const result = await updateCustomProviderModel(cfgMod, providerId, modelId, patch);
       refresh.afterCredentialChange();

package/src/session-runtime/provider-models/row-hydration.mjs

@@ -14,6 +14,7 @@ import {
   effortConfigurationMode,
 } from '../../runtime/agent/orchestrator/providers/effort-configuration.mjs';
 import { getProvider } from '../../runtime/agent/orchestrator/providers/registry.mjs';
+import { providerAvailable } from '../../runtime/agent/orchestrator/providers/provider-availability.mjs';
 import {
   DAYBREAK_PARAMETER_OPTION,
   DAYBREAK_PROVIDER,
@@ -96,7 +97,17 @@ export function createRowHydration({
     hydrateProviderModelRow: (row) => hydrateProviderModelRow(config(), row),
     sortProviderModels,
     providerModelCacheRow,
-    providerModelsFromCacheRows: (rows) =>
-      sortProviderModels((rows || []).map((row) => hydrateProviderModelRow(config(), row))),
+    // Cached rows outlive a Developer option switch, so availability is
+    // applied at read time, once per provider per call.
+    providerModelsFromCacheRows: (rows) => {
+      const availability = new Map();
+      const available = (provider) => {
+        if (!availability.has(provider)) availability.set(provider, providerAvailable(provider));
+        return availability.get(provider);
+      };
+      return sortProviderModels(
+        (rows || []).filter((row) => available(row.provider)).map((row) => hydrateProviderModelRow(config(), row))
+      );
+    },
   };
 }