@nextclaw/ui 0.12.10 → 0.12.12

package/src/{components/chat/adapters/chat-input-bar.adapter.ts → features/chat/utils/chat-input-bar.utils.ts}

@@ -1,32 +1,28 @@
 import type {
-  ChatInlineHint,
   ChatSelectedItem,
   ChatSkillPickerOption,
   ChatSkillPickerProps,
   ChatSlashItem,
-  ChatToolbarSelect
 } from '@nextclaw/agent-chat-ui';
+export {
+  buildModelStateHint,
+  buildModelToolbarSelect,
+  buildSessionTypeToolbarSelect,
+  buildThinkingToolbarSelect,
+} from "./chat-input-toolbar.utils";
+import type {
+  ChatInputBarAdapterTexts,
+  ChatModelRecord,
+  ChatSkillRecord,
+  ChatThinkingLevel,
+} from "@/features/chat/types/chat-input-bar.types";
 
-export type ChatThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'adaptive' | 'xhigh';
-
-export type ChatSkillRecord = {
-  key: string;
-  label: string;
-  scopeLabel?: string;
-  description?: string;
-  descriptionZh?: string;
-  badgeLabel?: string;
-};
-
-export type ChatModelRecord = {
-  value: string;
-  modelLabel: string;
-  providerLabel: string;
-  thinkingCapability?: {
-    supported: ChatThinkingLevel[];
-    default?: ChatThinkingLevel | null;
-  } | null;
-};
+export type {
+  ChatInputBarAdapterTexts,
+  ChatModelRecord,
+  ChatSkillRecord,
+  ChatThinkingLevel,
+} from "@/features/chat/types/chat-input-bar.types";
 
 const SLASH_ITEM_MATCH_SCORE = {
   exactSpec: 1200,
@@ -41,29 +37,6 @@ const SLASH_ITEM_MATCH_SCORE = {
   fallback: 1
 } as const;
 
-export type ChatInputBarAdapterTexts = {
-  slashSkillSubtitle: string;
-  slashSkillSpecLabel: string;
-  slashSkillScopeLabel: string;
-  noSkillDescription: string;
-  recentSkillsLabel: string;
-  allSkillsLabel: string;
-  modelSelectPlaceholder: string;
-  modelNoOptionsLabel: string;
-  recentModelsLabel: string;
-  allModelsLabel: string;
-  sessionTypePlaceholder: string;
-  thinkingLabels: Record<ChatThinkingLevel, string>;
-  noModelOptionsLabel: string;
-  configureProviderLabel: string;
-};
-
-function formatModelOptionLabel(option: ChatModelRecord): string {
-  const modelLabel = option.modelLabel.trim();
-  const providerLabel = option.providerLabel.trim();
-  return providerLabel ? `${providerLabel}/${modelLabel}` : modelLabel;
-}
-
 export function resolveSlashQuery(draft: string): string | null {
   const match = /^\/([^\s]*)$/.exec(draft);
   if (!match) {
@@ -296,154 +269,3 @@ export function buildSkillPickerModel(params: {
     onSelectedKeysChange: params.onSelectedKeysChange
   };
 }
-
-export function buildModelStateHint(params: {
-  isModelOptionsLoading: boolean;
-  isModelOptionsEmpty: boolean;
-  onGoToProviders: () => void;
-  texts: Pick<ChatInputBarAdapterTexts, 'noModelOptionsLabel' | 'configureProviderLabel'>;
-}): ChatInlineHint | null {
-  if (!params.isModelOptionsLoading && !params.isModelOptionsEmpty) {
-    return null;
-  }
-  if (params.isModelOptionsLoading) {
-    return {
-      tone: 'neutral',
-      loading: true
-    };
-  }
-  return {
-    tone: 'warning',
-    text: params.texts.noModelOptionsLabel,
-    actionLabel: params.texts.configureProviderLabel,
-    onAction: params.onGoToProviders
-  };
-}
-
-export function buildModelToolbarSelect(params: {
-  modelOptions: ChatModelRecord[];
-  recentModelValues?: string[];
-  selectedModel: string;
-  isModelOptionsLoading: boolean;
-  hasModelOptions: boolean;
-  onValueChange: (value: string) => void;
-  texts: Pick<ChatInputBarAdapterTexts, 'modelSelectPlaceholder' | 'modelNoOptionsLabel' | 'recentModelsLabel' | 'allModelsLabel'>;
-}): ChatToolbarSelect {
-  const selectedModelOption = params.modelOptions.find((option) => option.value === params.selectedModel);
-  const fallbackModelOption = params.modelOptions[0];
-  const resolvedModelOption = selectedModelOption ?? fallbackModelOption;
-  const resolvedValue = params.hasModelOptions ? resolvedModelOption?.value : undefined;
-  const recentValueSet = new Set(params.recentModelValues ?? []);
-  const modelOptionMap = new Map(params.modelOptions.map((option) => [option.value, option] as const));
-  const recentOptions = (params.recentModelValues ?? [])
-    .map((value) => modelOptionMap.get(value))
-    .filter((option): option is ChatModelRecord => Boolean(option));
-  const remainingOptions = params.modelOptions.filter((option) => !recentValueSet.has(option.value));
-  const optionGroups =
-    recentOptions.length > 0
-      ? [
-          {
-            key: 'recent-models',
-            label: params.texts.recentModelsLabel,
-            options: recentOptions.map((option) => ({
-              value: option.value,
-              label: formatModelOptionLabel(option)
-            }))
-          },
-          {
-            key: 'all-models',
-            label: params.texts.allModelsLabel,
-            options: remainingOptions.map((option) => ({
-              value: option.value,
-              label: formatModelOptionLabel(option)
-            }))
-          }
-        ].filter((group) => group.options.length > 0)
-      : undefined;
-
-  return {
-    key: 'model',
-    value: resolvedValue,
-    placeholder: params.texts.modelSelectPlaceholder,
-    selectedLabel: resolvedModelOption ? formatModelOptionLabel(resolvedModelOption) : undefined,
-    icon: 'sparkles',
-    options: params.modelOptions.map((option) => ({
-      value: option.value,
-      label: formatModelOptionLabel(option)
-    })),
-    groups: optionGroups,
-    disabled: !params.hasModelOptions,
-    loading: params.isModelOptionsLoading,
-    emptyLabel: params.texts.modelNoOptionsLabel,
-    onValueChange: params.onValueChange
-  };
-}
-
-export function buildSessionTypeToolbarSelect(params: {
-  selectedSessionType?: string;
-  selectedSessionTypeOption: { value: string; label: string } | null;
-  sessionTypeOptions: Array<{ value: string; label: string }>;
-  onValueChange: (value: string) => void;
-  canEditSessionType: boolean;
-  shouldShow: boolean;
-  texts: Pick<ChatInputBarAdapterTexts, 'sessionTypePlaceholder'>;
-}): ChatToolbarSelect | null {
-  if (!params.shouldShow) {
-    return null;
-  }
-
-  return {
-    key: 'session-type',
-    value: params.selectedSessionType,
-    placeholder: params.texts.sessionTypePlaceholder,
-    selectedLabel: params.selectedSessionTypeOption?.label,
-    options: params.sessionTypeOptions.map((option) => ({
-      value: option.value,
-      label: option.label
-    })),
-    disabled: !params.canEditSessionType,
-    onValueChange: params.onValueChange
-  };
-}
-
-function normalizeThinkingLevels(levels: ChatThinkingLevel[]): ChatThinkingLevel[] {
-  const deduped: ChatThinkingLevel[] = [];
-  for (const level of ['off', ...levels] as ChatThinkingLevel[]) {
-    if (!deduped.includes(level)) {
-      deduped.push(level);
-    }
-  }
-  return deduped;
-}
-
-export function buildThinkingToolbarSelect(params: {
-  supportedLevels: ChatThinkingLevel[];
-  selectedThinkingLevel: ChatThinkingLevel | null;
-  defaultThinkingLevel?: ChatThinkingLevel | null;
-  onValueChange: (value: ChatThinkingLevel) => void;
-  texts: Pick<ChatInputBarAdapterTexts, 'thinkingLabels'>;
-}): ChatToolbarSelect | null {
-  if (params.supportedLevels.length === 0) {
-    return null;
-  }
-
-  const options = normalizeThinkingLevels(params.supportedLevels);
-  const fallback = options.includes('off') ? 'off' : options[0];
-  const resolvedValue =
-    (params.selectedThinkingLevel && options.includes(params.selectedThinkingLevel) && params.selectedThinkingLevel) ||
-    (params.defaultThinkingLevel && options.includes(params.defaultThinkingLevel) && params.defaultThinkingLevel) ||
-    fallback;
-
-  return {
-    key: 'thinking',
-    value: resolvedValue,
-    placeholder: params.texts.thinkingLabels[resolvedValue],
-    selectedLabel: params.texts.thinkingLabels[resolvedValue],
-    icon: 'brain',
-    options: options.map((level) => ({
-      value: level,
-      label: params.texts.thinkingLabels[level]
-    })),
-    onValueChange: (value) => params.onValueChange(value as ChatThinkingLevel)
-  };
-}

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

@@ -0,0 +1,191 @@
+import type {
+  ChatInlineHint,
+  ChatToolbarSelect,
+} from "@nextclaw/agent-chat-ui";
+import type {
+  ChatInputBarAdapterTexts,
+  ChatModelRecord,
+  ChatThinkingLevel,
+} from "@/features/chat/types/chat-input-bar.types";
+
+function formatModelOptionLabel(option: ChatModelRecord): string {
+  const modelLabel = option.modelLabel.trim();
+  const providerLabel = option.providerLabel.trim();
+  return providerLabel ? `${providerLabel}/${modelLabel}` : modelLabel;
+}
+
+function normalizeThinkingLevels(
+  levels: ChatThinkingLevel[],
+): ChatThinkingLevel[] {
+  const deduped: ChatThinkingLevel[] = [];
+  for (const level of ["off", ...levels] as ChatThinkingLevel[]) {
+    if (!deduped.includes(level)) {
+      deduped.push(level);
+    }
+  }
+  return deduped;
+}
+
+export function buildModelStateHint(params: {
+  isModelOptionsLoading: boolean;
+  isModelOptionsEmpty: boolean;
+  onGoToProviders: () => void;
+  texts: Pick<
+    ChatInputBarAdapterTexts,
+    "noModelOptionsLabel" | "configureProviderLabel"
+  >;
+}): ChatInlineHint | null {
+  if (!params.isModelOptionsLoading && !params.isModelOptionsEmpty) {
+    return null;
+  }
+  if (params.isModelOptionsLoading) {
+    return {
+      tone: "neutral",
+      loading: true,
+    };
+  }
+  return {
+    tone: "warning",
+    text: params.texts.noModelOptionsLabel,
+    actionLabel: params.texts.configureProviderLabel,
+    onAction: params.onGoToProviders,
+  };
+}
+
+export function buildModelToolbarSelect(params: {
+  modelOptions: ChatModelRecord[];
+  recentModelValues?: string[];
+  selectedModel: string;
+  isModelOptionsLoading: boolean;
+  hasModelOptions: boolean;
+  onValueChange: (value: string) => void;
+  texts: Pick<
+    ChatInputBarAdapterTexts,
+    | "modelSelectPlaceholder"
+    | "modelNoOptionsLabel"
+    | "recentModelsLabel"
+    | "allModelsLabel"
+  >;
+}): ChatToolbarSelect {
+  const selectedModelOption = params.modelOptions.find(
+    (option) => option.value === params.selectedModel,
+  );
+  const fallbackModelOption = params.modelOptions[0];
+  const resolvedModelOption = selectedModelOption ?? fallbackModelOption;
+  const resolvedValue = params.hasModelOptions
+    ? resolvedModelOption?.value
+    : undefined;
+  const recentValueSet = new Set(params.recentModelValues ?? []);
+  const modelOptionMap = new Map(
+    params.modelOptions.map((option) => [option.value, option] as const),
+  );
+  const recentOptions = (params.recentModelValues ?? [])
+    .map((value) => modelOptionMap.get(value))
+    .filter((option): option is ChatModelRecord => Boolean(option));
+  const remainingOptions = params.modelOptions.filter(
+    (option) => !recentValueSet.has(option.value),
+  );
+  const optionGroups =
+    recentOptions.length > 0
+      ? [
+          {
+            key: "recent-models",
+            label: params.texts.recentModelsLabel,
+            options: recentOptions.map((option) => ({
+              value: option.value,
+              label: formatModelOptionLabel(option),
+            })),
+          },
+          {
+            key: "all-models",
+            label: params.texts.allModelsLabel,
+            options: remainingOptions.map((option) => ({
+              value: option.value,
+              label: formatModelOptionLabel(option),
+            })),
+          },
+        ].filter((group) => group.options.length > 0)
+      : undefined;
+
+  return {
+    key: "model",
+    value: resolvedValue,
+    placeholder: params.texts.modelSelectPlaceholder,
+    selectedLabel: resolvedModelOption
+      ? formatModelOptionLabel(resolvedModelOption)
+      : undefined,
+    icon: "sparkles",
+    options: params.modelOptions.map((option) => ({
+      value: option.value,
+      label: formatModelOptionLabel(option),
+    })),
+    groups: optionGroups,
+    disabled: !params.hasModelOptions,
+    loading: params.isModelOptionsLoading,
+    emptyLabel: params.texts.modelNoOptionsLabel,
+    onValueChange: params.onValueChange,
+  };
+}
+
+export function buildSessionTypeToolbarSelect(params: {
+  selectedSessionType?: string;
+  selectedSessionTypeOption: { value: string; label: string } | null;
+  sessionTypeOptions: Array<{ value: string; label: string }>;
+  onValueChange: (value: string) => void;
+  canEditSessionType: boolean;
+  shouldShow: boolean;
+  texts: Pick<ChatInputBarAdapterTexts, "sessionTypePlaceholder">;
+}): ChatToolbarSelect | null {
+  if (!params.shouldShow) {
+    return null;
+  }
+
+  return {
+    key: "session-type",
+    value: params.selectedSessionType,
+    placeholder: params.texts.sessionTypePlaceholder,
+    selectedLabel: params.selectedSessionTypeOption?.label,
+    options: params.sessionTypeOptions.map((option) => ({
+      value: option.value,
+      label: option.label,
+    })),
+    disabled: !params.canEditSessionType,
+    onValueChange: params.onValueChange,
+  };
+}
+
+export function buildThinkingToolbarSelect(params: {
+  supportedLevels: ChatThinkingLevel[];
+  selectedThinkingLevel: ChatThinkingLevel | null;
+  defaultThinkingLevel?: ChatThinkingLevel | null;
+  onValueChange: (value: ChatThinkingLevel) => void;
+  texts: Pick<ChatInputBarAdapterTexts, "thinkingLabels">;
+}): ChatToolbarSelect | null {
+  if (params.supportedLevels.length === 0) {
+    return null;
+  }
+
+  const options = normalizeThinkingLevels(params.supportedLevels);
+  const fallback = options.includes("off") ? "off" : options[0];
+  const resolvedValue =
+    (params.selectedThinkingLevel &&
+      options.includes(params.selectedThinkingLevel) &&
+      params.selectedThinkingLevel) ||
+    (params.defaultThinkingLevel &&
+      options.includes(params.defaultThinkingLevel) &&
+      params.defaultThinkingLevel) ||
+    fallback;
+
+  return {
+    key: "thinking",
+    value: resolvedValue,
+    placeholder: params.texts.thinkingLabels[resolvedValue],
+    selectedLabel: params.texts.thinkingLabels[resolvedValue],
+    icon: "brain",
+    options: options.map((level) => ({
+      value: level,
+      label: params.texts.thinkingLabels[level],
+    })),
+    onValueChange: (value) => params.onValueChange(value as ChatThinkingLevel),
+  };
+}

package/src/{lib/chat-message.ts → features/chat/utils/chat-message-core.utils.ts}

@@ -1,4 +1,4 @@
-import type { SessionEventView, SessionMessageView } from '@/api/types';
+import type { SessionEventView, SessionMessageView } from '@/shared/lib/api';
 
 export type ChatRole = 'user' | 'assistant' | 'tool' | 'system' | 'other';
 

package/src/{components/chat/adapters/chat-message-inline-content.adapter.ts → features/chat/utils/chat-message-inline-content.utils.ts}

@@ -1,12 +1,12 @@
 import {
   splitTextByInlineTokens,
   type ChatInlineTokenSource,
-} from "@/components/chat/chat-inline-token.utils";
+} from "@/features/chat/utils/chat-inline-token.utils";
 import type {
   ChatInlineContentSegmentViewModel,
   ChatMessagePartViewModel,
 } from "@nextclaw/agent-chat-ui";
-import type { ChatMessagePartSource } from "@/components/chat/adapters/chat-message-part.adapter";
+import type { ChatMessagePartSource } from "./chat-message-part.utils";
 
 const INVISIBLE_ONLY_TEXT_PATTERN = /\u200B|\u200C|\u200D|\u2060|\uFEFF/g;
 

package/src/features/chat/utils/chat-message-part.utils.ts

@@ -0,0 +1,233 @@
+import {
+  stringifyUnknown,
+  summarizeToolArgs,
+} from "@/features/chat/utils/chat-message-core.utils";
+import { type ChatInlineTokenSource } from "@/features/chat/utils/chat-inline-token.utils";
+import {
+  buildRenderableText,
+  buildTextPart,
+} from "./chat-message-inline-content.utils";
+import {
+  buildToolCard,
+  buildToolInvocationInput,
+  extractAssetFileView,
+  isTerminalResultRecord,
+  readOptionalNumber,
+  resolveToolCardStatus,
+  type ToolCardViewSource,
+} from "./chat-message-tool-card.utils";
+import { resolveToolInvocationAgentId } from "./chat-message-tool-agent-id.utils";
+import { buildFileOperationCardData } from "./file-operation/card.utils";
+import { buildSessionRequestToolCard } from "./chat-message-session-request-tool-card.utils";
+import type {
+  ChatMessagePartViewModel,
+  ChatToolPartViewModel,
+} from "@nextclaw/agent-chat-ui";
+import type {
+  ChatMessageAdapterTexts,
+  ChatMessagePartSource,
+} from "@/features/chat/types/chat-message.types";
+
+export type {
+  ChatMessageAdapterTexts,
+  ChatMessagePartSource,
+} from "@/features/chat/types/chat-message.types";
+
+type ChatMessagePartAdapterParams = {
+  part: ChatMessagePartSource;
+  inlineTokens: readonly ChatInlineTokenSource[];
+  texts: ChatMessageAdapterTexts;
+};
+
+
+function buildReasoningPart(
+  part: Extract<ChatMessagePartSource, { type: "reasoning" }>,
+  texts: ChatMessageAdapterTexts,
+): Extract<ChatMessagePartViewModel, { type: "reasoning" }> | null {
+  const text = buildRenderableText(part.reasoning);
+  if (!text) {
+    return null;
+  }
+  return {
+    type: "reasoning",
+    text,
+    label: texts.reasoningLabel,
+  };
+}
+
+function buildFilePart(
+  part: Extract<ChatMessagePartSource, { type: "file" }>,
+  texts: ChatMessageAdapterTexts,
+): Extract<ChatMessagePartViewModel, { type: "file" }> {
+  const isImage = part.mimeType.startsWith("image/");
+  const sizeBytes = readOptionalNumber(part.sizeBytes);
+  return {
+    type: "file",
+    file: {
+      label:
+        typeof part.name === "string" && part.name.trim()
+          ? part.name.trim()
+          : isImage
+            ? texts.imageAttachmentLabel
+            : texts.fileAttachmentLabel,
+      mimeType: part.mimeType,
+      dataUrl:
+        typeof part.url === "string" && part.url.trim().length > 0
+          ? part.url.trim()
+          : `data:${part.mimeType};base64,${part.data}`,
+      ...(sizeBytes != null ? { sizeBytes } : {}),
+      isImage,
+    },
+  };
+}
+
+function buildToolInvocationPart(
+  part: Extract<ChatMessagePartSource, { type: "tool-invocation" }>,
+  texts: ChatMessageAdapterTexts,
+): Extract<ChatMessagePartViewModel, { type: "tool-card" | "file" }> {
+  const invocation = part.toolInvocation;
+  const assetFileView = extractAssetFileView(invocation.result, texts);
+  if (assetFileView) {
+    return assetFileView;
+  }
+
+  const sessionRequestToolCard = buildSessionRequestToolCard({
+    invocation,
+    texts: {
+      toolStatusRunningLabel: texts.toolStatusRunningLabel,
+      toolStatusCompletedLabel: texts.toolStatusCompletedLabel,
+      toolStatusFailedLabel: texts.toolStatusFailedLabel,
+    },
+  });
+  if (sessionRequestToolCard) {
+    return {
+      type: "tool-card",
+      card: buildToolCard(sessionRequestToolCard, texts),
+    };
+  }
+
+  const statusView = resolveToolCardStatus({
+    status: invocation.status,
+    error: invocation.error,
+    cancelled: invocation.cancelled,
+    result: invocation.result,
+    texts,
+  });
+  const fileOperationCardData = buildFileOperationCardData({
+    toolName: invocation.toolName,
+    status: invocation.status,
+    toolCallId: invocation.toolCallId,
+    args: invocation.args,
+    parsedArgs: invocation.parsedArgs,
+    result: invocation.result,
+  });
+  const detail =
+    fileOperationCardData?.summary ??
+    summarizeToolArgs(invocation.parsedArgs ?? invocation.args);
+  const input = fileOperationCardData
+    ? undefined
+    : buildToolInvocationInput(invocation.args, invocation.parsedArgs);
+  const rawResult =
+    typeof invocation.error === "string" && invocation.error.trim()
+      ? invocation.error.trim()
+      : invocation.result != null
+        ? stringifyUnknown(invocation.result).trim()
+        : "";
+  const shouldHideStructuredTerminalJson =
+    !invocation.error && isTerminalResultRecord(invocation.result);
+  const shouldShowRawResult =
+    (!fileOperationCardData?.fileOperation || Boolean(invocation.error)) &&
+    !shouldHideStructuredTerminalJson;
+  const agentId = resolveToolInvocationAgentId(invocation);
+  const card: ToolCardViewSource = {
+    kind: statusView.kind,
+    name: invocation.toolName,
+    ...(agentId ? { agentId } : {}),
+    detail,
+    ...(input ? { input } : {}),
+    text: shouldShowRawResult && rawResult ? rawResult : undefined,
+    outputData: invocation.result,
+    callId: invocation.toolCallId || undefined,
+    hasResult: statusView.hasResult,
+    statusTone: statusView.statusTone,
+    statusLabel: statusView.statusLabel,
+    ...(fileOperationCardData?.fileOperation
+      ? { fileOperation: fileOperationCardData.fileOperation }
+      : {}),
+  };
+  return {
+    type: "tool-card",
+    card: buildToolCard(card, texts),
+  };
+}
+
+function buildUnknownPart(
+  part: ChatMessagePartSource,
+  texts: ChatMessageAdapterTexts,
+): Extract<ChatMessagePartViewModel, { type: "unknown" }> {
+  return {
+    type: "unknown",
+    label: texts.unknownPartLabel,
+    rawType: typeof part.type === "string" ? part.type : "unknown",
+    text: stringifyUnknown(part),
+  };
+}
+
+function isTextPart(
+  part: ChatMessagePartSource,
+): part is Extract<ChatMessagePartSource, { type: "text" }> {
+  return part.type === "text" && typeof part.text === "string";
+}
+
+function isReasoningPart(
+  part: ChatMessagePartSource,
+): part is Extract<ChatMessagePartSource, { type: "reasoning" }> {
+  return part.type === "reasoning" && typeof part.reasoning === "string";
+}
+
+function isFilePart(
+  part: ChatMessagePartSource,
+): part is Extract<ChatMessagePartSource, { type: "file" }> {
+  return (
+    part.type === "file" &&
+    typeof part.mimeType === "string" &&
+    typeof part.data === "string"
+  );
+}
+
+function isToolInvocationPart(
+  part: ChatMessagePartSource,
+): part is Extract<ChatMessagePartSource, { type: "tool-invocation" }> {
+  if (part.type !== "tool-invocation") {
+    return false;
+  }
+  if (
+    typeof part.toolInvocation !== "object" ||
+    part.toolInvocation === null ||
+    Array.isArray(part.toolInvocation)
+  ) {
+    return false;
+  }
+  return (
+    "toolName" in part.toolInvocation &&
+    typeof part.toolInvocation.toolName === "string"
+  );
+}
+
+export function adaptChatMessagePart(
+  params: ChatMessagePartAdapterParams,
+): ChatMessagePartViewModel | null {
+  if (isTextPart(params.part)) {
+    return buildTextPart(params.part, params.inlineTokens);
+  }
+  if (isReasoningPart(params.part)) {
+    return buildReasoningPart(params.part, params.texts);
+  }
+  if (isFilePart(params.part)) {
+    return buildFilePart(params.part, params.texts);
+  }
+  if (isToolInvocationPart(params.part)) {
+    return buildToolInvocationPart(params.part, params.texts);
+  }
+  return buildUnknownPart(params.part, params.texts);
+}

package/src/{components/chat/adapters/chat-message.session-request-tool-card.ts → features/chat/utils/chat-message-session-request-tool-card.utils.ts}

@@ -2,8 +2,8 @@ import {
   stringifyUnknown,
   summarizeToolArgs,
   type ToolCard,
-} from "@/lib/chat-message";
-import { resolveToolInvocationAgentId } from "@/components/chat/adapters/chat-message-tool-agent-id";
+} from "@/features/chat/utils/chat-message-core.utils";
+import { resolveToolInvocationAgentId } from "./chat-message-tool-agent-id.utils";
 import type { ChatToolPartViewModel } from "@nextclaw/agent-chat-ui";
 
 type ToolCardViewSource = ToolCard & {

package/src/{components/chat/adapters/chat-message.session-spawn-tool-card.test.ts → features/chat/utils/chat-message-session-spawn-tool-card.utils.test.ts}

@@ -1,6 +1,6 @@
 import { ToolInvocationStatus, type UiMessage } from "@nextclaw/agent-chat";
-import { adaptChatMessages } from "@/components/chat/adapters/chat-message.adapter";
-import type { ChatMessageSource } from "@/components/chat/adapters/chat-message.adapter";
+import { adaptChatMessages } from "./chat-message.utils";
+import type { ChatMessageSource } from "./chat-message.utils";
 
 const defaultTexts = {
   roleLabels: {