@nextclaw/ui 0.15.22 → 0.15.24

package/src/features/chat/features/input/utils/__tests__/chat-input-bar.utils.test.ts

@@ -1,5 +1,6 @@
 import {
   buildChatSlashItems,
+  buildModelStateHint,
   buildModelToolbarSelect,
   buildSkillPickerModel
 } from '@/features/chat/features/input/utils/chat-input-bar.utils';
@@ -23,11 +24,49 @@ function createModelTexts() {
     favoriteModelLabel: 'Favorite model',
     unfavoriteModelLabel: 'Remove favorite',
     manageModelsLabel: 'Manage models and providers',
+    discoveredModelsSummaryLabel: '{count} new models available',
+    discoveredModelsViewLabel: 'View',
+    discoveredModelsGroupLabel: 'New models',
+    discoveredModelAddLabel: 'Add',
+    discoveredModelAddedLabel: 'Added',
+    discoveredModelsDismissLabel: 'Dismiss this batch',
+    discoveredModelsDoneLabel: 'Done',
+    discoveredModelsCloseLabel: 'Close new models',
     recentModelsLabel: 'Recent',
     allModelsLabel: 'All models'
   };
 }
 
+describe('buildModelStateHint', () => {
+  it('keeps the input surface clear while model options are unresolved', () => {
+    expect(buildModelStateHint({
+      isModelOptionsEmpty: false,
+      onGoToProviders: vi.fn(),
+      texts: {
+        noModelOptionsLabel: 'No models',
+        configureProviderLabel: 'Configure provider'
+      }
+    })).toBeNull();
+  });
+
+  it('keeps the actionable warning when model loading resolves empty', () => {
+    const onGoToProviders = vi.fn();
+
+    expect(buildModelStateHint({
+      isModelOptionsEmpty: true,
+      onGoToProviders,
+      texts: {
+        noModelOptionsLabel: 'No models',
+        configureProviderLabel: 'Configure provider'
+      }
+    })).toEqual({
+      tone: 'warning',
+      text: 'No models',
+      actionLabel: 'Configure provider',
+      onAction: onGoToProviders
+    });
+  });
+});
 describe('buildChatSlashItems', () => {
   const texts = {
     slashSkillSubtitle: 'Skill',
@@ -239,6 +278,78 @@ describe('buildSkillPickerModel', () => {
 });
 
 describe('buildModelToolbarSelect', () => {
+  it('exposes discovered models through an expanded-panel contract without changing the selected label', () => {
+    const onDiscoveredModelsDismiss = vi.fn();
+    const onDiscoveredModelSelect = vi.fn();
+    const onOpen = vi.fn();
+    const select = buildModelToolbarSelect({
+      modelOptions: [{
+        value: 'opencode/big-pickle',
+        modelLabel: 'big-pickle',
+        providerLabel: 'OpenCode',
+      }],
+      discoveredModelOptions: [
+        {
+          value: 'opencode/deepseek-v4-flash-free',
+          modelLabel: 'deepseek-v4-flash-free',
+          providerLabel: 'OpenCode',
+        },
+        {
+          value: 'openrouter/inclusionai/ling-3.0-tiny:free',
+          modelLabel: 'inclusionai/ling-3.0-tiny:free',
+          providerLabel: 'OpenRouter',
+        },
+      ],
+      recentModelValues: [],
+      selectedModel: 'opencode/big-pickle',
+      isModelOptionsLoading: false,
+      hasModelOptions: true,
+      onDiscoveredModelSelect,
+      onDiscoveredModelsDismiss,
+      onOpen,
+      onValueChange: vi.fn(),
+      texts: createModelTexts(),
+    });
+
+    expect(select.selectedLabel).toBe('OpenCode/big-pickle');
+    expect(select.discovery).toEqual({
+      summaryLabel: '2 new models available',
+      viewLabel: 'View',
+      groupLabel: 'New models',
+      allGroupLabel: 'All models',
+      actionLabel: 'Add',
+      addedLabel: 'Added',
+      dismissLabel: 'Dismiss this batch',
+      doneLabel: 'Done',
+      closeLabel: 'Close new models',
+      searchPlaceholder: 'Search models',
+      searchEmptyLabel: 'No matching models',
+      groups: [
+        {
+          key: 'opencode',
+          label: 'OpenCode',
+          options: [{
+            value: 'opencode/deepseek-v4-flash-free',
+            label: 'deepseek-v4-flash-free',
+          }],
+        },
+        {
+          key: 'openrouter',
+          label: 'OpenRouter',
+          options: [{
+            value: 'openrouter/inclusionai/ling-3.0-tiny:free',
+            label: 'inclusionai/ling-3.0-tiny:free',
+          }],
+        },
+      ],
+      onDismiss: onDiscoveredModelsDismiss,
+      onSelect: onDiscoveredModelSelect,
+    });
+    expect(select.onOpen).toBe(onOpen);
+  });
+});
+
+describe('buildModelToolbarSelect selection', () => {
   it('falls back to the first available option when the selected model is missing', () => {
     const onValueChange = vi.fn();
     const select = buildModelToolbarSelect({

package/src/features/chat/features/input/utils/chat-composer-state.utils.ts

@@ -29,6 +29,27 @@ function appendTextPart(parts: NcpMessagePart[], text: string): NcpMessagePart[]
   ];
 }
 
+function hasSerializedTokenText(node: ChatComposerNode | undefined): boolean {
+  return node?.type === 'token' && Boolean(serializeChatComposerTokenText(node));
+}
+
+function serializeTokenWithTextBoundaries(params: {
+  index: number;
+  nodes: readonly ChatComposerNode[];
+  tokenText: string;
+}): string {
+  const { index, nodes, tokenText } = params;
+  const previousNode = nodes[index - 1];
+  const nextNode = nodes[index + 1];
+  const needsLeadingSpace = (
+    previousNode?.type === 'text' && /\S$/.test(previousNode.text)
+  ) || hasSerializedTokenText(previousNode);
+  const needsTrailingSpace = (
+    nextNode?.type === 'text' && /^\S/.test(nextNode.text)
+  ) || hasSerializedTokenText(nextNode);
+  return `${needsLeadingSpace ? ' ' : ''}${tokenText}${needsTrailingSpace ? ' ' : ''}`;
+}
+
 export function createInitialChatComposerNodes(): ChatComposerNode[] {
   return createEmptyChatComposerNodes();
 }
@@ -102,7 +123,7 @@ export function deriveNcpMessagePartsFromComposer(
   const attachmentById = new Map(attachments.map((attachment) => [attachment.id, attachment]));
   let parts: NcpMessagePart[] = [];
 
-  for (const node of nodes) {
+  for (const [index, node] of nodes.entries()) {
     if (node.type === 'text') {
       parts = appendTextPart(parts, node.text);
       continue;
@@ -110,7 +131,11 @@ export function deriveNcpMessagePartsFromComposer(
 
     const tokenText = serializeChatComposerTokenText(node);
     if (tokenText) {
-      parts = appendTextPart(parts, tokenText);
+      parts = appendTextPart(parts, serializeTokenWithTextBoundaries({
+        index,
+        nodes,
+        tokenText,
+      }));
       continue;
     }
 

package/src/features/chat/features/input/utils/chat-composer-token-protocol.utils.ts

@@ -1,6 +1,8 @@
 import {
+  CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
   CHAT_PROJECT_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
+  CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
 } from '@nextclaw/shared';
 
@@ -9,6 +11,8 @@ const CHAT_PANEL_APP_TOKEN_PREFIX = '@panel-app:';
 const CHAT_PROJECT_TOKEN_PREFIX = '@project:';
 const CHAT_WORKSPACE_FILE_TOKEN_PREFIX = '@file:';
 const CHAT_WORKSPACE_DIRECTORY_TOKEN_PREFIX = '@folder:';
+const CHAT_WORKSPACE_EXCERPT_TOKEN_PREFIX = '@excerpt:';
+const CHAT_CONVERSATION_EXCERPT_TOKEN_PREFIX = '@message-excerpt:';
 
 export function serializeChatComposerTokenText(params: {
   label?: string;
@@ -31,5 +35,11 @@ export function serializeChatComposerTokenText(params: {
   if (tokenKind === CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND) {
     return `${CHAT_WORKSPACE_DIRECTORY_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
   }
+  if (tokenKind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND) {
+    return `${CHAT_WORKSPACE_EXCERPT_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
+  }
+  if (tokenKind === CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) {
+    return `${CHAT_CONVERSATION_EXCERPT_TOKEN_PREFIX}${encodeURIComponent(tokenKey)}`;
+  }
   return null;
 }

package/src/features/chat/features/input/utils/chat-conversation-excerpt-token.utils.ts

@@ -0,0 +1,59 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import {
+  CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+  type ChatConversationExcerptInlineTokenMetadata,
+} from '@nextclaw/shared';
+
+type ComposerTokenNode = Extract<ChatComposerNode, { type: 'token' }>;
+
+function readRequiredString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function readConversationExcerptFields(source: Record<string, unknown>): {
+  messageId: string;
+  role: 'assistant' | 'user';
+  excerpt: string;
+} | null {
+  const messageId = readRequiredString(source.messageId);
+  const excerpt = readRequiredString(source.excerpt);
+  const { role } = source;
+  return messageId && excerpt && (role === 'assistant' || role === 'user')
+    ? { messageId, role, excerpt }
+    : null;
+}
+
+export function buildConversationExcerptInlineToken(
+  node: ComposerTokenNode,
+  rawText: string,
+): ChatConversationExcerptInlineTokenMetadata | null {
+  const fields = readConversationExcerptFields(node.data ?? {});
+  return fields
+    ? {
+        kind: CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+        key: node.tokenKey,
+        label: node.label,
+        rawText,
+        ...fields,
+      }
+    : null;
+}
+
+export function readConversationExcerptInlineToken(params: {
+  entry: Record<string, unknown>;
+  label: string;
+  rawText: string;
+}): ChatConversationExcerptInlineTokenMetadata | null {
+  const { entry, label, rawText } = params;
+  const key = readRequiredString(entry.key);
+  const fields = readConversationExcerptFields(entry);
+  return key && fields
+    ? {
+        kind: CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+        key,
+        label,
+        rawText,
+        ...fields,
+      }
+    : null;
+}

package/src/features/chat/features/input/utils/chat-inline-token.utils.ts

@@ -1,15 +1,18 @@
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import {
+  CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
   CHAT_INLINE_TOKENS_METADATA_KEY,
   CHAT_INLINE_TOKENS_SCHEMA_VERSION,
   CHAT_PROJECT_TOKEN_KIND,
   CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND,
+  CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
   CHAT_WORKSPACE_FILE_TOKEN_KIND,
   type ChatInlineTokenMetadata,
   type ChatInlineTokensMetadata,
   type ChatSkillSource,
 } from '@nextclaw/shared';
 import { serializeChatComposerTokenText } from './chat-composer-token-protocol.utils';
+import { buildConversationExcerptInlineToken, readConversationExcerptInlineToken } from './chat-conversation-excerpt-token.utils';
 
 export { CHAT_INLINE_TOKENS_METADATA_KEY };
 const CHAT_PANEL_APP_TOKEN_PREFIX = '@panel-app:';
@@ -35,6 +38,25 @@ export type ChatInlineTokenSource =
       label: string;
       rawText: string;
     }
+  | {
+      kind: typeof CHAT_CONVERSATION_EXCERPT_TOKEN_KIND;
+      key: string;
+      messageId: string;
+      role: 'assistant' | 'user';
+      label: string;
+      excerpt: string;
+      rawText: string;
+    }
+  | {
+      kind: typeof CHAT_WORKSPACE_EXCERPT_TOKEN_KIND;
+      key: string;
+      path: string;
+      label: string;
+      excerpt: string;
+      startLine: number | null;
+      endLine: number | null;
+      rawText: string;
+    }
   | {
       kind: string;
       key: string;
@@ -71,6 +93,12 @@ function readOptionalString(value: unknown): string | null {
   return trimmed.length > 0 ? trimmed : null;
 }
 
+function readOptionalLine(value: unknown): number | null {
+  return typeof value === 'number' && Number.isInteger(value) && value > 0
+    ? value
+    : null;
+}
+
 function dedupeInlineTokens<T extends ChatInlineTokenSource>(tokens: readonly T[]): T[] {
   const seen = new Set<string>();
   const output: T[] = [];
@@ -86,6 +114,26 @@ function dedupeInlineTokens<T extends ChatInlineTokenSource>(tokens: readonly T[
   return output;
 }
 
+function appendWorkspaceExcerptToken(
+  tokens: ChatInlineTokenMetadata[],
+  node: Extract<ChatComposerNode, { type: 'token' }>,
+  rawText: string,
+): void {
+  const path = readOptionalString(node.data?.path);
+  const excerpt = readOptionalString(node.data?.excerpt);
+  if (!path || !excerpt) return;
+  tokens.push({
+    kind: CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+    key: node.tokenKey,
+    path,
+    label: node.label,
+    excerpt,
+    startLine: readOptionalLine(node.data?.startLine),
+    endLine: readOptionalLine(node.data?.endLine),
+    rawText,
+  });
+}
+
 export function buildInlineTokensFromComposer(
   nodes: readonly ChatComposerNode[],
   skillRecords: readonly ChatSkillReferenceSnapshot[] = [],
@@ -100,7 +148,9 @@ export function buildInlineTokensFromComposer(
       node.tokenKind !== 'skill' &&
       node.tokenKind !== CHAT_PROJECT_TOKEN_KIND &&
       node.tokenKind !== CHAT_WORKSPACE_FILE_TOKEN_KIND &&
-      node.tokenKind !== CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND
+      node.tokenKind !== CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND &&
+      node.tokenKind !== CHAT_WORKSPACE_EXCERPT_TOKEN_KIND &&
+      node.tokenKind !== CHAT_CONVERSATION_EXCERPT_TOKEN_KIND
     ) {
       continue;
     }
@@ -133,6 +183,15 @@ export function buildInlineTokensFromComposer(
       });
       continue;
     }
+    if (node.tokenKind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND) {
+      appendWorkspaceExcerptToken(tokens, node, rawText);
+      continue;
+    }
+    if (node.tokenKind === CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) {
+      const token = buildConversationExcerptInlineToken(node, rawText);
+      if (token) tokens.push(token);
+      continue;
+    }
     const workspaceKind = node.tokenKind === CHAT_WORKSPACE_FILE_TOKEN_KIND
       ? CHAT_WORKSPACE_FILE_TOKEN_KIND
       : CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND;
@@ -215,7 +274,15 @@ export function resolveInlineTokensForText(
   text: string,
   tokens: readonly ChatInlineTokenSource[]
 ): ChatInlineTokenSource[] {
-  return dedupeInlineTokens([...tokens, ...buildInlineTokensFromTextProtocol(text)]);
+  const inferredTokens = buildInlineTokensFromTextProtocol(text).filter((inferredToken) => {
+    const inferredIndex = text.indexOf(inferredToken.rawText);
+    return !tokens.some((explicitToken) => (
+      explicitToken.kind === inferredToken.kind &&
+      inferredToken.rawText.startsWith(explicitToken.rawText) &&
+      text.indexOf(explicitToken.rawText) === inferredIndex
+    ));
+  });
+  return dedupeInlineTokens([...tokens, ...inferredTokens]);
 }
 
 export function readInlineTokensFromMetadata(
@@ -235,36 +302,8 @@ export function readInlineTokensFromMetadata(
 
   const tokens: ChatInlineTokenSource[] = [];
   for (const entry of raw.items) {
-    if (!isRecord(entry)) {
-      continue;
-    }
-    const kind = readOptionalString(entry.kind);
-    const rawText = readOptionalString(entry.rawText);
-    const label = readOptionalString(entry.label);
-    if (!kind || !label || !rawText) {
-      continue;
-    }
-    if (kind === 'skill') {
-      const ref = readOptionalString(entry.ref);
-      const name = readOptionalString(entry.name);
-      const path = readOptionalString(entry.path);
-      const source = readSkillSource(entry.source);
-      if (!ref || !name || !path || !source) {
-        continue;
-      }
-      tokens.push({ kind, ref, name, source, path, label, rawText });
-      continue;
-    }
-    const key = readOptionalString(entry.key);
-    if (!key) {
-      continue;
-    }
-    tokens.push({
-      kind,
-      key,
-      rawText,
-      label,
-    });
+    const token = readInlineTokenEntry(entry);
+    if (token) tokens.push(token);
   }
 
   return dedupeInlineTokens(tokens);
@@ -276,6 +315,58 @@ function readSkillSource(value: unknown): ChatSkillSource | null {
     : null;
 }
 
+function readInlineTokenEntry(entry: unknown): ChatInlineTokenSource | null {
+  if (!isRecord(entry)) {
+    return null;
+  }
+  const kind = readOptionalString(entry.kind);
+  const rawText = readOptionalString(entry.rawText);
+  const label = readOptionalString(entry.label);
+  if (!kind || !label || !rawText) {
+    return null;
+  }
+  if (kind === 'skill') {
+    const ref = readOptionalString(entry.ref);
+    const name = readOptionalString(entry.name);
+    const path = readOptionalString(entry.path);
+    const source = readSkillSource(entry.source);
+    return ref && name && path && source
+      ? { kind, ref, name, source, path, label, rawText }
+      : null;
+  }
+  if (kind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND) {
+    return readWorkspaceExcerptInlineToken({ entry, label, rawText });
+  }
+  if (kind === CHAT_CONVERSATION_EXCERPT_TOKEN_KIND) {
+    return readConversationExcerptInlineToken({ entry, label, rawText });
+  }
+  const key = readOptionalString(entry.key);
+  return key ? { kind, key, rawText, label } : null;
+}
+
+function readWorkspaceExcerptInlineToken(params: {
+  entry: Record<string, unknown>;
+  label: string;
+  rawText: string;
+}): ChatInlineTokenSource | null {
+  const { entry, label, rawText } = params;
+  const key = readOptionalString(entry.key);
+  const path = readOptionalString(entry.path);
+  const excerpt = readOptionalString(entry.excerpt);
+  return key && path && excerpt
+    ? {
+        kind: CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+        key,
+        path,
+        label,
+        excerpt,
+        startLine: readOptionalLine(entry.startLine),
+        endLine: readOptionalLine(entry.endLine),
+        rawText,
+      }
+    : null;
+}
+
 function readLegacyInlineTokens(entries: readonly unknown[]): ChatInlineTokenSource[] {
   const tokens: ChatInlineTokenSource[] = [];
   for (const entry of entries) {

package/src/features/chat/features/input/utils/chat-input-bar.utils.ts

@@ -8,6 +8,7 @@ export {
   buildModelStateHint,
   buildModelToolbarSelect,
   buildThinkingToolbarSelect,
+  toChatModelRecords,
 } from "./chat-input-toolbar.utils";
 import type {
   ChatInputBarAdapterTexts,

package/src/features/chat/features/input/utils/chat-input-toolbar.utils.ts

@@ -7,12 +7,42 @@ import type {
   ChatModelRecord,
   ChatThinkingLevel,
 } from "@/features/chat/types/chat-input-bar.types";
+import type { ChatModelOption } from "@/features/chat/types/chat-input.types";
 
 function formatModelOptionLabel(option: ChatModelRecord): string {
   const modelLabel = option.modelLabel.trim();
   const providerLabel = option.providerLabel.trim();
   return providerLabel ? `${providerLabel}/${modelLabel}` : modelLabel;
 }
+function buildDiscoveredModelGroups(options: ChatModelRecord[]) {
+  const groups = new Map<string, { key: string; label: string; options: Array<{ value: string; label: string }> }>();
+  for (const option of options) {
+    const separatorIndex = option.value.indexOf('/');
+    const providerKey = separatorIndex > 0 ? option.value.slice(0, separatorIndex) : option.providerLabel;
+    const group = groups.get(providerKey) ?? {
+      key: providerKey,
+      label: option.providerLabel,
+      options: [],
+    };
+    group.options.push({ value: option.value, label: option.modelLabel });
+    groups.set(providerKey, group);
+  }
+  return [...groups.values()];
+}
+
+export function toChatModelRecords(snapshotModels: ChatModelOption[]): ChatModelRecord[] {
+  return snapshotModels.map((model) => ({
+    value: model.value,
+    modelLabel: model.modelLabel,
+    providerLabel: model.providerLabel,
+    thinkingCapability: model.thinkingCapability
+      ? {
+          supported: model.thinkingCapability.supported as ChatThinkingLevel[],
+          default: (model.thinkingCapability.default as ChatThinkingLevel | null | undefined) ?? null,
+        }
+      : null,
+  }));
+}
 
 function normalizeThinkingLevels(
   levels: ChatThinkingLevel[],
@@ -27,7 +57,6 @@ function normalizeThinkingLevels(
 }
 
 export function buildModelStateHint(params: {
-  isModelOptionsLoading: boolean;
   isModelOptionsEmpty: boolean;
   onGoToProviders: () => void;
   texts: Pick<
@@ -37,19 +66,12 @@ export function buildModelStateHint(params: {
 }): ChatInlineHint | null {
   const {
     isModelOptionsEmpty,
-    isModelOptionsLoading,
     onGoToProviders,
     texts,
   } = params;
-  if (!isModelOptionsLoading && !isModelOptionsEmpty) {
+  if (!isModelOptionsEmpty) {
     return null;
   }
-  if (isModelOptionsLoading) {
-    return {
-      tone: "neutral",
-      loading: true,
-    };
-  }
   return {
     tone: "warning",
     text: texts.noModelOptionsLabel,
@@ -58,24 +80,73 @@ export function buildModelStateHint(params: {
   };
 }
 
+function buildModelDiscovery(params: {
+  options: ChatModelRecord[];
+  onDismiss?: () => void;
+  onSelect?: (value: string) => Promise<void> | void;
+  texts: Pick<
+    ChatInputBarAdapterTexts,
+    | "allModelsLabel"
+    | "discoveredModelAddLabel"
+    | "discoveredModelAddedLabel"
+    | "discoveredModelsCloseLabel"
+    | "discoveredModelsDismissLabel"
+    | "discoveredModelsDoneLabel"
+    | "discoveredModelsGroupLabel"
+    | "discoveredModelsSummaryLabel"
+    | "discoveredModelsViewLabel"
+    | "modelSearchEmptyLabel"
+    | "modelSearchPlaceholder"
+  >;
+}): ChatToolbarSelect["discovery"] {
+  const { onDismiss, onSelect, options, texts } = params;
+  if (!onDismiss || !onSelect || options.length === 0) {
+    return undefined;
+  }
+  return {
+    summaryLabel: texts.discoveredModelsSummaryLabel.replace('{count}', String(options.length)),
+    viewLabel: texts.discoveredModelsViewLabel,
+    groupLabel: texts.discoveredModelsGroupLabel,
+    allGroupLabel: texts.allModelsLabel,
+    actionLabel: texts.discoveredModelAddLabel,
+    addedLabel: texts.discoveredModelAddedLabel,
+    dismissLabel: texts.discoveredModelsDismissLabel,
+    doneLabel: texts.discoveredModelsDoneLabel,
+    closeLabel: texts.discoveredModelsCloseLabel,
+    searchPlaceholder: texts.modelSearchPlaceholder,
+    searchEmptyLabel: texts.modelSearchEmptyLabel,
+    groups: buildDiscoveredModelGroups(options),
+    onDismiss,
+    onSelect,
+  };
+}
+
 export function buildModelToolbarSelect({
   modelOptions,
+  discoveredModelOptions,
   favoriteModelValues,
   recentModelValues,
   selectedModel,
   isModelOptionsLoading,
   hasModelOptions,
   onFavoriteToggle,
+  onDiscoveredModelSelect,
+  onDiscoveredModelsDismiss,
+  onOpen,
   onValueChange,
   texts,
 }: {
   modelOptions: ChatModelRecord[];
+  discoveredModelOptions?: ChatModelRecord[];
   favoriteModelValues?: string[];
   recentModelValues?: string[];
   selectedModel: string;
   isModelOptionsLoading: boolean;
   hasModelOptions: boolean;
   onFavoriteToggle?: (value: string, favorite: boolean) => void;
+  onDiscoveredModelSelect?: (value: string) => Promise<void> | void;
+  onDiscoveredModelsDismiss?: () => void;
+  onOpen?: () => void;
   onValueChange: (value: string) => void;
   texts: Pick<
     ChatInputBarAdapterTexts,
@@ -87,6 +158,14 @@ export function buildModelToolbarSelect({
     | "favoriteModelLabel"
     | "unfavoriteModelLabel"
     | "manageModelsLabel"
+    | "discoveredModelsSummaryLabel"
+    | "discoveredModelsViewLabel"
+    | "discoveredModelsGroupLabel"
+    | "discoveredModelAddLabel"
+    | "discoveredModelAddedLabel"
+    | "discoveredModelsDismissLabel"
+    | "discoveredModelsDoneLabel"
+    | "discoveredModelsCloseLabel"
     | "recentModelsLabel"
     | "allModelsLabel"
   >;
@@ -143,6 +222,7 @@ export function buildModelToolbarSelect({
           },
         ].filter((group) => group.options.length > 0)
     : undefined;
+  const discoveryOptions = discoveredModelOptions ?? [];
 
   return {
     key: "model",
@@ -157,7 +237,7 @@ export function buildModelToolbarSelect({
       label: formatModelOptionLabel(option),
     })),
     groups: optionGroups,
-    disabled: !hasModelOptions,
+    disabled: !hasModelOptions && discoveryOptions.length === 0,
     loading: isModelOptionsLoading,
     emptyLabel: texts.modelNoOptionsLabel,
     search: {
@@ -173,8 +253,15 @@ export function buildModelToolbarSelect({
           onToggle: onFavoriteToggle,
         }
       : undefined,
+    discovery: buildModelDiscovery({
+      options: discoveryOptions,
+      onDismiss: onDiscoveredModelsDismiss,
+      onSelect: onDiscoveredModelSelect,
+      texts,
+    }),
     manageLabel: texts.manageModelsLabel,
     manageHref: "/providers",
+    onOpen,
     onValueChange,
   };
 }