mixdog 0.9.19 → 0.9.21

package/src/session-runtime/env.mjs

@@ -0,0 +1,17 @@
+// Environment-variable coercion helpers shared by the session runtime.
+// Extracted verbatim from mixdog-session-runtime.mjs during the facade split.
+export function envFlag(name) {
+  return /^(1|true|yes|on)$/i.test(String(process.env[name] || ''));
+}
+
+export function envPresent(name) {
+  return process.env[name] !== undefined && process.env[name] !== '';
+}
+
+export function envDelayMs(name, fallback, { min = 0, max = 60_000 } = {}) {
+  const raw = process.env[name];
+  if (raw === undefined || raw === '') return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(n)));
+}

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

@@ -0,0 +1,242 @@
+import { cancelBackgroundTasks } from '../runtime/shared/background-tasks.mjs';
+import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
+import { writeStatuslineRoute } from './statusline-route.mjs';
+import {
+  sessionMessageText,
+  isSessionPreviewNoise,
+  cleanSessionPreview,
+  clean,
+  hasOwn,
+} from './session-text.mjs';
+import { toolSpecForMode, deferredSurfaceModeForLead } from './effort.mjs';
+
+// Session lifecycle surface: teardown (close/abort), resume/new, and the
+// resumable-session listing. Extracted verbatim from the runtime API object;
+// stateless helpers are imported directly and the runtime injects live
+// getters/setters for the mutable session/route/cwd locals plus the closure
+// callbacks and long-lived handles (managers, timers, channel/agent/mcp).
+export function createLifecycleApi(deps) {
+  const {
+    getSession, setSession, getRoute, setRoute, getConfig, getMode, getCurrentCwd,
+    setCloseRequested, getMemoryModPromise, setMemoryModPromise,
+    setSessionNeedsCwdRefresh,
+    hooks, hookCommonPayload, mgr, statusRoutes, channels, agentTool, mcpClient,
+    warmupTimers, prewarmTimers,
+    flushConfigSave, flushBackendSave, flushOutputStyleSave,
+    withTeardownDeadline, closePatchRuntimeIfLoaded,
+    createCurrentSession, refreshRouteEffort,
+    invalidateContextStatusCache, invalidatePreSessionToolSurface,
+    applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
+  } = deps;
+  return {
+    async close(reason = 'cli-exit', options = {}) {
+      const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
+      setCloseRequested(true);
+      // SessionEnd: bridge teardown to the standard hook bus. reason mapped to
+      // standard values ('clear'/'exit' where applicable, else 'other'). Short
+      // await guard so a slow hook cannot wedge teardown; best-effort.
+      try {
+        const rl = String(reason || '').toLowerCase();
+        const endReason = /clear/.test(rl) ? 'clear'
+          : /exit|quit|cli-exit|shutdown|sigint|sigterm/.test(rl) ? 'exit'
+          : 'other';
+        const session = getSession();
+        if (session?.id) {
+          await withTeardownDeadline(
+            Promise.resolve(hooks.dispatch('SessionEnd', hookCommonPayload({ session_id: session.id, reason: endReason }))).catch(() => {}),
+            300,
+            undefined,
+          );
+        }
+      } catch { /* best-effort: SessionEnd hook must never wedge teardown */ }
+      // Persist any change that is still sitting in the debounce window so a
+      // toggle made right before exit is not lost. Synchronous + best-effort:
+      // teardown must continue even if the final write fails.
+      try { flushConfigSave(); } catch {}
+      try { flushBackendSave(); } catch {}
+      try { flushOutputStyleSave(); } catch {}
+      if (prewarmTimers.channelStartTimer) {
+        clearTimeout(prewarmTimers.channelStartTimer);
+        prewarmTimers.channelStartTimer = null;
+      }
+      for (const timerKey of [
+        'providerSetupWarmupTimer',
+        'providerWarmupTimer',
+        'providerModelWarmupTimer',
+        'modelCatalogWarmupTimer',
+      ]) {
+        if (warmupTimers[timerKey]) {
+          clearTimeout(warmupTimers[timerKey]);
+          warmupTimers[timerKey] = null;
+        }
+      }
+      if (prewarmTimers.codeGraphPrewarmTimer) {
+        clearTimeout(prewarmTimers.codeGraphPrewarmTimer);
+        prewarmTimers.codeGraphPrewarmTimer = null;
+      }
+      for (const timerKey of ['statuslineUsageWarmupTimer', 'statuslineUsageRefreshTimer']) {
+        if (warmupTimers[timerKey]) {
+          clearTimeout(warmupTimers[timerKey]);
+          warmupTimers[timerKey] = null;
+        }
+      }
+      try { cancelBackgroundTasks({ reason, notify: false }); } catch {}
+      const channelStop = channels.stop(reason, detach ? { waitForExit: false } : undefined);
+      try { agentTool.closeAll(reason); } catch {}
+      let mcpStop = null;
+      try { mcpStop = mcpClient.disconnectAll?.(); } catch {}
+      const openaiWsStop = globalThis.__mixdogOpenaiWsRuntimeLoaded === true
+        ? import('../runtime/agent/orchestrator/providers/openai-oauth-ws.mjs')
+          .then((mod) => mod?.drainOpenaiWsPool?.(reason))
+          .catch(() => {})
+        : null;
+      const patchStop = closePatchRuntimeIfLoaded(detach ? { waitForExit: false } : undefined);
+      const memoryModPromise = getMemoryModPromise();
+      const memoryStop = memoryModPromise
+        ? memoryModPromise
+          .then((mod) => (typeof mod?.stop === 'function' ? mod.stop() : null))
+          .catch(() => {})
+          .finally(() => {
+            setMemoryModPromise(null);
+          })
+        : null;
+      let ok = false;
+      const session = getSession();
+      if (session?.id) {
+        statusRoutes?.clearGatewaySessionRoute?.(session.id);
+        // Bug fix: runtime stop/exit (TUI Ctrl-C, process exit) previously
+        // always tombstoned the current session, so a session you were
+        // mid-conversation in vanished from the Resume list the instant you
+        // quit and was hard-deleted by the 24h tombstone sweep. Only
+        // tombstone truly-empty scratch sessions; non-empty sessions must
+        // survive exit resumable.
+        // liveTurnMessages holds the in-flight user prompt until turn
+        // commit — an active first-turn ask has its user message there,
+        // not yet in session.messages, so it must also be checked or a
+        // first-turn exit could still burn a real session.
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        ok = mgr.closeSession(session.id, reason, { tombstone });
+        setSession(null);
+      }
+      const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
+        ? import('../runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs')
+          .then((mod) => mod?.shutdownShellJobs?.(reason, { sync: !detach }))
+          .catch(() => {})
+        : null;
+      const bashSessionsStop = globalThis.__mixdogBashSessionRuntimeLoaded === true
+        ? import('../runtime/agent/orchestrator/tools/bash-session.mjs')
+          .then((mod) => mod?.shutdownBashSessions?.(reason))
+          .catch(() => {})
+        : null;
+      if (detach) {
+        try { await withTeardownDeadline(channelStop, 300, false); } catch {}
+        try { await withTeardownDeadline(shellJobsStop, 300, false); } catch {}
+        try { await withTeardownDeadline(bashSessionsStop, 300, false); } catch {}
+        try { await withTeardownDeadline(memoryStop, 1500, false); } catch {}
+        for (const stop of [mcpStop, openaiWsStop, patchStop]) {
+          Promise.resolve(stop).catch(() => {});
+        }
+        return ok;
+      }
+      await Promise.allSettled([
+        withTeardownDeadline(channelStop, 5500, false),
+        withTeardownDeadline(mcpStop, 1500, false),
+        withTeardownDeadline(openaiWsStop, 1500, false),
+        withTeardownDeadline(patchStop, 1500, false),
+        withTeardownDeadline(memoryStop, 5500, false),
+        withTeardownDeadline(shellJobsStop, 1500, false),
+        withTeardownDeadline(bashSessionsStop, 1500, false),
+      ]);
+      return ok;
+    },
+    abort(reason = 'cli-abort') {
+      const session = getSession();
+      if (!session?.id) return false;
+      return mgr.abortSessionTurn(session.id, reason);
+    },
+    listSessions() {
+      return mgr.listSessions({}).map(s => {
+        const owner = clean(s.owner || 'user').toLowerCase();
+        if (owner && !['cli', 'user', 'mixdog', 'legacy'].includes(owner)) return null;
+        const sourceType = clean(s.sourceType || '').toLowerCase();
+        const sourceName = clean(s.sourceName || '').toLowerCase();
+        const agent = clean(s.agent || '').toLowerCase();
+        const leadish = agent === 'lead'
+          || sourceType === 'lead'
+          || (sourceType === 'cli')
+          || (!sourceType && !sourceName && !isAgentOwner(owner));
+        if (!leadish) return null;
+        let preview = cleanSessionPreview(s.preview || '');
+        let messageCount = Math.max(0, Number(s.messageCount) || 0);
+        if (!preview && Array.isArray(s.messages)) {
+          const msgs = s.messages || [];
+          const userPreviews = msgs
+            .filter(m => m && m.role === 'user')
+            .map(m => cleanSessionPreview(sessionMessageText(m.content)))
+            .filter(text => !isSessionPreviewNoise(text));
+          preview = userPreviews[userPreviews.length - 1] || userPreviews[0] || '';
+          messageCount = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant')).length;
+        }
+        if (!preview && messageCount === 0) return null;
+        return {
+          id: s.id,
+          updatedAt: s.updatedAt,
+          cwd: s.cwd || '',
+          model: s.model,
+          provider: s.provider,
+          messageCount,
+          preview,
+        };
+      }).filter(Boolean);
+    },
+    async newSession() {
+      const session = getSession();
+      if (session?.id) {
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        mgr.closeSession(session.id, 'cli-new', { tombstone });
+        setSession(null);
+      }
+      invalidateContextStatusCache();
+      await createCurrentSession();
+      return getSession().id;
+    },
+    async resume(id) {
+      const prev = getSession();
+      const previousId = prev?.id || null;
+      const previousMessages = prev?.messages || null;
+      const previousLive = prev?.liveTurnMessages || null;
+      const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()));
+      if (!resumed) return null;
+      if (previousId && previousId !== resumed.id) {
+        statusRoutes?.clearGatewaySessionRoute?.(previousId);
+        const tombstone = !hasUserConversationMessage(previousMessages)
+          && !hasUserConversationMessage(previousLive);
+        mgr.closeSession(previousId, 'cli-resume', { tombstone });
+      }
+      setSession(resumed);
+      applyResolvedCwd(resumed.cwd || getCurrentCwd(), { markRefresh: false });
+      const route = getRoute();
+      const resumeEffort = hasOwn(route, 'effort') ? route.effort : resumed.effort;
+      setRoute(resolveRoute(getConfig(), { provider: resumed.provider, model: resumed.model, effort: resumeEffort }));
+      await refreshRouteEffort();
+      const session = getSession();
+      session.effort = getRoute().effectiveEffort || null;
+      session.cwd = getCurrentCwd();
+      applyDeferredToolSurface(session, deferredSurfaceModeForLead(getMode()), standaloneTools, { provider: getRoute().provider });
+      invalidatePreSessionToolSurface();
+      invalidateContextStatusCache();
+      setSessionNeedsCwdRefresh(false);
+      writeStatuslineRoute(statusRoutes, session, getRoute());
+      return {
+        id: resumed.id,
+        messages: resumed.messages || [],
+        cwd: getCurrentCwd(),
+        provider: resumed.provider,
+        model: resumed.model,
+      };
+    },
+  };
+}

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

@@ -0,0 +1,198 @@
+import { clean, hasOwn } from './session-text.mjs';
+import { coerceEffortFor, normalizeEffortInput } from './effort.mjs';
+import { fastCapableFor, saveModelSettings } from './model-capabilities.mjs';
+import {
+  ensureProviderEnabled,
+  validateRequestedModelSelector,
+  findPreset,
+  modelMetaLooksResolved,
+} from './config-helpers.mjs';
+import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
+import {
+  workflowPresetId,
+  normalizeSearchRouteConfig,
+  isDefaultSearchRouteConfig,
+  isSearchCapableProvider,
+  SEARCH_DEFAULT_PROVIDER,
+  SEARCH_DEFAULT_MODEL,
+} from './workflow.mjs';
+import { writeStatuslineRoute } from './statusline-route.mjs';
+
+// Model/route/search-route selection + mutation surface. Extracted verbatim from
+// the runtime API object; stateless helpers are imported directly and the
+// runtime injects live getters/setters for the mutable config/route/searchRoute/
+// session locals plus the closure callbacks (config adopt/save, effort refresh,
+// provider registry, statusline).
+export function createModelRouteApi(deps) {
+  const {
+    getConfig, getRoute, setRouteState, getSession, setSession,
+    getConfigHasSecrets, getSearchRouteState, setSearchRouteState,
+    cfgMod, reg, mgr, statusRoutes,
+    resolveRoute, searchCapableFor, lookupModelMeta,
+    adoptConfig, saveConfigAndAdopt, ensureFullConfig,
+    persistLeadRoute, refreshRouteEffort,
+    refreshStatuslineUsageSnapshot, scheduleStatuslineUsageRefresh,
+    invalidateContextStatusCache, invalidateProviderCaches,
+    collectSearchProviderModels,
+  } = deps;
+  return {
+    getSearchRoute() {
+      const sr = normalizeSearchRouteConfig(getConfig().searchRoute) || normalizeSearchRouteConfig(getSearchRouteState());
+      setSearchRouteState(sr);
+      return sr;
+    },
+    async listSearchModels(options = {}) {
+      return await collectSearchProviderModels({ force: options.force === true || options.refresh === true });
+    },
+    async setSearchRoute(next) {
+      const searchRoute = getSearchRouteState();
+      let selectedRoute = normalizeSearchRouteConfig(next);
+      if (!selectedRoute && next?.model && searchRoute?.provider) {
+        selectedRoute = normalizeSearchRouteConfig({ ...next, provider: searchRoute.provider });
+      }
+      if (!selectedRoute) throw new Error('search route requires provider and model');
+      if (isDefaultSearchRouteConfig(selectedRoute)) {
+        ensureFullConfig();
+        const routeToSave = normalizeSearchRouteConfig({
+          provider: SEARCH_DEFAULT_PROVIDER,
+          model: SEARCH_DEFAULT_MODEL,
+          ...(selectedRoute.toolType ? { toolType: selectedRoute.toolType } : {}),
+        });
+        const nextConfig = { ...getConfig() };
+        nextConfig.searchRoute = routeToSave;
+        saveConfigAndAdopt(nextConfig);
+        const sr = normalizeSearchRouteConfig(getConfig().searchRoute);
+        setSearchRouteState(sr);
+        invalidateProviderCaches();
+        return sr;
+      }
+      if (!isSearchCapableProvider(selectedRoute.provider)) {
+        throw new Error(`provider "${selectedRoute.provider}" does not support Mixdog native search`);
+      }
+      ensureFullConfig();
+      await reg.initProviders(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+      const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+      if (!searchCapableFor(selectedRoute.provider, modelMeta)) {
+        throw new Error(`model "${selectedRoute.model}" is not marked as web-search capable`);
+      }
+      const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
+      const effort = coerceEffortFor(selectedRoute.provider, modelMeta, selectedRoute.effort);
+      selectedRoute = {
+        ...selectedRoute,
+        ...(effort ? { effort } : {}),
+        fast: fastCapable ? selectedRoute.fast === true : false,
+      };
+      adoptConfig(saveModelSettings(cfgMod, selectedRoute, { fastCapable, baseConfig: getConfig() }), { hasSecrets: getConfigHasSecrets() });
+      const routeToSave = normalizeSearchRouteConfig(selectedRoute);
+      const nextConfig = { ...getConfig() };
+      nextConfig.searchRoute = routeToSave;
+      saveConfigAndAdopt(nextConfig);
+      const sr = normalizeSearchRouteConfig(getConfig().searchRoute);
+      setSearchRouteState(sr);
+      invalidateProviderCaches();
+      return sr;
+    },
+    async setRoute(next, options = {}) {
+      // Model/provider changes take effect on the NEXT session only — never
+      // rewrite a running session's provider/model in place (provider-keyed
+      // prompt cache). `route` still updates immediately for the next session.
+      const applyToCurrentSession = options?.applyToCurrentSession === true;
+      const requested = { ...(next || {}) };
+      validateRequestedModelSelector(getConfig(), requested);
+      const providerExplicitlyRequested = clean(next?.provider) !== '';
+      if (requested.effort === undefined && !requested.provider && !requested.model && hasOwn(getRoute(), 'effort')) {
+        requested.effort = getRoute().effort;
+      }
+      if (!requested.provider && requested.model && !findPreset(getConfig(), requested.model)) {
+        requested.provider = getRoute().provider;
+      }
+      let selectedRoute = resolveRoute(getConfig(), requested);
+      await reg.initProviders(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+      const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+      if (!providerExplicitlyRequested
+        && !selectedRoute.preset
+        && !modelMetaLooksResolved(modelMeta)
+        && !getModelMetadataSync(selectedRoute.model, selectedRoute.provider)) {
+        throw new Error(`unknown model: ${selectedRoute.provider}/${selectedRoute.model}`);
+      }
+      const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
+      selectedRoute = { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
+      adoptConfig(saveModelSettings(cfgMod, selectedRoute, { fastCapable, baseConfig: getConfig() }), { hasSecrets: getConfigHasSecrets() });
+      const leadRoute = persistLeadRoute(selectedRoute);
+      setRouteState(resolveRoute(getConfig(), leadRoute
+        ? { model: workflowPresetId('lead') }
+        : selectedRoute));
+      await refreshRouteEffort(modelMeta);
+      refreshStatuslineUsageSnapshot(getRoute());
+      scheduleStatuslineUsageRefresh();
+      if (!applyToCurrentSession) {
+        return getRoute();
+      }
+      const session = getSession();
+      if (session) {
+        const route = getRoute();
+        const updated = mgr.updateSessionRoute?.(session.id, {
+          provider: route.provider,
+          model: route.model,
+          fast: route.fast === true,
+          effort: route.effectiveEffort || null,
+        });
+        if (updated) setSession(updated);
+        else {
+          session.provider = route.provider;
+          session.model = route.model;
+          session.fast = route.fast === true;
+          session.effort = route.effectiveEffort || null;
+        }
+        writeStatuslineRoute(statusRoutes, getSession(), route);
+        invalidateContextStatusCache();
+      }
+      return getRoute();
+    },
+    async setFast(value) {
+      const enabled = value === true;
+      const modelMeta = await lookupModelMeta(getRoute().provider, getRoute().model);
+      const fastCapable = fastCapableFor(getRoute().provider, modelMeta);
+      if (enabled && !fastCapable) {
+        throw new Error(`fast mode is not available for ${getRoute().provider}/${getRoute().model}`);
+      }
+      setRouteState(resolveRoute(getConfig(), { provider: getRoute().provider, model: getRoute().model, effort: getRoute().effort, fast: fastCapable ? enabled : false }));
+      adoptConfig(saveModelSettings(cfgMod, getRoute(), { fastCapable, baseConfig: getConfig() }), { hasSecrets: getConfigHasSecrets() });
+      const leadRoute = persistLeadRoute(getRoute());
+      if (leadRoute) setRouteState(resolveRoute(getConfig(), { model: workflowPresetId('lead') }));
+      await refreshRouteEffort(modelMeta);
+      const session = getSession();
+      if (session) {
+        const route = getRoute();
+        session.fast = route.fast === true;
+        session.effort = route.effectiveEffort || null;
+        writeStatuslineRoute(statusRoutes, session, route);
+        invalidateContextStatusCache();
+      }
+      return getRoute().fast === true;
+    },
+    async toggleFast() {
+      return await this.setFast(!(getRoute().fast === true));
+    },
+    async setEffort(value) {
+      const normalized = normalizeEffortInput(value);
+      setRouteState({ ...getRoute(), effort: normalized });
+      const modelMeta = await lookupModelMeta(getRoute().provider, getRoute().model);
+      const fastCapable = fastCapableFor(getRoute().provider, modelMeta);
+      adoptConfig(saveModelSettings(cfgMod, getRoute(), { fastCapable, baseConfig: getConfig() }), { hasSecrets: getConfigHasSecrets() });
+      const leadRoute = persistLeadRoute(getRoute());
+      if (leadRoute) {
+        setRouteState(resolveRoute(getConfig(), { model: workflowPresetId('lead') }));
+      }
+      await refreshRouteEffort(modelMeta);
+      const session = getSession();
+      if (session) {
+        const route = getRoute();
+        session.effort = route.effectiveEffort || null;
+        writeStatuslineRoute(statusRoutes, session, route);
+        invalidateContextStatusCache();
+      }
+      return getRoute();
+    },
+  };
+}

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

@@ -0,0 +1,135 @@
+import {
+  beginOAuthProviderLogin,
+  forgetProviderAuth,
+  isKnownProvider,
+  loginOAuthProvider,
+  renderProviderStatus,
+  saveOpenAIUsageSessionKey,
+  saveOpenCodeGoUsageAuth,
+  loginOpenCodeGoUsage,
+  saveProviderApiKey,
+  setLocalProvider,
+} from '../standalone/provider-admin.mjs';
+import { clean } from './session-text.mjs';
+
+// Provider auth / catalog / preset surface. Extracted verbatim from the runtime
+// API object; the stateless admin helpers are imported directly and the runtime
+// injects the closure-owned config/cache callbacks. `isKnownProvider` is
+// re-imported here from provider-admin (same binding the runtime uses).
+export function createProviderAuthApi({
+  cfgMod,
+  getConfig,
+  saveConfigAndAdopt,
+  displayConfig,
+  reloadFullConfig,
+  invalidateProviderCaches,
+  warmProviderModelCache,
+  cachedProviderSetup,
+  getUsageDashboard,
+  collectProviderModels,
+}) {
+  return {
+    listProviders() {
+      return renderProviderStatus(displayConfig());
+    },
+    async getProviderSetup() {
+      return await cachedProviderSetup();
+    },
+    async getUsageDashboard(options = {}) {
+      return await getUsageDashboard(options);
+    },
+    async authenticateProvider(providerId, secret) {
+      const result = String(secret || '').trim()
+        ? saveProviderApiKey(cfgMod, providerId, secret)
+        : await loginOAuthProvider(cfgMod, providerId);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      warmProviderModelCache();
+      return result;
+    },
+    async loginOAuthProvider(providerId) {
+      const result = await loginOAuthProvider(cfgMod, providerId);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      warmProviderModelCache();
+      return result;
+    },
+    async beginOAuthProviderLogin(providerId) {
+      const result = await beginOAuthProviderLogin(cfgMod, providerId);
+      reloadFullConfig();
+      return {
+        ...result,
+        waitForCallback: result.waitForCallback?.then((completed) => {
+          reloadFullConfig();
+          if (completed) {
+            invalidateProviderCaches();
+            warmProviderModelCache();
+          }
+          return completed;
+        }),
+        completeCode: async (code) => {
+          const completed = await result.completeCode(code);
+          reloadFullConfig();
+          invalidateProviderCaches();
+          warmProviderModelCache();
+          return completed;
+        },
+      };
+    },
+    saveProviderApiKey(providerId, secret) {
+      const result = saveProviderApiKey(cfgMod, providerId, secret);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      warmProviderModelCache();
+      return result;
+    },
+    saveOpenAIUsageSessionKey(secret) {
+      const result = saveOpenAIUsageSessionKey(cfgMod, secret);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      return result;
+    },
+    saveOpenCodeGoUsageAuth(opts) {
+      const result = saveOpenCodeGoUsageAuth(cfgMod, opts);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      return result;
+    },
+    async loginOpenCodeGoUsage() {
+      const result = await loginOpenCodeGoUsage(cfgMod);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      return result;
+    },
+    setLocalProvider(providerId, opts) {
+      const result = setLocalProvider(cfgMod, providerId, opts);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      warmProviderModelCache();
+      return result;
+    },
+    forgetProviderAuth(providerId) {
+      const result = forgetProviderAuth(cfgMod, providerId);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      warmProviderModelCache();
+      return result;
+    },
+    listPresets() {
+      return cfgMod.listPresets(displayConfig());
+    },
+    async listProviderModels(options = {}) {
+      return await collectProviderModels({
+        force: options.force === true || options.refresh === true,
+        quick: options.quick === true,
+      });
+    },
+    async setDefaultProvider(provider) {
+      const requested = clean(provider);
+      if (!requested) throw new Error('provider is required');
+      if (!isKnownProvider(requested)) throw new Error(`unknown provider "${provider}"`);
+      saveConfigAndAdopt({ ...getConfig(), defaultProvider: requested });
+      return requested;
+    },
+  };
+}