mixdog 1.2.0 → 1.2.2

package/src/session-runtime/native-web-search/routes.mjs

@@ -7,19 +7,37 @@ import { webSearchRouteOrDefault } from '../../runtime/agent/orchestrator/runtim
 
 export function createWebSearchRouteCandidates({
   getRoute,
+  getReg,
   getWebSearchRoute,
   setWebSearchRoute,
   ensureFullConfig,
   awaitKeychainPrewarm,
+  ensureProvidersReady,
+  ensureProviderEnabled,
   normalizeWebSearchProviderId,
   isDefaultWebSearchRouteConfig,
   isWebSearchCapableProvider,
   webSearchCapableFor,
 }) {
-  function currentMainWebSearchModelMeta() {
+  function currentMainWebSearchModelMeta(loadedRow = null) {
     const route = getRoute();
     if (!route?.provider || !route?.model) return null;
-    return { ...route, id: route.model, display: route.model, name: route.model };
+    // Capability comes from the provider's catalog row (supportedTools etc.),
+    // not from the bare model id.
+    const catalogRow = getReg()?.getProvider(route.provider)?.getCachedModelInfo?.(route.model) || loadedRow;
+    return { ...catalogRow, ...route, id: route.model, display: route.model, name: route.model };
+  }
+
+  /** A cold catalog (fresh or model-proxy provider instance) is loaded once
+   *  before the capability check, so it never falls back to the bare id.
+   *  Returns the listed row, which carries the catalog fields even when the
+   *  provider keeps no per-model cache. */
+  async function loadMainCatalogRow(cfg, route) {
+    await ensureProvidersReady(ensureProviderEnabled(cfg, route.provider));
+    const provider = getReg().getProvider(route.provider);
+    if (provider?.getCachedModelInfo?.(route.model) || typeof provider?.listModels !== 'function') return null;
+    const models = await provider.listModels();
+    return (Array.isArray(models) ? models.find((m) => m?.id === route.model) : null) || null;
   }
 
   async function nativeWebSearchRoutes() {
@@ -33,7 +51,8 @@ export function createWebSearchRouteCandidates({
     const webSearchRoute = webSearchRouteOrDefault(cfg.webSearchRoute, getWebSearchRoute());
     setWebSearchRoute(webSearchRoute);
     if (isDefaultWebSearchRouteConfig(webSearchRoute)) {
-      const mainModel = currentMainWebSearchModelMeta();
+      const loadedRow = route?.provider && route?.model ? await loadMainCatalogRow(cfg, route) : null;
+      const mainModel = currentMainWebSearchModelMeta(loadedRow);
       if (!mainModel || !webSearchCapableFor(route.provider, mainModel)) return [];
       return [
         {

package/src/session-runtime/new-session-config.mjs

@@ -21,7 +21,8 @@ export function createNewSessionConfig({
     await flushPendingSessionConfigWrites();
     await sharedCfgMod.pendingConfigWrites();
     sharedCfgMod.invalidateConfigReadCache();
-    const previousMcp = rt.config.mcpServers;
+    const mcpSettings = () => [rt.config.mcpServers, rt.config.pluginMcp];
+    const previousMcp = mcpSettings();
     // Headless callers inject a deliberately isolated config. Never replace
     // their explicit policy with the interactive profile on disk.
     if (!initialConfig || typeof initialConfig !== 'object') {
@@ -34,7 +35,7 @@ export function createNewSessionConfig({
     invalidatePreSessionToolSurface();
     invalidateSkills();
     await configureEmbedding(sharedCfgMod.readSection('memory')?.embedding || {});
-    if (!firstSession || !isDeepStrictEqual(previousMcp, rt.config.mcpServers)) {
+    if (!firstSession || !isDeepStrictEqual(previousMcp, mcpSettings())) {
       // Reused runtimes may still own old connections. This reset is scoped to
       // the runtime that is constructing the new session, not to its peers.
       await connectConfiguredMcp({ reset: true });

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

@@ -3,7 +3,10 @@
 // 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 { markCompletionEntry } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
+import {
+  PENDING_MODE_TASK_NOTIFICATION,
+  markCompletionEntry,
+} from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
 import {
   isDeliveredCompletion,
   logDuplicateSkip,
@@ -144,7 +147,11 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
     if (!open) return false;
     if (typeof mgr.enqueuePendingMessage !== 'function') return false;
     try {
-      return mgr.enqueuePendingMessage(targetSessionId, content) > 0;
+      // A channel notification (webhook event rules, schedule injects, relays)
+      // 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;
     } catch {
       return false;
     }

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

@@ -1,6 +1,10 @@
 // provider-auth/accounts.mjs — the per-provider account roster and account
 // switching, with the bounded background usage sweep that refreshes quotas.
-import { listProviderAccounts, updateProviderAccounts } from '../services/provider-admin.mjs';
+import {
+  listProviderAccounts,
+  materializeProviderAccounts,
+  updateProviderAccounts,
+} from '../services/provider-admin.mjs';
 import { getProvider } from '../../runtime/agent/orchestrator/providers/registry.mjs';
 import { fetchOAuthUsageSnapshot } from '../../runtime/agent/orchestrator/providers/oauth-usage.mjs';
 
@@ -11,21 +15,23 @@ export function createAccountApi(
   // One in-flight usage sweep per provider; a reopened picker reuses it.
   const accountUsageSweeps = new Map();
 
+  async function measureAccountUsage(providerId, provider, accounts, force = false) {
+    await awaitKeychainPrewarm();
+    for (let offset = 0; offset < accounts.length; offset += 4) {
+      await Promise.all(
+        accounts.slice(offset, offset + 4).map((account) => {
+          const target = { provider: providerId, accountId: account.id };
+          return fetchOAuthUsageSnapshot(target, provider.forAccount(account.id), () => {}, { force }).catch(
+            () => null
+          );
+        })
+      );
+    }
+  }
+
   async function sweepAccountUsage(providerId, provider, accounts) {
     try {
-      await awaitKeychainPrewarm();
-      for (let offset = 0; offset < accounts.length; offset += 4) {
-        await Promise.all(
-          accounts
-            .slice(offset, offset + 4)
-            .map((account) =>
-              fetchOAuthUsageSnapshot(
-                { provider: providerId, accountId: account.id },
-                provider.forAccount(account.id)
-              ).catch(() => null)
-            )
-        );
-      }
+      await measureAccountUsage(providerId, provider, accounts);
     } finally {
       accountUsageSweeps.delete(providerId);
     }
@@ -69,8 +75,20 @@ export function createAccountApi(
       return pool;
     },
     async updateProviderAccounts(providerId, change) {
+      // `{ refreshUsage: true }` re-measures every account now (the roster's
+      // "Refresh usage") and changes nothing else in the roster. The implicit
+      // signed-in account is stored first so its measurement has a row to land on.
+      if (change?.refreshUsage === true && Object.keys(change).length === 1) {
+        const provider = getProvider(providerId);
+        if (typeof provider?.forAccount === 'function') {
+          await awaitKeychainPrewarm();
+          const { accounts } = await materializeProviderAccounts(providerId);
+          await measureAccountUsage(providerId, provider, accounts, true);
+        }
+        return listProviderAccounts(providerId);
+      }
       await awaitKeychainPrewarm();
-      const result = updateProviderAccounts(providerId, change);
+      const result = await updateProviderAccounts(providerId, change);
       reloadFullConfig();
       invalidateProviderCaches();
       warmProviderModelCache();

package/src/session-runtime/provider-models/model-meta.mjs

@@ -10,6 +10,8 @@ export function modelMetaKey(providerId, modelId) {
 
 export function createModelMetaIndex({ caches, modelMetaByRoute, reg, scheduleProviderModelWarmup }) {
   let observedCatalogRevision = catalogRevision(reg());
+  // Keys holding only the bare-id placeholder: a fetching lookup replaces them.
+  const placeholderKeys = new Set();
 
   /** Invalidates the provider caches when the registry's catalog moved on;
    *  returns the current revision either way. */
@@ -22,6 +24,7 @@ export function createModelMetaIndex({ caches, modelMetaByRoute, reg, schedulePr
     caches.providerModelsPromise = null;
     caches.webSearchProviderModelsCache = { models: null, at: 0, revision };
     modelMetaByRoute.clear();
+    placeholderKeys.clear();
     return revision;
   }
 
@@ -32,14 +35,16 @@ export function createModelMetaIndex({ caches, modelMetaByRoute, reg, schedulePr
   }
 
   function remember(providerId, modelId, meta) {
-    modelMetaByRoute.set(modelMetaKey(providerId, modelId), meta);
+    const key = modelMetaKey(providerId, modelId);
+    modelMetaByRoute.set(key, meta);
+    placeholderKeys.delete(key);
   }
 
   async function lookupModelMeta(providerId, modelId, { allowFetch = false } = {}) {
     const revision = syncCatalogRevision();
     const seq = caches.providerModelsLoadSeq;
     const key = modelMetaKey(providerId, modelId);
-    if (modelMetaByRoute.has(key)) return modelMetaByRoute.get(key);
+    if (modelMetaByRoute.has(key) && !(allowFetch && placeholderKeys.has(key))) return modelMetaByRoute.get(key);
     const fallback = () => ({ id: modelId, provider: providerId });
     const providerImpl = reg().getProvider(providerId);
     if (!providerImpl || typeof providerImpl.listModels !== 'function') {
@@ -58,6 +63,7 @@ export function createModelMetaIndex({ caches, modelMetaByRoute, reg, schedulePr
     if (!allowFetch) {
       const meta = fallback();
       modelMetaByRoute.set(key, meta);
+      placeholderKeys.add(key);
       scheduleProviderModelWarmup();
       return meta;
     }
@@ -65,7 +71,10 @@ export function createModelMetaIndex({ caches, modelMetaByRoute, reg, schedulePr
       const models = await providerImpl.listModels();
       const found = Array.isArray(models) ? models.find((m) => m?.id === modelId) : null;
       const meta = found || fallback();
-      if (snapshotIsCurrent(revision, seq)) modelMetaByRoute.set(key, meta);
+      if (snapshotIsCurrent(revision, seq)) {
+        modelMetaByRoute.set(key, meta);
+        placeholderKeys.delete(key);
+      }
       return meta;
     } catch {
       // A failed fetch is not authoritative: nothing is pinned.

package/src/session-runtime/provider-models/web-search-catalog.mjs

@@ -38,7 +38,11 @@ export function createWebSearchCatalog({
     try {
       let models = null;
       if (forceRefresh && typeof provider._refreshModelCache === 'function') {
-        models = await provider._refreshModelCache();
+        try {
+          models = await provider._refreshModelCache();
+        } catch {
+          models = null; // fall back to listModels below
+        }
       }
       if (!Array.isArray(models)) models = await provider.listModels();
       if (!Array.isArray(models)) return [];

package/src/session-runtime/provider-readiness.mjs

@@ -67,16 +67,17 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
     await awaitKeychainPrewarm();
     if (rt.closeRequested) throw new Error('runtime is closing');
     const initKey = providerInitCacheKey(providerConfig);
-    const existing = providerInitPromises.get(initKey);
-    if (existing) return await existing;
     // Provider initialization is idempotent for one normalized config. Keep
     // the fulfilled promise, not only the in-flight one: session resume used
     // to rerun registry/keychain setup on every click even though neither the
     // provider config nor the registry had changed. Auth/config mutations call
     // invalidateProviderCaches(), which clears this gate and preserves the
     // existing refresh semantics.
-    const providerInitPromise = Promise.resolve().then(() => getReg().initProviders(providerConfig));
-    providerInitPromises.set(initKey, providerInitPromise);
+    let providerInitPromise = providerInitPromises.get(initKey);
+    if (!providerInitPromise) {
+      providerInitPromise = Promise.resolve().then(() => getReg().initProviders(providerConfig));
+      providerInitPromises.set(initKey, providerInitPromise);
+    }
     let result;
     try {
       result = await providerInitPromise;
@@ -84,13 +85,18 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
       if (providerInitPromises.get(initKey) === providerInitPromise) providerInitPromises.delete(initKey);
       throw error;
     }
-    if (!rt.startupProviderCatalogRefreshStarted && !rt.closeRequested) {
-      rt.startupProviderCatalogRefreshStarted = true;
-      rt.startupProviderCatalogRefreshPending = true;
+    if (!rt.closeRequested) {
       try {
-        void Promise.resolve(getReg().refreshProviderCatalogsOnStartup())
+        // The registry memoizes the refresh per catalog epoch; a provider set
+        // change yields a new promise, which gets its own completion handling.
+        const refresh = getReg().refreshProviderCatalogsOnStartup();
+        if (refresh === rt.startupProviderCatalogRefreshObserved) return result;
+        rt.startupProviderCatalogRefreshObserved = refresh;
+        rt.startupProviderCatalogRefreshPending = true;
+        const isLatest = () => rt.startupProviderCatalogRefreshObserved === refresh;
+        void Promise.resolve(refresh)
           .then(() => {
-            rt.startupProviderCatalogRefreshPending = false;
+            if (isLatest()) rt.startupProviderCatalogRefreshPending = false;
             if (rt.closeRequested) return;
             // Fresh catalog rows invalidate model-derived caches, but the
             // already initialized provider registry remains valid.
@@ -103,7 +109,7 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
             bootProfile('provider-catalogs:refresh-ready');
           })
           .catch((error) => {
-            rt.startupProviderCatalogRefreshPending = false;
+            if (isLatest()) rt.startupProviderCatalogRefreshPending = false;
             bootProfile('provider-catalogs:refresh-failed', { error: error?.message || String(error) });
           });
         bootProfile('provider-catalogs:refresh-started');

package/src/session-runtime/quick-model-rows/web-search-rows.mjs

@@ -2,8 +2,11 @@
 // main model, cached or built-in quick models per capable provider, and the
 // configured/current routes, deduplicated per provider:model.
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
-import { QUICK_WEB_SEARCH_MODELS } from '../quick-web-search-models.mjs';
-import { WEB_SEARCH_DEFAULT_PROVIDER, WEB_SEARCH_DEFAULT_MODEL } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import { quickWebSearchModels } from '../quick-web-search-models.mjs';
+import {
+  WEB_SEARCH_DEFAULT_PROVIDER,
+  WEB_SEARCH_DEFAULT_MODEL,
+} from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { providerCachedModelsSync } from '../../runtime/agent/orchestrator/providers/provider-catalog-cache.mjs';
 import { hydratedModel } from './model-meta.mjs';
 
@@ -33,7 +36,12 @@ export function createQuickWebSearchRows({
       contextWindow: resolved?.contextWindow || null,
       outputTokens: resolved?.outputTokens || null,
       latest: resolved?.latest === true,
-      supportsWebSearch: true,
+      // Only what the source row itself declares; webSearchCapableFor adds the
+      // provider catalog's row and the id fallback. Never forced on.
+      ...(typeof model?.supportsWebSearch === 'boolean' ? { supportsWebSearch: model.supportsWebSearch } : {}),
+      ...(Array.isArray(model?.supportedTools) ? { supportedTools: model.supportedTools } : {}),
+      ...(Array.isArray(model?.tools) ? { tools: model.tools } : {}),
+      ...(model?.capabilities && typeof model.capabilities === 'object' ? { capabilities: model.capabilities } : {}),
       supportsFunctionCalling: resolved?.supportsFunctionCalling === true,
       supportsPromptCaching: resolved?.supportsPromptCaching === true,
       supportsReasoning: resolved?.supportsReasoning === true,
@@ -95,7 +103,7 @@ export function createQuickWebSearchRows({
       const providerName = normalizeWebSearchProviderId(name);
       if (!providerConfig?.enabled || !isWebSearchCapableProvider(providerName)) continue;
       const cachedModels = providerCachedModelsSync(providerName);
-      const quickModels = cachedModels.length ? cachedModels : QUICK_WEB_SEARCH_MODELS[providerName] || [];
+      const quickModels = cachedModels.length ? cachedModels : quickWebSearchModels(providerName);
       for (const model of quickModels) {
         addQuickWebSearchModel(rows, seen, providerName, model);
       }
@@ -110,10 +118,7 @@ export function createQuickWebSearchRows({
     }
     const mainModel = currentMainWebSearchModelMeta();
     if (mainModel && webSearchCapableFor(route.provider, mainModel)) {
-      addQuickWebSearchModel(rows, seen, route.provider, {
-        id: route.model,
-        display: route.model,
-      });
+      addQuickWebSearchModel(rows, seen, route.provider, mainModel);
     }
     return webSearchModelsFromRows(rows);
   }

package/src/session-runtime/quick-web-search-models.mjs

@@ -1,41 +1,16 @@
-// Static quick-pick model ids surfaced during onboarding / web-search setup.
-// Limits are intentionally not hardcoded here: rows are hydrated from live
-// provider caches and provider-scoped metadata during catalog construction.
+// Offline quick-pick model rows for onboarding / web-search setup. No model id
+// is listed here: when a provider has no live roster yet, its newest rows come
+// from the provider-scoped public catalog, so a new release appears without a
+// code change. Rows are hydrated further during catalog construction.
+import { getModelsDevProviderModelsSync } from '../runtime/shared/llm/model-catalog.mjs';
 
 export const ONBOARDING_VERSION = 1;
 
-export const QUICK_WEB_SEARCH_MODELS = Object.freeze({
-  'openai-oauth': [
-    { id: 'gpt-6-sol', display: 'GPT-6 Sol', latest: true },
-    { id: 'gpt-6-luna', display: 'GPT-6 Luna', latest: true },
-    { id: 'gpt-5.6-sol', display: 'GPT-5.6 Sol' },
-    { id: 'gpt-5.6-terra', display: 'GPT-5.6 Terra' },
-    { id: 'gpt-5.6-luna', display: 'GPT-5.6 Luna' },
-  ],
-  openai: [
-    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true },
-    { id: 'gpt-5', display: 'GPT-5' },
-    { id: 'gpt-4.1', display: 'GPT-4.1' },
-    { id: 'gpt-4o', display: 'GPT-4o' },
-  ],
-  'grok-oauth': [{ id: 'grok-4.5', display: 'Grok 4.5', latest: true }],
-  xai: [{ id: 'grok-4.5', display: 'Grok 4.5', latest: true }],
-  gemini: [
-    { id: 'gemini-3.6-flash', display: 'Gemini 3.6 Flash', latest: true },
-    { id: 'gemini-3.5-flash-lite', display: 'Gemini 3.5 Flash Lite', latest: true },
-    { id: 'gemini-3.1-pro-preview', display: 'Gemini 3.1 Pro Preview' },
-  ],
-  'anthropic-oauth': [
-    { id: 'claude-opus-5-5', display: 'Claude Opus 5.5', latest: true },
-    { id: 'claude-sonnet-5', display: 'Claude Sonnet 5', latest: true },
-    { id: 'claude-fable-5', display: 'Claude Fable 5', latest: true },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
-  ],
-  anthropic: [
-    { id: 'claude-opus-5-5', display: 'Claude Opus 5.5', latest: true },
-    { id: 'claude-sonnet-5', display: 'Claude Sonnet 5', latest: true },
-    { id: 'claude-fable-5', display: 'Claude Fable 5', latest: true },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
-  ],
-});
+const QUICK_ROWS_PER_PROVIDER = 5;
+
+export function quickWebSearchModels(provider, models = getModelsDevProviderModelsSync(provider)) {
+  return Object.entries(models || {})
+    .map(([id, row]) => ({ id, display: row?.name || id, releaseDate: row?.release_date || null }))
+    .sort((a, b) => (Date.parse(b.releaseDate) || 0) - (Date.parse(a.releaseDate) || 0))
+    .slice(0, QUICK_ROWS_PER_PROVIDER);
+}

package/src/session-runtime/resource-extension-sync.mjs

@@ -5,6 +5,7 @@ import { publishGlobalExtensionChange, subscribeGlobalExtensionChanges } from '.
 
 export function createExtensionSync({
   connectConfiguredMcp,
+  cancelMcpLogin,
   invalidatePreSessionToolSurface,
   refreshEmptySessionToolPolicy,
   reloadFullConfig,
@@ -28,11 +29,13 @@ export function createExtensionSync({
     }
   }
 
-  // Apply per-server MCP changes in order; every other server stays untouched.
+  // Apply per-server MCP changes in order, then reconcile: a configured server
+  // added, renamed or removed can move a plugin server to another name, and
+  // only the reconcile connects it there and drops the stale name. Servers
+  // whose resolved config is unchanged stay untouched.
   async function applyMcpChanges(changes) {
-    let status;
-    for (const { name, enabled } of changes) status = await connectConfiguredMcp({ only: name, enabled });
-    return status;
+    for (const { name, enabled } of changes) await connectConfiguredMcp({ only: name, enabled });
+    return connectConfiguredMcp({ reconcile: true });
   }
 
   async function refreshState(kind, detail = null) {
@@ -41,7 +44,11 @@ export function createExtensionSync({
     const mcpChanges = kind === 'mcp' ? detail?.mcpChanges : null;
     if (Array.isArray(mcpChanges)) {
       await applyMcpChanges(mcpChanges);
-    } else if (kind === 'mcp' || kind === 'plugins') {
+    } else if (kind === 'plugins') {
+      // Plugin servers are derived from the registry: connect what is new or
+      // changed, drop what is gone or disabled, leave the rest connected.
+      await connectConfiguredMcp({ reconcile: true });
+    } else if (kind === 'mcp') {
       await connectConfiguredMcp({ reset: true });
     }
     await refreshSurface(kind);
@@ -54,6 +61,9 @@ export function createExtensionSync({
     const chain = mcpToggleChains.get(serverName) || { desired: enabled, running: null };
     chain.desired = enabled;
     mcpToggleChains.set(serverName, chain);
+    // A disable riding the chain would otherwise wait out an explicit sign-in
+    // (beginMcpOAuthLogin) of this server still in flight.
+    if (enabled === false) cancelMcpLogin?.(serverName);
     if (!chain.running) {
       chain.running = (async () => {
         let status;
@@ -101,12 +111,21 @@ export function createExtensionSync({
     return status;
   }
 
+  /** After a plugin registry change: reconcile this runtime's MCP connections
+   *  with the derived server set first, then let peers do the same. */
+  async function reconcilePluginsAndAnnounce() {
+    const status = await connectConfiguredMcp({ reconcile: true });
+    await announce('plugins');
+    return status;
+  }
+
   return {
     refreshSurface,
     publish,
     scheduleMcpToggle,
     announce,
     reconnectMcpAndAnnounce,
+    reconcilePluginsAndAnnounce,
     dispose: () => subscription.unsubscribe(),
   };
 }