@pellux/goodvibes-tui 0.19.32 → 0.19.34

package/src/input/commands/tts-runtime.ts

@@ -1,5 +1,7 @@
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config/schema';
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers/registry';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { SelectionItem } from '../selection-modal.ts';
 
 const TTS_CONFIG_KEYS = new Set(['provider', 'voice', 'llm-provider', 'llm-model']);
 
@@ -33,34 +35,64 @@ export function registerTtsRuntimeCommands(registry: CommandRegistry): void {
     name: 'config-tts',
     aliases: ['tts-config'],
     description: 'Configure live TTS provider, voice, and optional spoken-turn LLM overrides',
-    usage: '[show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm-provider <id|clear>|llm-model <id|clear>]',
+    usage: '[show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm|llm clear|llm-provider <id|clear>|llm-model <id|clear>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'show').toLowerCase();
       if (sub === 'show') {
+        if (args.length === 0 && openTtsConfigModal(ctx)) return;
         ctx.print(formatTtsConfig(ctx));
         return;
       }
       if (sub === 'providers') {
-        await printTtsProviders(ctx);
+        if (openTtsProviderPicker(ctx)) return;
+        printTtsProviders(ctx);
         return;
       }
       if (sub === 'voices') {
+        if (await openTtsVoicePicker(ctx, args[1])) return;
         await printTtsVoices(ctx, args[1]);
         return;
       }
+      if (sub === 'llm' || sub === 'model') {
+        const action = (args[1] ?? '').toLowerCase();
+        if (action === 'clear' || action === 'default') {
+          setTtsConfigValue(ctx, 'tts.llmProvider', '');
+          setTtsConfigValue(ctx, 'tts.llmModel', '');
+          ctx.print('TTS LLM override cleared. /tts will use the current chat model.');
+          return;
+        }
+        if (openTtsLlmPicker(ctx)) return;
+        ctx.print('TTS LLM picker is not available in this runtime. Use /config-tts llm-provider <id> and /config-tts llm-model <model>.');
+        return;
+      }
       if (TTS_CONFIG_KEYS.has(sub)) {
         const value = args.slice(1).join(' ').trim();
         if (!value) {
+          if ((sub === 'llm-provider' || sub === 'llm-model') && openTtsLlmPicker(ctx)) return;
           ctx.print(`Usage: /config-tts ${sub} <value|clear>`);
           return;
         }
         const key = ttsConfigKeyForSubcommand(sub);
         const nextValue = value.toLowerCase() === 'clear' ? '' : value;
-        ctx.platform.configManager.setDynamic(key, nextValue);
+        const previousProvider = key === 'tts.provider'
+          ? String(ctx.platform.configManager.get('tts.provider') ?? '').trim()
+          : '';
+        if (key === 'tts.llmProvider') {
+          setTtsLlmProvider(ctx, nextValue);
+          return;
+        }
+        if (key === 'tts.llmModel') {
+          setTtsLlmModel(ctx, nextValue);
+          return;
+        }
+        setTtsConfigValue(ctx, key, nextValue);
+        if (key === 'tts.provider' && previousProvider && previousProvider !== nextValue) {
+          setTtsConfigValue(ctx, 'tts.voice', '');
+        }
         ctx.print(`${key} ${nextValue ? `set to ${nextValue}` : 'cleared'}.`);
         return;
       }
-      ctx.print('Usage: /config-tts [show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm-provider <id|clear>|llm-model <id|clear>]');
+      ctx.print('Usage: /config-tts [show|providers|voices [provider]|provider <id|clear>|voice <id|clear>|llm|llm clear|llm-provider <id|clear>|llm-model <id|clear>]');
     },
   });
 }
@@ -86,17 +118,155 @@ function formatTtsConfig(ctx: CommandContext): string {
     `  spoken-turn llm provider override: ${llmProvider || '(current chat provider)'}`,
     `  spoken-turn llm model override: ${llmModel || '(current chat model)'}`,
     '  playback: live streaming through local mpv or ffplay',
-    '  commands: /tts <prompt>, /tts stop, /config-tts providers, /config-tts voices [provider]',
+    '  commands: /tts <prompt>, /tts stop, /config-tts, /config-tts providers, /config-tts voices [provider], /config-tts llm',
   ].join('\n');
 }
 
-async function printTtsProviders(ctx: CommandContext): Promise<void> {
+function openTtsConfigModal(ctx: CommandContext): boolean {
+  if (!ctx.openSelection) return false;
+  const cm = ctx.platform.configManager;
+  const provider = String(cm.get('tts.provider') ?? '').trim() || '(default)';
+  const voice = String(cm.get('tts.voice') ?? '').trim() || '(provider default)';
+  const llmProvider = String(cm.get('tts.llmProvider') ?? '').trim();
+  const llmModel = String(cm.get('tts.llmModel') ?? '').trim();
+  const llmProviderLabel = llmProvider || '(current chat provider)';
+  const llmModelLabel = llmModel || '(current chat model)';
+  const items: SelectionItem[] = [
+    {
+      id: 'provider',
+      label: 'TTS provider',
+      detail: provider,
+      category: 'speech output',
+      primaryAction: 'select',
+      actions: '[Enter] choose',
+    },
+    {
+      id: 'voice',
+      label: 'TTS voice',
+      detail: voice,
+      category: 'speech output',
+      primaryAction: 'select',
+      actions: '[Enter] choose',
+    },
+    {
+      id: 'llm-provider',
+      label: 'TTS LLM provider',
+      detail: llmProviderLabel,
+      category: 'response generation',
+      primaryAction: 'select',
+      actions: '[Enter] choose provider and model',
+    },
+    {
+      id: 'llm-model',
+      label: 'TTS LLM model',
+      detail: llmModelLabel,
+      category: 'response generation',
+      primaryAction: 'select',
+      actions: '[Enter] choose provider and model',
+    },
+    {
+      id: 'clear-voice',
+      label: 'Use provider default voice',
+      detail: 'clears tts.voice',
+      category: 'clear values',
+      primaryAction: 'select',
+    },
+    {
+      id: 'clear-llm',
+      label: 'Use current chat model for /tts',
+      detail: 'clears tts.llmProvider and tts.llmModel',
+      category: 'clear values',
+      primaryAction: 'select',
+    },
+  ];
+
+  ctx.openSelection('TTS Configuration', items, { allowSearch: true }, (result) => {
+    if (!result) return;
+    if (result.item.id === 'provider') {
+      openTtsProviderPicker(ctx);
+      return;
+    }
+    if (result.item.id === 'voice') {
+      void openTtsVoicePicker(ctx);
+      return;
+    }
+    if (result.item.id === 'llm-provider') {
+      openTtsLlmPicker(ctx);
+      return;
+    }
+    if (result.item.id === 'llm-model') {
+      openTtsLlmPicker(ctx);
+      return;
+    }
+    if (result.item.id === 'clear-voice') {
+      setTtsConfigValue(ctx, 'tts.voice', '');
+      ctx.print('TTS voice cleared. The provider default voice will be used.');
+      return;
+    }
+    if (result.item.id === 'clear-llm') {
+      setTtsConfigValue(ctx, 'tts.llmProvider', '');
+      setTtsConfigValue(ctx, 'tts.llmModel', '');
+      ctx.print('TTS LLM override cleared. /tts will use the current chat model.');
+    }
+  });
+  return true;
+}
+
+function openTtsLlmPicker(ctx: CommandContext): boolean {
+  if (ctx.openProviderModelPickerWithTarget?.('tts')) return true;
+  return ctx.openModelPickerWithTarget?.('tts') ?? false;
+}
+
+function getStreamingTtsProviders(ctx: CommandContext): Array<{ id: string; label: string; capabilities: readonly string[] }> {
+  const registry = ctx.platform.voiceProviderRegistry;
+  if (!registry) {
+    return [];
+  }
+  return registry.list().filter((provider) => provider.capabilities.includes('tts-stream'));
+}
+
+function openTtsProviderPicker(ctx: CommandContext): boolean {
+  if (!ctx.openSelection) return false;
+  const registry = ctx.platform.voiceProviderRegistry;
+  if (!registry) {
+    ctx.print('Voice provider registry is not available in this runtime.');
+    return true;
+  }
+  const providers = getStreamingTtsProviders(ctx);
+  if (providers.length === 0) {
+    ctx.print('No streaming TTS providers are registered.');
+    return true;
+  }
+  const current = String(ctx.platform.configManager.get('tts.provider') ?? '').trim();
+  const items: SelectionItem[] = providers.map((provider) => ({
+    id: provider.id,
+    label: provider.label,
+    detail: provider.id === current ? `${provider.id}  (current)` : provider.id,
+    category: 'streaming TTS providers',
+    primaryAction: 'select',
+    actions: '[Enter] set provider',
+  }));
+  ctx.openSelection('Choose TTS Provider', items, { preSelectId: current, allowSearch: true }, (result) => {
+    if (!result) return;
+    const previous = String(ctx.platform.configManager.get('tts.provider') ?? '').trim();
+    setTtsConfigValue(ctx, 'tts.provider', result.item.id);
+    if (previous && previous !== result.item.id) {
+      setTtsConfigValue(ctx, 'tts.voice', '');
+      ctx.print(`TTS provider set to ${result.item.id}. TTS voice was cleared because voices are provider-specific.`);
+    } else {
+      ctx.print(`TTS provider set to ${result.item.id}.`);
+    }
+  });
+  return true;
+}
+
+function printTtsProviders(ctx: CommandContext): void {
   const registry = ctx.platform.voiceProviderRegistry;
   if (!registry) {
     ctx.print('Voice provider registry is not available in this runtime.');
     return;
   }
-  const providers = registry.list().filter((provider) => provider.capabilities.includes('tts-stream'));
+  const providers = getStreamingTtsProviders(ctx);
   if (providers.length === 0) {
     ctx.print('No streaming TTS providers are registered.');
     return;
@@ -104,9 +274,113 @@ async function printTtsProviders(ctx: CommandContext): Promise<void> {
   ctx.print([
     'Streaming TTS Providers',
     ...providers.map((provider) => `  ${provider.id}: ${provider.label}`),
+    '',
+    'Set provider: /config-tts provider <provider-id>',
   ].join('\n'));
 }
 
+function getSelectableLlmModels(ctx: CommandContext): ModelDefinition[] {
+  const registry = ctx.provider.providerRegistry as Partial<Pick<typeof ctx.provider.providerRegistry, 'getSelectableModels' | 'listModels'>>;
+  if (typeof registry.getSelectableModels === 'function') return registry.getSelectableModels();
+  if (typeof registry.listModels === 'function') return registry.listModels().filter((model) => model.selectable !== false);
+  return [];
+}
+
+function setTtsLlmProvider(ctx: CommandContext, nextValue: string): void {
+  if (!nextValue) {
+    setTtsConfigValue(ctx, 'tts.llmProvider', '');
+    setTtsConfigValue(ctx, 'tts.llmModel', '');
+    ctx.print('TTS LLM override cleared. /tts will use the current chat model.');
+    return;
+  }
+  const previousProvider = String(ctx.platform.configManager.get('tts.llmProvider') ?? '').trim();
+  setTtsConfigValue(ctx, 'tts.llmProvider', nextValue);
+  if (previousProvider && previousProvider !== nextValue) {
+    setTtsConfigValue(ctx, 'tts.llmModel', '');
+    ctx.print(`TTS LLM provider set to ${nextValue}. TTS LLM model was cleared because models are provider-specific.`);
+    return;
+  }
+  ctx.print(`TTS LLM provider set to ${nextValue}.`);
+}
+
+function setTtsLlmModel(ctx: CommandContext, nextValue: string): void {
+  if (!nextValue) {
+    setTtsConfigValue(ctx, 'tts.llmModel', '');
+    ctx.print('TTS LLM model override cleared. /tts will use the current chat model unless a model is selected.');
+    return;
+  }
+  const preferredProvider = String(ctx.platform.configManager.get('tts.llmProvider') ?? '').trim() || undefined;
+  const selected = findSelectableLlmModel(ctx, nextValue, preferredProvider);
+  if (selected) {
+    setTtsConfigValue(ctx, 'tts.llmProvider', selected.provider);
+    setTtsConfigValue(ctx, 'tts.llmModel', getModelRegistryKey(selected));
+    ctx.print(`TTS LLM set to ${selected.displayName} (${selected.provider}).`);
+    return;
+  }
+  setTtsConfigValue(ctx, 'tts.llmModel', nextValue);
+  ctx.print(`tts.llmModel set to ${nextValue}.`);
+}
+
+function findSelectableLlmModel(ctx: CommandContext, ref: string, preferredProvider?: string): ModelDefinition | undefined {
+  const matches = getSelectableLlmModels(ctx).filter((model) =>
+    model.registryKey === ref || model.id === ref || model.displayName === ref,
+  );
+  if (preferredProvider) {
+    const providerMatch = matches.find((model) => model.provider === preferredProvider);
+    if (providerMatch) return providerMatch;
+  }
+  return matches[0];
+}
+
+function getModelRegistryKey(model: ModelDefinition): string {
+  return model.registryKey ?? `${model.provider}:${model.id}`;
+}
+
+async function openTtsVoicePicker(ctx: CommandContext, providerArg?: string): Promise<boolean> {
+  if (!ctx.openSelection) return false;
+  const service = ctx.platform.voiceService;
+  if (!service) {
+    ctx.print('Voice service is not available in this runtime.');
+    return true;
+  }
+  const providerId = (providerArg ?? String(ctx.platform.configManager.get('tts.provider') ?? '')).trim() || undefined;
+  try {
+    const voices = await service.listVoices(providerId);
+    if (voices.length === 0) {
+      ctx.print(providerId ? `No voices returned for ${providerId}.` : 'No TTS voices returned.');
+      return true;
+    }
+    const current = String(ctx.platform.configManager.get('tts.voice') ?? '').trim();
+    const items: SelectionItem[] = [
+      {
+        id: '__default__',
+        label: 'Use provider default voice',
+        detail: current ? 'clears tts.voice' : '(current)',
+        category: 'voice',
+        primaryAction: 'select',
+      },
+      ...voices.map((voice) => ({
+        id: voice.id,
+        label: voice.label || voice.id,
+        detail: voice.id === current ? `${voice.id}  (current)` : voice.id,
+        category: providerId ?? 'voices',
+        primaryAction: 'select' as const,
+        actions: '[Enter] set voice',
+      })),
+    ];
+    ctx.openSelection(`Choose TTS Voice${providerId ? ` (${providerId})` : ''}`, items, { preSelectId: current || '__default__', allowSearch: true }, (result) => {
+      if (!result) return;
+      const nextVoice = result.item.id === '__default__' ? '' : result.item.id;
+      setTtsConfigValue(ctx, 'tts.voice', nextVoice);
+      ctx.print(nextVoice ? `TTS voice set to ${nextVoice}.` : 'TTS voice cleared. The provider default voice will be used.');
+    });
+    return true;
+  } catch (error) {
+    ctx.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
+    return true;
+  }
+}
+
 async function printTtsVoices(ctx: CommandContext, providerArg?: string): Promise<void> {
   const service = ctx.platform.voiceService;
   if (!service) {
@@ -124,12 +398,19 @@ async function printTtsVoices(ctx: CommandContext, providerArg?: string): Promis
       `TTS Voices${providerId ? ` (${providerId})` : ''}`,
       ...voices.slice(0, 60).map((voice) => `  ${voice.id}: ${voice.label}`),
       ...(voices.length > 60 ? [`  ... ${voices.length - 60} more`] : []),
+      '',
+      'Set voice: /config-tts voice <voice-id>',
+      'Use provider default voice: /config-tts voice clear',
     ].join('\n'));
   } catch (error) {
     ctx.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 
+function setTtsConfigValue(ctx: CommandContext, key: ConfigKey, value: string): void {
+  ctx.platform.configManager.setDynamic(key, value);
+}
+
 function formatValue(value: unknown): string {
   const text = String(value ?? '').trim();
   return text || '(default)';

package/src/input/commands.ts

@@ -55,6 +55,7 @@ import { registerConversationRuntimeCommands } from './commands/conversation-run
 import { registerQrcodeRuntimeCommands } from './commands/qrcode-runtime.ts';
 import { registerOnboardingRuntimeCommands } from './commands/onboarding-runtime.ts';
 import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
+import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -104,6 +105,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerQrcodeRuntimeCommands(registry);
   registerOnboardingRuntimeCommands(registry);
   registerTtsRuntimeCommands(registry);
+  registerCloudflareRuntimeCommands(registry);
   registerLocalRuntimeCommands(registry);
   registerSessionWorkflowCommands(registry);
   registerDiscoveryRuntimeCommands(registry);

package/src/input/feed-context-factory.ts

@@ -152,6 +152,7 @@ export interface FeedContextClosures {
   cleanupMarkerRegistry: (text: string) => void;
   expandPrompt: (text: string) => string | import('@pellux/goodvibes-sdk/platform/providers/interface').ContentPart[];
   openModelPickerWithTarget: (target: ModelPickerTarget, source?: 'settings' | 'onboarding') => boolean;
+  openProviderModelPickerWithTarget: (target: ModelPickerTarget, source?: 'settings' | 'onboarding') => boolean;
   onModelPickerCommit: () => boolean;
   onOnboardingAction: (action: import('./onboarding/onboarding-wizard.ts').OnboardingWizardAction) => void;
 }

package/src/input/handler-feed.ts

@@ -153,6 +153,7 @@ export interface InputFeedContext {
   readonly cleanupMarkerRegistry: (text: string) => void;
   readonly expandPrompt: (text: string) => string | import('@pellux/goodvibes-sdk/platform/providers/interface').ContentPart[];
   readonly openModelPickerWithTarget: (target: ModelPickerTarget, source?: 'settings' | 'onboarding') => boolean;
+  readonly openProviderModelPickerWithTarget: (target: ModelPickerTarget, source?: 'settings' | 'onboarding') => boolean;
   readonly onModelPickerCommit: () => boolean;
   readonly onOnboardingAction: (action: OnboardingWizardAction) => void;
   readonly exitApp: () => void;
@@ -176,6 +177,10 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       searchShortcutMatch: token.type === 'key' && keybindings.matches('search', token),
       selectionModal: context.selectionModal,
       selectionCallback: context.selectionCallback,
+      getSelectionCallback: () => context.selectionCallback,
+      setSelectionCallback: (callback) => {
+        context.selectionCallback = callback;
+      },
       bookmarkModal: context.bookmarkModal,
       settingsModal: context.settingsModal,
       sessionPickerModal: context.sessionPickerModal,
@@ -213,6 +218,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       scroll: context.scroll,
       getScrollTop: context.getScrollTop,
       openModelPickerWithTarget: context.openModelPickerWithTarget,
+      openProviderModelPickerWithTarget: context.openProviderModelPickerWithTarget,
       onModelPickerCommit: context.onModelPickerCommit,
       onOnboardingAction: context.onOnboardingAction,
     }, token);

package/src/input/handler-modal-routes.ts

@@ -19,6 +19,8 @@ type SelectionRouteState = {
     close: () => void;
   };
   selectionCallback: ((result: SelectionResult | null) => void) | null;
+  getSelectionCallback?: () => ((result: SelectionResult | null) => void) | null;
+  setSelectionCallback?: (callback: ((result: SelectionResult | null) => void) | null) => void;
   modalStack: string[];
   requestRender: () => void;
   handleEscape: () => void;
@@ -53,11 +55,13 @@ export function handleSelectionModalToken(state: SelectionRouteState, token: Inp
     }
     const cb = state.selectionCallback;
     state.selectionCallback = null;
+    state.setSelectionCallback?.(null);
     state.selectionModal.close();
     if (state.modalStack.length > 0 && state.modalStack[state.modalStack.length - 1] === 'selection') {
       state.modalStack.pop();
     }
     cb?.({ item: selected, action, step });
+    state.selectionCallback = state.getSelectionCallback?.() ?? state.selectionCallback;
   };
 
   const getAdjustmentStep = (
@@ -216,13 +220,30 @@ type SettingsRouteState = {
     editBackspace: () => void;
     editChar: (char: string) => void;
     pendingModelPickerTarget: import('./model-picker.ts').ModelPickerTarget | null;
+    pendingProviderModelPickerTarget?: import('./model-picker.ts').ModelPickerTarget | null;
   };
   /** Called when the settings modal requests the model picker for a non-main target. */
   openModelPickerWithTarget?: (target: import('./model-picker.ts').ModelPickerTarget) => void;
+  /** Called when the settings modal requests provider selection before model selection. */
+  openProviderModelPickerWithTarget?: (target: import('./model-picker.ts').ModelPickerTarget) => void;
   requestRender: () => void;
   handleEscape: () => void;
 };
 
+function consumeSettingsPickerRequest(state: SettingsRouteState): void {
+  const providerModelTarget = state.settingsModal.pendingProviderModelPickerTarget ?? null;
+  if (providerModelTarget !== null) {
+    state.settingsModal.pendingProviderModelPickerTarget = null;
+    state.openProviderModelPickerWithTarget?.(providerModelTarget);
+    return;
+  }
+  const pickerTarget = state.settingsModal.pendingModelPickerTarget;
+  if (pickerTarget !== null) {
+    state.settingsModal.pendingModelPickerTarget = null;
+    state.openModelPickerWithTarget?.(pickerTarget);
+  }
+}
+
 export function handleSettingsModalToken(state: SettingsRouteState, token: InputToken): boolean {
   if (!state.settingsModal.active) return false;
 
@@ -236,11 +257,7 @@ export function handleSettingsModalToken(state: SettingsRouteState, token: Input
       else if (state.settingsModal.currentCategory === 'flags') state.settingsModal.toggleSelectedFlag();
       else {
         state.settingsModal.activateSelected();
-        const pickerTarget = state.settingsModal.pendingModelPickerTarget;
-        if (pickerTarget !== null) {
-          state.settingsModal.pendingModelPickerTarget = null;
-          state.openModelPickerWithTarget?.(pickerTarget);
-        }
+        consumeSettingsPickerRequest(state);
       }
     } else if ((token.logicalName === 'left' || token.logicalName === 'right') && !state.settingsModal.editingMode) {
       state.settingsModal.adjustSelected(token.logicalName, token.shift ? 10 : 1);
@@ -253,11 +270,7 @@ export function handleSettingsModalToken(state: SettingsRouteState, token: Input
       if (state.settingsModal.currentCategory === 'flags') state.settingsModal.toggleSelectedFlag();
       else {
         state.settingsModal.activateSelected();
-        const pickerTarget = state.settingsModal.pendingModelPickerTarget;
-        if (pickerTarget !== null) {
-          state.settingsModal.pendingModelPickerTarget = null;
-          state.openModelPickerWithTarget?.(pickerTarget);
-        }
+        consumeSettingsPickerRequest(state);
       }
     } else if (state.settingsModal.editingMode) {
       state.settingsModal.editChar(token.value);

package/src/input/handler-modal-token-routes.ts

@@ -39,6 +39,8 @@ export type ModalTokenRouteState = {
   searchShortcutMatch: boolean;
   selectionModal: SelectionModal;
   selectionCallback: ((result: SelectionResult | null) => void) | null;
+  getSelectionCallback?: () => ((result: SelectionResult | null) => void) | null;
+  setSelectionCallback?: (callback: ((result: SelectionResult | null) => void) | null) => void;
   bookmarkModal: BookmarkModal;
   settingsModal: SettingsModal;
   sessionPickerModal: SessionPickerModal;
@@ -80,6 +82,10 @@ export type ModalTokenRouteState = {
     target: import('./model-picker.ts').ModelPickerTarget,
     source?: 'settings' | 'onboarding',
   ) => boolean;
+  openProviderModelPickerWithTarget?: (
+    target: import('./model-picker.ts').ModelPickerTarget,
+    source?: 'settings' | 'onboarding',
+  ) => boolean;
   clearOnboardingModelPickerCancelState?: () => void;
   restoreOnboardingModelPickerCancelState?: () => void;
   onModelPickerCommit?: () => boolean;
@@ -110,6 +116,8 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
   const selectionState = {
     selectionModal: state.selectionModal,
     selectionCallback: state.selectionCallback,
+    getSelectionCallback: state.getSelectionCallback,
+    setSelectionCallback: state.setSelectionCallback,
     modalStack: state.modalStack,
     requestRender: state.requestRender,
     handleEscape: state.handleEscape,
@@ -130,6 +138,7 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
   if (handleSettingsModalToken({
     settingsModal: state.settingsModal,
     openModelPickerWithTarget: state.openModelPickerWithTarget,
+    openProviderModelPickerWithTarget: state.openProviderModelPickerWithTarget,
     requestRender: state.requestRender,
     handleEscape: state.handleEscape,
   }, token)) {