@nextclaw/ui 0.6.15 → 0.8.0

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

@@ -0,0 +1,173 @@
+import type { SetStateAction } from 'react';
+import type { ThinkingLevel } from '@/api/types';
+import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import type { ChatInputSnapshot } from '@/components/chat/stores/chat-input.store';
+import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import type { ChatModelOption } from '@/components/chat/chat-input.types';
+import { normalizeSessionType } from '@/components/chat/useChatSessionTypeState';
+
+export class NcpChatInputManager {
+  constructor(
+    private uiManager: ChatUiManager,
+    private streamActionsManager: ChatStreamActionsManager,
+    private getDraftSessionId: () => string
+  ) {}
+
+  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
+    const current = useChatInputStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
+    if (typeof next === 'function') {
+      return (next as (value: T) => T)(prev);
+    }
+    return next;
+  };
+
+  syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
+    if (!this.hasSnapshotChanges(patch)) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot(patch);
+    if (
+      Object.prototype.hasOwnProperty.call(patch, 'modelOptions') ||
+      Object.prototype.hasOwnProperty.call(patch, 'selectedModel') ||
+      Object.prototype.hasOwnProperty.call(patch, 'selectedThinkingLevel')
+    ) {
+      const snapshot = useChatInputStore.getState().snapshot;
+      this.reconcileThinkingForModel(snapshot.selectedModel);
+    }
+  };
+
+  setDraft = (next: SetStateAction<string>) => {
+    const prev = useChatInputStore.getState().snapshot.draft;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ draft: value });
+  };
+
+  setPendingSessionType = (next: SetStateAction<string>) => {
+    const prev = useChatInputStore.getState().snapshot.pendingSessionType;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ pendingSessionType: value });
+  };
+
+  send = async () => {
+    const inputSnapshot = useChatInputStore.getState().snapshot;
+    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
+    const message = inputSnapshot.draft.trim();
+    if (!message) {
+      return;
+    }
+    const requestedSkills = inputSnapshot.selectedSkills;
+    const sessionKey = sessionSnapshot.selectedSessionKey ?? this.getDraftSessionId();
+    if (!sessionSnapshot.selectedSessionKey) {
+      this.uiManager.goToSession(sessionKey, { replace: true });
+    }
+    this.setDraft('');
+    this.setSelectedSkills([]);
+    await this.streamActionsManager.sendMessage({
+      message,
+      sessionKey,
+      agentId: sessionSnapshot.selectedAgentId,
+      sessionType: inputSnapshot.selectedSessionType,
+      model: inputSnapshot.selectedModel || undefined,
+      thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
+      stopSupported: true,
+      requestedSkills,
+      restoreDraftOnError: true
+    });
+  };
+
+  stop = async () => {
+    await this.streamActionsManager.stopCurrentRun();
+  };
+
+  goToProviders = () => {
+    this.uiManager.goToProviders();
+  };
+
+  setSelectedModel = (next: SetStateAction<string>) => {
+    const prev = useChatInputStore.getState().snapshot.selectedModel;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ selectedModel: value });
+    this.reconcileThinkingForModel(value);
+  };
+
+  setSelectedThinkingLevel = (next: SetStateAction<ThinkingLevel | null>) => {
+    const prev = useChatInputStore.getState().snapshot.selectedThinkingLevel;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ selectedThinkingLevel: value });
+  };
+
+  selectSessionType = (value: string) => {
+    const normalized = normalizeSessionType(value);
+    useChatInputStore.getState().setSnapshot({ selectedSessionType: normalized, pendingSessionType: normalized });
+  };
+
+  setSelectedSkills = (next: SetStateAction<string[]>) => {
+    const prev = useChatInputStore.getState().snapshot.selectedSkills;
+    const value = this.resolveUpdateValue(prev, next);
+    if (Object.is(value, prev)) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ selectedSkills: value });
+  };
+
+  selectModel = (value: string) => {
+    this.setSelectedModel(value);
+  };
+
+  selectThinkingLevel = (value: ThinkingLevel) => {
+    this.setSelectedThinkingLevel(value);
+  };
+
+  selectSkills = (next: string[]) => {
+    this.setSelectedSkills(next);
+  };
+
+  private resolveThinkingForModel(modelOption: ChatModelOption | undefined, current: ThinkingLevel | null): ThinkingLevel | null {
+    const capability = modelOption?.thinkingCapability;
+    if (!capability || capability.supported.length === 0) {
+      return null;
+    }
+    if (current === 'off') {
+      return 'off';
+    }
+    if (current && capability.supported.includes(current)) {
+      return current;
+    }
+    if (capability.default && capability.supported.includes(capability.default)) {
+      return capability.default;
+    }
+    return 'off';
+  }
+
+  private reconcileThinkingForModel(model: string): void {
+    const snapshot = useChatInputStore.getState().snapshot;
+    const modelOption = snapshot.modelOptions.find((option) => option.value === model);
+    const nextThinking = this.resolveThinkingForModel(modelOption, snapshot.selectedThinkingLevel);
+    if (nextThinking !== snapshot.selectedThinkingLevel) {
+      useChatInputStore.getState().setSnapshot({ selectedThinkingLevel: nextThinking });
+    }
+  }
+}

package/src/components/chat/ncp/ncp-chat-page-data.ts

@@ -0,0 +1,134 @@
+import { useMemo } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import type { SessionEntryView } from '@/api/types';
+import type { ChatModelOption } from '@/components/chat/chat-input.types';
+import {
+  adaptNcpSessionSummaries,
+  readNcpSessionPreferredThinking
+} from '@/components/chat/ncp/ncp-session-adapter';
+import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
+import { useSyncSelectedModel } from '@/components/chat/chat-page-runtime';
+import {
+  useConfig,
+  useConfigMeta,
+  useNcpSessions
+} from '@/hooks/useConfig';
+import { useMarketplaceInstalled } from '@/hooks/useMarketplace';
+import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/lib/provider-models';
+
+type UseNcpChatPageDataParams = {
+  query: string;
+  selectedSessionKey: string | null;
+  pendingSessionType: string;
+  setPendingSessionType: Dispatch<SetStateAction<string>>;
+  setSelectedModel: Dispatch<SetStateAction<string>>;
+};
+
+function filterSessionsByQuery(sessions: SessionEntryView[], query: string): SessionEntryView[] {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) {
+    return sessions;
+  }
+  return sessions.filter((session) => session.key.toLowerCase().includes(normalizedQuery));
+}
+
+export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
+  const configQuery = useConfig();
+  const configMetaQuery = useConfigMeta();
+  const sessionsQuery = useNcpSessions({ limit: 200 });
+  const installedSkillsQuery = useMarketplaceInstalled('skill');
+  const isProviderStateResolved =
+    (configQuery.isFetched || configQuery.isSuccess) &&
+    (configMetaQuery.isFetched || configMetaQuery.isSuccess);
+
+  const modelOptions = useMemo<ChatModelOption[]>(() => {
+    const providers = buildProviderModelCatalog({
+      meta: configMetaQuery.data,
+      config: configQuery.data,
+      onlyConfigured: true
+    });
+    const seen = new Set<string>();
+    const options: ChatModelOption[] = [];
+    for (const provider of providers) {
+      for (const localModel of provider.models) {
+        const value = composeProviderModel(provider.prefix, localModel);
+        if (!value || seen.has(value)) {
+          continue;
+        }
+        seen.add(value);
+        options.push({
+          value,
+          modelLabel: localModel,
+          providerLabel: provider.displayName,
+          thinkingCapability: resolveModelThinkingCapability(provider.modelThinking, localModel, provider.aliases)
+        });
+      }
+    }
+    return options.sort((left, right) => {
+      const providerCompare = left.providerLabel.localeCompare(right.providerLabel);
+      if (providerCompare !== 0) {
+        return providerCompare;
+      }
+      return left.modelLabel.localeCompare(right.modelLabel);
+    });
+  }, [configMetaQuery.data, configQuery.data]);
+
+  const sessionSummaries = useMemo(
+    () => sessionsQuery.data?.sessions ?? [],
+    [sessionsQuery.data?.sessions]
+  );
+  const allSessions = useMemo(
+    () => adaptNcpSessionSummaries(sessionSummaries),
+    [sessionSummaries]
+  );
+  const sessions = useMemo(
+    () => filterSessionsByQuery(allSessions, params.query),
+    [allSessions, params.query]
+  );
+  const selectedSession = useMemo(
+    () => allSessions.find((session) => session.key === params.selectedSessionKey) ?? null,
+    [allSessions, params.selectedSessionKey]
+  );
+  const selectedSessionSummary = useMemo(
+    () => sessionSummaries.find((session) => session.sessionId === params.selectedSessionKey) ?? null,
+    [params.selectedSessionKey, sessionSummaries]
+  );
+  const skillRecords = useMemo(
+    () => installedSkillsQuery.data?.records ?? [],
+    [installedSkillsQuery.data?.records]
+  );
+  const selectedSessionThinkingLevel = useMemo(
+    () => (selectedSessionSummary ? readNcpSessionPreferredThinking(selectedSessionSummary) : null),
+    [selectedSessionSummary]
+  );
+
+  const sessionTypeState = useChatSessionTypeState({
+    selectedSession,
+    selectedSessionKey: params.selectedSessionKey,
+    pendingSessionType: params.pendingSessionType,
+    setPendingSessionType: params.setPendingSessionType,
+    sessionTypesData: null
+  });
+
+  useSyncSelectedModel({
+    modelOptions,
+    selectedSessionPreferredModel: selectedSession?.preferredModel,
+    defaultModel: configQuery.data?.agents.defaults.model,
+    setSelectedModel: params.setSelectedModel
+  });
+
+  return {
+    configQuery,
+    configMetaQuery,
+    sessionsQuery,
+    installedSkillsQuery,
+    isProviderStateResolved,
+    modelOptions,
+    sessionSummaries,
+    sessions,
+    skillRecords,
+    selectedSession,
+    selectedSessionThinkingLevel,
+    ...sessionTypeState
+  };
+}

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

@@ -0,0 +1,89 @@
+import { deleteNcpSession as deleteNcpSessionApi } from '@/api/config';
+import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
+import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import type { ChatThreadSnapshot } from '@/components/chat/stores/chat-thread.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
+import { t } from '@/lib/i18n';
+
+export type NcpChatThreadManagerActions = {
+  refetchSessions: () => Promise<unknown>;
+};
+
+const noopAsync = async () => {};
+
+export class NcpChatThreadManager {
+  private actions: NcpChatThreadManagerActions = {
+    refetchSessions: noopAsync
+  };
+
+  constructor(
+    private uiManager: ChatUiManager,
+    private sessionListManager: ChatSessionListManager,
+    private streamActionsManager: ChatStreamActionsManager
+  ) {}
+
+  bindActions = (patch: Partial<NcpChatThreadManagerActions>) => {
+    this.actions = {
+      ...this.actions,
+      ...patch
+    };
+  };
+
+  private hasSnapshotChanges = (patch: Partial<ChatThreadSnapshot>): boolean => {
+    const current = useChatThreadStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatThreadSnapshot, ChatThreadSnapshot[keyof ChatThreadSnapshot]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  syncSnapshot = (patch: Partial<ChatThreadSnapshot>) => {
+    if (!this.hasSnapshotChanges(patch)) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot(patch);
+  };
+
+  deleteSession = () => {
+    void this.deleteCurrentSession();
+  };
+
+  createSession = () => {
+    this.sessionListManager.createSession();
+  };
+
+  goToProviders = () => {
+    this.uiManager.goToProviders();
+  };
+
+  private deleteCurrentSession = async () => {
+    const {
+      snapshot: { selectedSessionKey }
+    } = useChatSessionListStore.getState();
+    if (!selectedSessionKey) {
+      return;
+    }
+    const confirmed = await this.uiManager.confirm({
+      title: t('chatDeleteSessionConfirm'),
+      variant: 'destructive',
+      confirmLabel: t('delete')
+    });
+    if (!confirmed) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({ isDeletePending: true });
+    try {
+      await deleteNcpSessionApi(selectedSessionKey);
+      this.streamActionsManager.resetStreamState();
+      useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: null });
+      this.uiManager.goToChatRoot({ replace: true });
+      await this.actions.refetchSessions();
+    } finally {
+      useChatThreadStore.getState().setSnapshot({ isDeletePending: false });
+    }
+  };
+}

package/src/components/chat/ncp/ncp-chat.presenter.ts

@@ -0,0 +1,33 @@
+import { ChatRunStatusManager } from '@/components/chat/managers/chat-run-status.manager';
+import { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
+import { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+import { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import { NcpChatInputManager } from '@/components/chat/ncp/ncp-chat-input.manager';
+import { NcpChatThreadManager } from '@/components/chat/ncp/ncp-chat-thread.manager';
+
+export class NcpChatPresenter {
+  chatUiManager = new ChatUiManager();
+  chatStreamActionsManager = new ChatStreamActionsManager();
+  chatSessionListManager = new ChatSessionListManager(this.chatUiManager, this.chatStreamActionsManager);
+  chatInputManager = new NcpChatInputManager(
+    this.chatUiManager,
+    this.chatStreamActionsManager,
+    () => this.getDraftSessionId()
+  );
+  chatRunStatusManager = new ChatRunStatusManager();
+  chatThreadManager = new NcpChatThreadManager(
+    this.chatUiManager,
+    this.chatSessionListManager,
+    this.chatStreamActionsManager
+  );
+
+  private draftSessionId = '';
+
+  setDraftSessionId = (sessionId: string) => {
+    this.draftSessionId = sessionId;
+  };
+
+  private getDraftSessionId(): string {
+    return this.draftSessionId;
+  }
+}

package/src/components/chat/ncp/ncp-session-adapter.test.ts

@@ -0,0 +1,49 @@
+import { adaptNcpSessionSummary, readNcpSessionPreferredThinking } from '@/components/chat/ncp/ncp-session-adapter';
+import type { NcpSessionSummaryView } from '@/api/types';
+
+function createSummary(partial: Partial<NcpSessionSummaryView> = {}): NcpSessionSummaryView {
+  return {
+    sessionId: 'ncp-session-1',
+    messageCount: 3,
+    updatedAt: '2026-03-18T00:00:00.000Z',
+    status: 'idle',
+    ...partial
+  };
+}
+
+describe('adaptNcpSessionSummary', () => {
+  it('maps session metadata into shared session entry fields', () => {
+    const adapted = adaptNcpSessionSummary(
+      createSummary({
+        metadata: {
+          label: 'NCP Planning Thread',
+          model: 'openai/gpt-5',
+          session_type: 'native'
+        }
+      })
+    );
+
+    expect(adapted).toMatchObject({
+      key: 'ncp-session-1',
+      label: 'NCP Planning Thread',
+      preferredModel: 'openai/gpt-5',
+      sessionType: 'native',
+      sessionTypeMutable: false,
+      messageCount: 3
+    });
+  });
+});
+
+describe('readNcpSessionPreferredThinking', () => {
+  it('normalizes persisted thinking metadata for UI hydration', () => {
+    const thinking = readNcpSessionPreferredThinking(
+      createSummary({
+        metadata: {
+          preferred_thinking: 'HIGH'
+        }
+      })
+    );
+
+    expect(thinking).toBe('high');
+  });
+});

package/src/components/chat/ncp/ncp-session-adapter.ts

@@ -0,0 +1,194 @@
+import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
+import type { NcpMessagePart } from '@nextclaw/ncp';
+import type { NcpMessageView, NcpSessionSummaryView, SessionEntryView, ThinkingLevel } from '@/api/types';
+
+const THINKING_LEVEL_SET = new Set<string>(['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh']);
+
+function stringifyUnknown(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+  try {
+    return JSON.stringify(value ?? {});
+  } catch {
+    return String(value ?? '');
+  }
+}
+
+function readOptionalString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function readMetadata(summary: NcpSessionSummaryView): Record<string, unknown> | null {
+  const { metadata } = summary;
+  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+    return null;
+  }
+  return metadata as Record<string, unknown>;
+}
+
+export function readNcpSessionPreferredModel(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return (
+    readOptionalString(metadata.preferred_model) ??
+    readOptionalString(metadata.preferredModel) ??
+    readOptionalString(metadata.model)
+  );
+}
+
+export function readNcpSessionPreferredThinking(summary: NcpSessionSummaryView): ThinkingLevel | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  const rawValue =
+    readOptionalString(metadata.preferred_thinking) ??
+    readOptionalString(metadata.thinking) ??
+    readOptionalString(metadata.thinking_level) ??
+    readOptionalString(metadata.thinkingLevel);
+  if (!rawValue) {
+    return null;
+  }
+  const normalized = rawValue.toLowerCase();
+  return THINKING_LEVEL_SET.has(normalized) ? (normalized as ThinkingLevel) : null;
+}
+
+function readNcpSessionLabel(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.label);
+}
+
+function readNcpSessionType(summary: NcpSessionSummaryView): string {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return 'native';
+  }
+  return readOptionalString(metadata.session_type) ?? readOptionalString(metadata.sessionType) ?? 'native';
+}
+
+function mapToolStatus(part: Extract<NcpMessagePart, { type: 'tool-invocation' }>): ToolInvocationStatus {
+  if (part.state === 'result') {
+    return ToolInvocationStatus.RESULT;
+  }
+  if (part.state === 'partial-call') {
+    return ToolInvocationStatus.PARTIAL_CALL;
+  }
+  return ToolInvocationStatus.CALL;
+}
+
+function toUiParts(parts: NcpMessagePart[]): UIMessage['parts'] {
+  const uiParts: UIMessage['parts'] = [];
+  for (const part of parts) {
+    if (part.type === 'text') {
+      uiParts.push({ type: 'text', text: part.text });
+      continue;
+    }
+    if (part.type === 'rich-text') {
+      uiParts.push({ type: 'text', text: part.text });
+      continue;
+    }
+    if (part.type === 'reasoning') {
+      uiParts.push({
+        type: 'reasoning',
+        reasoning: part.text,
+        details: []
+      });
+      continue;
+    }
+    if (part.type === 'source') {
+      uiParts.push({
+        type: 'source',
+        source: {
+          sourceType: 'url',
+          id: part.url ?? part.title ?? Math.random().toString(36).slice(2, 8),
+          url: part.url ?? '',
+          ...(part.title ? { title: part.title } : {})
+        }
+      });
+      continue;
+    }
+    if (part.type === 'file' && part.contentBase64) {
+      uiParts.push({
+        type: 'file',
+        mimeType: part.mimeType ?? 'application/octet-stream',
+        data: part.contentBase64
+      });
+      continue;
+    }
+    if (part.type === 'step-start') {
+      uiParts.push({ type: 'step-start' });
+      continue;
+    }
+    if (part.type === 'tool-invocation') {
+      uiParts.push({
+        type: 'tool-invocation',
+        toolInvocation: {
+          status: mapToolStatus(part),
+          toolCallId: part.toolCallId ?? `${part.toolName}-${Math.random().toString(36).slice(2, 8)}`,
+          toolName: part.toolName,
+          args: stringifyUnknown(part.args),
+          result: part.result
+        }
+      });
+    }
+  }
+  return uiParts;
+}
+
+function normalizeRole(role: NcpMessageView['role']): UIMessage['role'] {
+  if (role === 'service') {
+    return 'system';
+  }
+  return role === 'tool' ? 'assistant' : role;
+}
+
+export function adaptNcpMessageToUiMessage(message: NcpMessageView): UIMessage {
+  return {
+    id: message.id,
+    role: normalizeRole(message.role),
+    parts: toUiParts(message.parts),
+    meta: {
+      source: 'stream',
+      status: message.status,
+      sessionKey: message.sessionId,
+      timestamp: message.timestamp
+    }
+  };
+}
+
+export function adaptNcpMessagesToUiMessages(messages: readonly NcpMessageView[]): UIMessage[] {
+  return messages.map(adaptNcpMessageToUiMessage);
+}
+
+export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionEntryView {
+  const label = readNcpSessionLabel(summary);
+  const preferredModel = readNcpSessionPreferredModel(summary);
+  return {
+    key: summary.sessionId,
+    createdAt: summary.updatedAt,
+    updatedAt: summary.updatedAt,
+    ...(label ? { label } : {}),
+    ...(preferredModel ? { preferredModel } : {}),
+    sessionType: readNcpSessionType(summary),
+    sessionTypeMutable: false,
+    messageCount: summary.messageCount
+  };
+}
+
+export function adaptNcpSessionSummaries(summaries: NcpSessionSummaryView[]): SessionEntryView[] {
+  return summaries.map(adaptNcpSessionSummary);
+}
+
+export function createNcpSessionId(): string {
+  return `ncp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}

package/src/components/chat/nextclaw/index.ts

@@ -0,0 +1,23 @@
+export { ChatInputBarContainer } from '@/components/chat/containers/chat-input-bar.container';
+export { ChatMessageListContainer } from '@/components/chat/containers/chat-message-list.container';
+
+export {
+  adaptChatMessages,
+  type ChatMessageAdapterTexts,
+  type ChatMessageSource,
+  type ChatMessagePartSource
+} from '@/components/chat/adapters/chat-message.adapter';
+
+export {
+  buildChatSlashItems,
+  buildSelectedSkillItems,
+  buildSkillPickerModel,
+  buildModelStateHint,
+  buildModelToolbarSelect,
+  buildSessionTypeToolbarSelect,
+  buildThinkingToolbarSelect,
+  resolveSlashQuery,
+  type ChatSkillRecord,
+  type ChatModelRecord,
+  type ChatThinkingLevel
+} from '@/components/chat/adapters/chat-input-bar.adapter';