@nextclaw/ui 0.11.17 → 0.11.19

package/src/components/chat/chat-inline-token.utils.ts

@@ -0,0 +1,146 @@
+import type { ChatComposerNode } from "@nextclaw/agent-chat-ui";
+
+export const CHAT_UI_INLINE_TOKENS_METADATA_KEY = "ui_inline_tokens";
+const CHAT_SKILL_TOKEN_PREFIX = "$";
+
+export type ChatInlineTokenSource = {
+  kind: string;
+  key: string;
+  label: string;
+  rawText: string;
+};
+
+export type ChatInlineTextFragment =
+  | {
+      type: "text";
+      text: string;
+    }
+  | {
+      type: "token";
+      token: ChatInlineTokenSource;
+    };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readOptionalString(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function dedupeInlineTokens(
+  tokens: readonly ChatInlineTokenSource[],
+): ChatInlineTokenSource[] {
+  const seen = new Set<string>();
+  const output: ChatInlineTokenSource[] = [];
+  for (const token of tokens) {
+    const dedupeKey = `${token.kind}:${token.key}:${token.rawText}`;
+    if (seen.has(dedupeKey)) {
+      continue;
+    }
+    seen.add(dedupeKey);
+    output.push(token);
+  }
+  return output;
+}
+
+export function buildInlineSkillTokensFromComposer(
+  nodes: readonly ChatComposerNode[],
+): ChatInlineTokenSource[] {
+  const tokens: ChatInlineTokenSource[] = [];
+  for (const node of nodes) {
+    if (node.type !== "token" || node.tokenKind !== "skill") {
+      continue;
+    }
+    tokens.push({
+      kind: "skill",
+      key: node.tokenKey,
+      label: node.label,
+      rawText: `${CHAT_SKILL_TOKEN_PREFIX}${node.tokenKey}`,
+    });
+  }
+  return dedupeInlineTokens(tokens);
+}
+
+export function readInlineTokensFromMetadata(
+  metadata: Record<string, unknown> | undefined,
+): ChatInlineTokenSource[] {
+  const raw = metadata?.[CHAT_UI_INLINE_TOKENS_METADATA_KEY];
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+
+  const tokens: ChatInlineTokenSource[] = [];
+  for (const entry of raw) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    const kind = readOptionalString(entry.kind);
+    const key = readOptionalString(entry.key);
+    const rawText = readOptionalString(entry.rawText);
+    if (!kind || !key || !rawText) {
+      continue;
+    }
+    tokens.push({
+      kind,
+      key,
+      rawText,
+      label: readOptionalString(entry.label) ?? key,
+    });
+  }
+
+  return dedupeInlineTokens(tokens);
+}
+
+export function splitTextByInlineTokens(
+  text: string,
+  tokens: readonly ChatInlineTokenSource[],
+): ChatInlineTextFragment[] {
+  if (text.length === 0 || tokens.length === 0) {
+    return text.length === 0 ? [] : [{ type: "text", text }];
+  }
+
+  const orderedTokens = [...tokens].sort(
+    (left, right) => right.rawText.length - left.rawText.length,
+  );
+  const fragments: ChatInlineTextFragment[] = [];
+  let cursor = 0;
+
+  while (cursor < text.length) {
+    let matchedToken: ChatInlineTokenSource | null = null;
+    for (const token of orderedTokens) {
+      if (text.startsWith(token.rawText, cursor)) {
+        matchedToken = token;
+        break;
+      }
+    }
+
+    if (!matchedToken) {
+      let nextCursor = cursor + 1;
+      while (nextCursor < text.length) {
+        if (orderedTokens.some((token) => text.startsWith(token.rawText, nextCursor))) {
+          break;
+        }
+        nextCursor += 1;
+      }
+      fragments.push({
+        type: "text",
+        text: text.slice(cursor, nextCursor),
+      });
+      cursor = nextCursor;
+      continue;
+    }
+
+    fragments.push({
+      type: "token",
+      token: matchedToken,
+    });
+    cursor += matchedToken.rawText.length;
+  }
+
+  return fragments;
+}

package/src/components/chat/chat-input/chat-input-bar.controller.test.tsx

@@ -125,4 +125,28 @@ describe('useChatInputBarController', () => {
     });
     expect(onSend).toHaveBeenCalledTimes(1);
   });
+
+  it('does not send on enter while a response is still running', () => {
+    const onSend = vi.fn();
+    const event = createKeyEvent('Enter');
+    const { result } = renderHook(() =>
+      useChatInputBarController({
+        isSlashMode: false,
+        slashItems: [],
+        isSlashLoading: false,
+        onSelectSlashItem: vi.fn(),
+        onSend,
+        onStop: vi.fn(),
+        isSending: true,
+        canStopGeneration: true
+      })
+    );
+
+    act(() => {
+      result.current.onTextareaKeyDown(event);
+    });
+
+    expect(onSend).not.toHaveBeenCalled();
+    expect(event.preventDefault).toHaveBeenCalledTimes(1);
+  });
 });

package/src/components/chat/chat-input/chat-input-bar.controller.ts

@@ -13,15 +13,32 @@ type UseChatInputBarControllerParams = {
   canStopGeneration: boolean;
 };
 
+function isSubmitKey(event: Pick<KeyboardEvent<HTMLTextAreaElement>, 'key' | 'shiftKey'>): boolean {
+  return event.key === 'Enter' && !event.shiftKey;
+}
+
+function isSlashDismissKey(event: Pick<KeyboardEvent<HTMLTextAreaElement>, 'key' | 'code' | 'nativeEvent'>): boolean {
+  return !event.nativeEvent.isComposing && (event.key === ' ' || event.code === 'Space');
+}
+
 export function useChatInputBarController(params: UseChatInputBarControllerParams) {
+  const {
+    isSlashMode,
+    slashItems,
+    onSelectSlashItem,
+    onSend,
+    onStop,
+    isSending,
+    canStopGeneration
+  } = params;
   const [activeSlashIndex, setActiveSlashIndex] = useState(0);
   const [dismissedSlashPanel, setDismissedSlashPanel] = useState(false);
 
-  const isSlashPanelOpen = params.isSlashMode && !dismissedSlashPanel;
-  const activeSlashItem = params.slashItems[activeSlashIndex] ?? null;
+  const isSlashPanelOpen = isSlashMode && !dismissedSlashPanel;
+  const activeSlashItem = slashItems[activeSlashIndex] ?? null;
 
   useEffect(() => {
-    if (!isSlashPanelOpen || params.slashItems.length === 0) {
+    if (!isSlashPanelOpen || slashItems.length === 0) {
       setActiveSlashIndex(0);
       return;
     }
@@ -29,65 +46,85 @@ export function useChatInputBarController(params: UseChatInputBarControllerParam
       if (current < 0) {
         return 0;
       }
-      if (current >= params.slashItems.length) {
-        return params.slashItems.length - 1;
+      if (current >= slashItems.length) {
+        return slashItems.length - 1;
       }
       return current;
     });
-  }, [isSlashPanelOpen, params.slashItems.length]);
+  }, [isSlashPanelOpen, slashItems.length]);
 
   useEffect(() => {
-    if (!params.isSlashMode && dismissedSlashPanel) {
+    if (!isSlashMode && dismissedSlashPanel) {
       setDismissedSlashPanel(false);
     }
-  }, [dismissedSlashPanel, params.isSlashMode]);
+  }, [dismissedSlashPanel, isSlashMode]);
 
   const handleSelectSlashItem = useCallback((item: ChatSlashItem) => {
-    params.onSelectSlashItem(item);
+    onSelectSlashItem(item);
     setDismissedSlashPanel(false);
-  }, [params]);
+  }, [onSelectSlashItem]);
+
+  const handleSlashKeyDown = useCallback((event: KeyboardEvent<HTMLTextAreaElement>): boolean => {
+    if (!isSlashPanelOpen || slashItems.length === 0) {
+      return false;
+    }
+    if (event.key === 'ArrowDown') {
+      event.preventDefault();
+      setActiveSlashIndex((current) => (current + 1) % slashItems.length);
+      return true;
+    }
+    if (event.key === 'ArrowUp') {
+      event.preventDefault();
+      setActiveSlashIndex((current) => (current - 1 + slashItems.length) % slashItems.length);
+      return true;
+    }
+    if (!isSubmitKey(event) && event.key !== 'Tab') {
+      return false;
+    }
+    event.preventDefault();
+    const selected = slashItems[activeSlashIndex];
+    if (selected) {
+      handleSelectSlashItem(selected);
+    }
+    return true;
+  }, [activeSlashIndex, handleSelectSlashItem, isSlashPanelOpen, slashItems]);
+
+  const handleEscapeKeyDown = useCallback((event: KeyboardEvent<HTMLTextAreaElement>): boolean => {
+    if (event.key !== 'Escape') {
+      return false;
+    }
+    if (isSlashPanelOpen) {
+      event.preventDefault();
+      setDismissedSlashPanel(true);
+      return true;
+    }
+    if (!isSending || !canStopGeneration) {
+      return false;
+    }
+    event.preventDefault();
+    void onStop();
+    return true;
+  }, [canStopGeneration, isSlashPanelOpen, isSending, onStop]);
 
   const onTextareaKeyDown = useCallback((event: KeyboardEvent<HTMLTextAreaElement>) => {
-    if (isSlashPanelOpen && !event.nativeEvent.isComposing && (event.key === ' ' || event.code === 'Space')) {
+    if (isSubmitKey(event) && isSending) {
+      event.preventDefault();
+      return;
+    }
+    if (isSlashPanelOpen && isSlashDismissKey(event)) {
       setDismissedSlashPanel(true);
     }
-    if (isSlashPanelOpen && params.slashItems.length > 0) {
-      if (event.key === 'ArrowDown') {
-        event.preventDefault();
-        setActiveSlashIndex((current) => (current + 1) % params.slashItems.length);
-        return;
-      }
-      if (event.key === 'ArrowUp') {
-        event.preventDefault();
-        setActiveSlashIndex((current) => (current - 1 + params.slashItems.length) % params.slashItems.length);
-        return;
-      }
-      if ((event.key === 'Enter' && !event.shiftKey) || event.key === 'Tab') {
-        event.preventDefault();
-        const selected = params.slashItems[activeSlashIndex];
-        if (selected) {
-          handleSelectSlashItem(selected);
-        }
-        return;
-      }
+    if (handleSlashKeyDown(event)) {
+      return;
     }
-    if (event.key === 'Escape') {
-      if (isSlashPanelOpen) {
-        event.preventDefault();
-        setDismissedSlashPanel(true);
-        return;
-      }
-      if (params.isSending && params.canStopGeneration) {
-        event.preventDefault();
-        void params.onStop();
-        return;
-      }
+    if (handleEscapeKeyDown(event)) {
+      return;
     }
-    if (event.key === 'Enter' && !event.shiftKey) {
+    if (isSubmitKey(event)) {
       event.preventDefault();
-      void params.onSend();
+      void onSend();
     }
-  }, [activeSlashIndex, handleSelectSlashItem, isSlashPanelOpen, params]);
+  }, [handleEscapeKeyDown, handleSlashKeyDown, isSending, isSlashPanelOpen, onSend]);
 
   return {
     isSlashPanelOpen,

package/src/components/chat/chat-recent-skills.manager.ts

@@ -0,0 +1,8 @@
+import { RecentSelectionManager } from '@/lib/recent-selection.manager';
+
+export const chatRecentSkillsManager = new RecentSelectionManager({
+  storageKey: 'nextclaw.chat.recent-skills',
+  limit: 5
+});
+
+export const CHAT_RECENT_SKILLS_MIN_OPTIONS = 4;

package/src/components/chat/containers/chat-input-bar.container.tsx

@@ -20,6 +20,10 @@ import {
   CHAT_RECENT_MODELS_MIN_OPTIONS,
   chatRecentModelsManager
 } from '@/components/chat/chat-recent-models.manager';
+import {
+  CHAT_RECENT_SKILLS_MIN_OPTIONS,
+  chatRecentSkillsManager
+} from '@/components/chat/chat-recent-skills.manager';
 import { useI18n } from '@/components/providers/I18nProvider';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
 import { t } from '@/lib/i18n';
@@ -112,6 +116,14 @@ export function ChatInputBarContainer() {
     availableValues: modelRecords.map((option) => option.value),
     minAvailableCount: CHAT_RECENT_MODELS_MIN_OPTIONS
   });
+  const recentSkillValues = chatRecentSkillsManager.resolveVisible({
+    availableValues: skillRecords.map((record) => record.key),
+    minAvailableCount: 0
+  });
+  const recentSkillGroupValues = chatRecentSkillsManager.resolveVisible({
+    availableValues: skillRecords.map((record) => record.key),
+    minAvailableCount: CHAT_RECENT_SKILLS_MIN_OPTIONS
+  });
 
   const hasModelOptions = modelRecords.length > 0;
   const isModelOptionsLoading = !snapshot.isProviderStateResolved && !hasModelOptions;
@@ -126,10 +138,12 @@ export function ChatInputBarContainer() {
       : t('chatModelNoOptions');
   const recentModelsLabel = language === 'zh' ? '最近选择' : 'Recent';
   const allModelsLabel = language === 'zh' ? '全部模型' : 'All models';
+  const recentSkillsLabel = language === 'zh' ? '最近使用' : 'Recent';
+  const allSkillsLabel = language === 'zh' ? '全部技能' : 'All skills';
 
   const slashItems = useMemo(
-    () => buildChatSlashItems(skillRecords, slashQuery ?? '', slashTexts),
-    [slashQuery, skillRecords, slashTexts]
+    () => buildChatSlashItems(skillRecords, slashQuery ?? '', slashTexts, recentSkillValues),
+    [slashQuery, skillRecords, slashTexts, recentSkillValues]
   );
 
   const selectedModelOption = modelRecords.find((option) => option.value === snapshot.selectedModel);
@@ -206,6 +220,8 @@ export function ChatInputBarContainer() {
 
   const skillPicker = buildSkillPickerModel({
     skillRecords,
+    recentSkillValues,
+    groupedRecentSkillValues: recentSkillGroupValues,
     selectedSkills: snapshot.selectedSkills,
     isLoading: snapshot.isSkillsLoading,
     onSelectedKeysChange: presenter.chatInputManager.selectSkills,
@@ -214,7 +230,9 @@ export function ChatInputBarContainer() {
       searchPlaceholder: t('chatSkillsPickerSearchPlaceholder'),
       emptyLabel: t('chatSkillsPickerEmpty'),
       loadingLabel: t('sessionsLoading'),
-      manageLabel: t('chatSkillsPickerManage')
+      manageLabel: t('chatSkillsPickerManage'),
+      recentSkillsLabel,
+      allSkillsLabel
     }
   });
 
@@ -233,6 +251,11 @@ export function ChatInputBarContainer() {
         slashMenu={{
           isLoading: snapshot.isSkillsLoading,
           items: slashItems,
+          onSelectItem: (item) => {
+            if (item.value) {
+              presenter.chatInputManager.rememberSkillSelection(item.value);
+            }
+          },
           texts: {
             slashLoadingLabel: t('chatSlashLoading'),
             slashSectionLabel: t('chatSlashSectionSkills'),
@@ -274,7 +297,11 @@ export function ChatInputBarContainer() {
             isSending: snapshot.isSending,
             canStopGeneration: snapshot.canStopGeneration,
             sendDisabled:
-              (snapshot.draft.trim().length === 0 && snapshot.attachments.length === 0) ||
+              (
+                snapshot.draft.trim().length === 0 &&
+                snapshot.attachments.length === 0 &&
+                snapshot.selectedSkills.length === 0
+              ) ||
               !hasModelOptions ||
               snapshot.sessionTypeUnavailable,
             stopDisabled: !snapshot.canStopGeneration,

package/src/components/chat/containers/chat-message-list.container.test.tsx

@@ -99,3 +99,48 @@ it("keeps historical adapted message references stable when only the streaming m
   expect(secondMessages[0]).toBe(firstMessages[0]);
   expect(secondMessages[1]).not.toBe(firstMessages[1]);
 });
+
+it("adapts persisted inline token metadata into rich message parts", () => {
+  const message = {
+    id: "user-inline-token",
+    sessionId: "session-1",
+    role: "user",
+    status: "final",
+    timestamp: "2026-03-31T10:00:00.000Z",
+    metadata: {
+      ui_inline_tokens: [
+        {
+          kind: "skill",
+          key: "weather",
+          label: "Weather",
+          rawText: "$weather",
+        },
+      ],
+    },
+    parts: [{ type: "text", text: "please use $weather now" }],
+  } satisfies NcpMessage;
+
+  render(<ChatMessageListContainer messages={[message]} isSending={false} />);
+
+  const renderedMessages =
+    captures.renders[captures.renders.length - 1]?.messages ?? [];
+  expect(renderedMessages[0]).toMatchObject({
+    parts: [
+      {
+        type: "inline-content",
+        segments: [
+          { type: "markdown", text: "please use " },
+          {
+            type: "token",
+            token: {
+              kind: "skill",
+              key: "weather",
+              label: "Weather",
+            },
+          },
+          { type: "markdown", text: " now" },
+        ],
+      },
+    ],
+  });
+});

package/src/components/chat/containers/chat-message-list.container.tsx

@@ -9,6 +9,7 @@ import {
   type ChatMessageAdapterTexts,
   type ChatMessageSource,
 } from "@/components/chat/adapters/chat-message.adapter";
+import { readInlineTokensFromMetadata } from "@/components/chat/chat-inline-token.utils";
 import { adaptNcpMessageToUiMessage } from "@/components/chat/ncp/ncp-session-adapter";
 import { useI18n } from "@/components/providers/I18nProvider";
 import { formatDateTime, t } from "@/lib/i18n";
@@ -63,7 +64,11 @@ function buildChatMessageTexts(language: string) {
   };
 }
 
-export function ChatMessageListContainer(props: ChatMessageListContainerProps) {
+export function ChatMessageListContainer({
+  messages: rawMessages,
+  isSending,
+  className,
+}: ChatMessageListContainerProps) {
   const { language } = useI18n();
   const texts = useMemo<ChatMessageAdapterTexts>(
     () => buildChatMessageAdapterTexts(language),
@@ -71,7 +76,7 @@ export function ChatMessageListContainer(props: ChatMessageListContainerProps) {
   );
 
   const messages = useMemo(() => {
-    return props.messages.map((message) => {
+    return rawMessages.map((message) => {
       const cached = messageViewModelCache.get(message);
       if (cached && cached.language === language) {
         return cached.viewModel;
@@ -84,6 +89,7 @@ export function ChatMessageListContainer(props: ChatMessageListContainerProps) {
         meta: {
           timestamp: uiMessage.meta?.timestamp,
           status: uiMessage.meta?.status,
+          inlineTokens: readInlineTokensFromMetadata(message.metadata),
         },
         parts: uiMessage.parts as unknown as ChatMessageSource["parts"],
       };
@@ -95,7 +101,7 @@ export function ChatMessageListContainer(props: ChatMessageListContainerProps) {
       messageViewModelCache.set(message, { language, viewModel });
       return viewModel;
     });
-  }, [language, props.messages, texts]);
+  }, [language, rawMessages, texts]);
 
   const hasAssistantDraft = useMemo(
     () =>
@@ -114,9 +120,9 @@ export function ChatMessageListContainer(props: ChatMessageListContainerProps) {
   return (
     <ChatMessageList
       messages={messages}
-      isSending={props.isSending}
+      isSending={isSending}
       hasAssistantDraft={hasAssistantDraft}
-      className={props.className}
+      className={className}
       texts={messageTexts}
     />
   );

package/src/components/chat/ncp/NcpChatPage.tsx

@@ -10,6 +10,7 @@ import { API_BASE } from '@/api/api-base';
 import { fetchNcpSessionMessages } from '@/api/ncp-session';
 import { ChatPageLayout, type ChatPageProps, useChatSessionSync } from '@/components/chat/chat-page-shell';
 import { sessionDisplayName } from '@/components/chat/chat-session-display';
+import { buildInlineSkillTokensFromComposer, CHAT_UI_INLINE_TOKENS_METADATA_KEY } from '@/components/chat/chat-inline-token.utils';
 import { createNcpAppClientFetch } from '@/components/chat/ncp/ncp-app-client-fetch';
 import { parseSessionKeyFromRoute, resolveAgentIdFromSessionKey } from '@/components/chat/chat-session-route';
 import { useNcpChatPageData } from '@/components/chat/ncp/ncp-chat-page-data';
@@ -29,6 +30,7 @@ function buildNcpSendMetadata(payload: {
   thinkingLevel?: string;
   sessionType?: string;
   requestedSkills?: string[];
+  composerNodes?: Parameters<typeof buildInlineSkillTokensFromComposer>[0];
 }): Record<string, unknown> {
   const metadata: Record<string, unknown> = {};
   if (payload.model?.trim()) {
@@ -46,6 +48,12 @@ function buildNcpSendMetadata(payload: {
   if (requestedSkills.length > 0) {
     metadata.requested_skills = requestedSkills;
   }
+  const inlineSkillTokens = payload.composerNodes
+    ? buildInlineSkillTokensFromComposer(payload.composerNodes)
+    : [];
+  if (inlineSkillTokens.length > 0) {
+    metadata[CHAT_UI_INLINE_TOKENS_METADATA_KEY] = inlineSkillTokens;
+  }
   return metadata;
 }
 
@@ -195,7 +203,8 @@ export function NcpChatPage({ view }: ChatPageProps) {
           model: payload.model,
           thinkingLevel: payload.thinkingLevel,
           sessionType: payload.sessionType,
-          requestedSkills: payload.requestedSkills
+          requestedSkills: payload.requestedSkills,
+          composerNodes: payload.composerNodes
         });
         const envelope = buildNcpRequestEnvelope({
           sessionId: payload.sessionKey,

package/src/components/chat/ncp/ncp-chat-input.manager.ts

@@ -20,6 +20,7 @@ import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-s
 import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
 import { ChatSessionPreferenceSync } from '@/components/chat/chat-session-preference-sync';
 import { chatRecentModelsManager } from '@/components/chat/chat-recent-models.manager';
+import { chatRecentSkillsManager } from '@/components/chat/chat-recent-skills.manager';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 import { normalizeSessionType } from '@/components/chat/useChatSessionTypeState';
 
@@ -252,11 +253,24 @@ export class NcpChatInputManager {
     this.sessionPreferenceSync.syncSelectedSessionPreferences();
   };
 
+  rememberSkillSelection = (value: string) => {
+    chatRecentSkillsManager.remember(value);
+  };
+
   selectSkills = (next: string[]) => {
+    const prev = useChatInputStore.getState().snapshot.selectedSkills;
+    for (const value of next) {
+      if (!prev.includes(value)) {
+        this.rememberSkillSelection(value);
+      }
+    }
     this.setSelectedSkills(next);
   };
 
-  private resolveThinkingForModel(modelOption: ChatModelOption | undefined, current: ThinkingLevel | null): ThinkingLevel | null {
+  private resolveThinkingForModel = (
+    modelOption: ChatModelOption | undefined,
+    current: ThinkingLevel | null
+  ): ThinkingLevel | null => {
     const capability = modelOption?.thinkingCapability;
     if (!capability || capability.supported.length === 0) {
       return null;
@@ -271,9 +285,9 @@ export class NcpChatInputManager {
       return capability.default;
     }
     return 'off';
-  }
+  };
 
-  private reconcileThinkingForModel(model: string): void {
+  private reconcileThinkingForModel = (model: string): void => {
     const snapshot = useChatInputStore.getState().snapshot;
     const modelOption = snapshot.modelOptions.find((option) => option.value === model);
     const { selectedThinkingLevel } = snapshot;
@@ -281,5 +295,5 @@ export class NcpChatInputManager {
     if (nextThinking !== selectedThinkingLevel) {
       useChatInputStore.getState().setSnapshot({ selectedThinkingLevel: nextThinking });
     }
-  }
+  };
 }

package/src/components/chat/presenter/chat-presenter-context.tsx

@@ -29,6 +29,7 @@ export type ChatInputManagerLike = {
   selectModel: (value: string) => void;
   selectThinkingLevel: (value: ThinkingLevel) => void;
   selectSkills: (next: string[]) => void;
+  rememberSkillSelection: (value: string) => void;
 };
 
 export type ChatThreadManagerLike = {