@nextclaw/ui 0.12.10 → 0.12.12

package/src/{components/chat/adapters/chat-message.summary-truncation.test.ts → features/chat/utils/chat-message-summary-truncation.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";
 import type { ChatMessagePartViewModel } from "@nextclaw/agent-chat-ui";
 
 const defaultTexts = {

package/src/{components/chat/adapters/chat-message-tool-agent-id.test.ts → features/chat/utils/chat-message-tool-agent-id.utils.test.ts}

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

package/src/features/chat/utils/chat-message-tool-card.utils.ts

@@ -0,0 +1,216 @@
+import {
+  stringifyUnknown,
+  type ToolCard,
+} from "@/features/chat/utils/chat-message-core.utils";
+import type {
+  ChatMessagePartViewModel,
+  ChatToolPartViewModel,
+} from "@nextclaw/agent-chat-ui";
+import type { ChatMessageAdapterTexts } from "@/features/chat/types/chat-message.types";
+
+export type ToolCardViewSource = ToolCard & {
+  statusTone: ChatToolPartViewModel["statusTone"];
+  statusLabel: string;
+  agentId?: string;
+  action?: ChatToolPartViewModel["action"];
+  fileOperation?: ChatToolPartViewModel["fileOperation"];
+  outputData?: unknown;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function readOptionalString(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function readOptionalNumber(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+
+export function isTerminalResultRecord(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return (
+    "command" in value ||
+    "workingDir" in value ||
+    "exitCode" in value ||
+    "stdout" in value ||
+    "stderr" in value ||
+    "aggregated_output" in value ||
+    "combinedOutput" in value
+  );
+}
+
+export function extractAssetFileView(
+  value: unknown,
+  texts: ChatMessageAdapterTexts,
+): Extract<ChatMessagePartViewModel, { type: "file" }> | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const assetCandidate = isRecord(value.asset)
+    ? value.asset
+    : Array.isArray(value.assets) &&
+        value.assets.length > 0 &&
+        isRecord(value.assets[0])
+      ? value.assets[0]
+      : null;
+  if (!assetCandidate) {
+    return null;
+  }
+  const url = readOptionalString(assetCandidate.url);
+  const mimeType =
+    readOptionalString(assetCandidate.mimeType) ?? "application/octet-stream";
+  const sizeBytes = readOptionalNumber(assetCandidate.sizeBytes);
+  if (!url) {
+    return null;
+  }
+  const label =
+    readOptionalString(assetCandidate.name) ??
+    (mimeType.startsWith("image/")
+      ? texts.imageAttachmentLabel
+      : texts.fileAttachmentLabel);
+  return {
+    type: "file",
+    file: {
+      label,
+      mimeType,
+      dataUrl: url,
+      ...(sizeBytes != null ? { sizeBytes } : {}),
+      isImage: mimeType.startsWith("image/"),
+    },
+  };
+}
+
+export function buildToolCard(
+  toolCard: ToolCardViewSource,
+  texts: ChatMessageAdapterTexts,
+): ChatToolPartViewModel {
+  return {
+    kind: toolCard.kind,
+    toolName: toolCard.name,
+    ...("agentId" in toolCard && toolCard.agentId
+      ? { agentId: toolCard.agentId }
+      : {}),
+    summary: toolCard.detail,
+    inputLabel: texts.toolInputLabel,
+    input:
+      "input" in toolCard && typeof toolCard.input === "string"
+        ? toolCard.input
+        : undefined,
+    output: toolCard.text,
+    outputData: toolCard.outputData,
+    hasResult: Boolean(toolCard.hasResult),
+    statusTone: toolCard.statusTone,
+    statusLabel: toolCard.statusLabel,
+    titleLabel:
+      toolCard.kind === "call" ? texts.toolCallLabel : texts.toolResultLabel,
+    outputLabel: texts.toolOutputLabel,
+    emptyLabel: texts.toolNoOutputLabel,
+    ...("action" in toolCard && toolCard.action
+      ? { action: toolCard.action }
+      : {}),
+    ...("fileOperation" in toolCard && toolCard.fileOperation
+      ? { fileOperation: toolCard.fileOperation }
+      : {}),
+  };
+}
+
+export function resolveToolCardStatus(params: {
+  status?: string;
+  error?: string;
+  cancelled?: boolean;
+  result?: unknown;
+  texts: ChatMessageAdapterTexts;
+}): Pick<
+  ChatToolPartViewModel,
+  "kind" | "hasResult" | "statusTone" | "statusLabel"
+> {
+  const rawStatus =
+    typeof params.status === "string" ? params.status.trim().toLowerCase() : "";
+  const hasError =
+    typeof params.error === "string" && params.error.trim().length > 0;
+  const isCancelled = params.cancelled === true || rawStatus === "cancelled";
+  if (isCancelled) {
+    return {
+      kind: "result",
+      hasResult: true,
+      statusTone: "cancelled",
+      statusLabel: params.texts.toolStatusCancelledLabel,
+    };
+  }
+  if (hasError || rawStatus === "error") {
+    return {
+      kind: "result",
+      hasResult: true,
+      statusTone: "error",
+      statusLabel: params.texts.toolStatusFailedLabel,
+    };
+  }
+  if (rawStatus === "result" || params.result != null) {
+    return {
+      kind: "result",
+      hasResult: true,
+      statusTone: "success",
+      statusLabel: params.texts.toolStatusCompletedLabel,
+    };
+  }
+  if (rawStatus === "partial-call") {
+    return {
+      kind: "call",
+      hasResult: false,
+      statusTone: "running",
+      statusLabel: params.texts.toolStatusRunningLabel,
+    };
+  }
+  return {
+    kind: "call",
+    hasResult: false,
+    statusTone: "running",
+    statusLabel: params.texts.toolStatusRunningLabel,
+  };
+}
+
+function parseStructuredValue(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return value;
+  }
+  try {
+    return JSON.parse(trimmed) as unknown;
+  } catch {
+    return value;
+  }
+}
+
+export function buildToolInvocationInput(
+  args?: unknown,
+  parsedArgs?: unknown,
+): string | undefined {
+  const source = parsedArgs ?? parseStructuredValue(args);
+  const text = stringifyUnknown(source).trim();
+  return text || undefined;
+}

package/src/{components/chat/adapters/chat-message.adapter.test.ts → features/chat/utils/chat-message.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";
 
 function toSource(uiMessages: UiMessage[]): ChatMessageSource[] {
   return uiMessages as unknown as ChatMessageSource[];

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

@@ -1,5 +1,5 @@
-import { adaptChatMessagePart } from "@/components/chat/adapters/chat-message-part.adapter";
-import type { ChatInlineTokenSource } from "@/components/chat/chat-inline-token.utils";
+import { adaptChatMessagePart } from "./chat-message-part.utils";
+import type { ChatInlineTokenSource } from "@/features/chat/utils/chat-inline-token.utils";
 import type {
   ChatMessageRole,
   ChatMessageViewModel,
@@ -7,12 +7,12 @@ import type {
 import type {
   ChatMessageAdapterTexts,
   ChatMessagePartSource,
-} from "@/components/chat/adapters/chat-message-part.adapter";
+} from "@/features/chat/types/chat-message.types";
 
 export type {
   ChatMessageAdapterTexts,
   ChatMessagePartSource,
-} from "@/components/chat/adapters/chat-message-part.adapter";
+} from "@/features/chat/types/chat-message.types";
 
 export type ChatMessageSource = {
   id: string;

package/src/features/chat/utils/chat-runtime.utils.ts

@@ -0,0 +1,235 @@
+import type { SessionMessageView } from '@/shared/lib/api';
+import { extractMessageText } from './chat-message-core.utils';
+import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
+
+export { isAbortLikeError, formatSendError, buildLocalAssistantMessage } from '@nextclaw/agent-chat';
+
+const HISTORY_TOOL_ROLES = new Set(['tool', 'tool_result', 'toolresult', 'function']);
+
+type ToolArgsPayload = {
+  args: string;
+  parsedArgs?: unknown;
+};
+
+function parseToolArgsPayload(raw: unknown): ToolArgsPayload {
+  const args = typeof raw === 'string' ? raw : JSON.stringify(raw ?? {});
+  try {
+    return { args, parsedArgs: JSON.parse(args) };
+  } catch {
+    return { args };
+  }
+}
+
+function findToolPartIndex(parts: UIMessage['parts'], toolCallId: string): number {
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    const part = parts[index];
+    if (part.type === 'tool-invocation' && part.toolInvocation.toolCallId === toolCallId) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+class HistoryMessageBuilder {
+  private readonly output: UIMessage[] = [];
+  private cursor = 0;
+  private assistantIndex = 0;
+  private activeAssistant: UIMessage | null = null;
+
+  build = (messages: SessionMessageView[]): UIMessage[] => {
+    for (const message of messages) {
+      const role = message.role?.toLowerCase().trim();
+      if (!role) continue;
+      if (role === 'user' || role === 'system' || role === 'data') {
+        this.appendTextMessage(message, role as UIMessage['role']);
+        continue;
+      }
+      if (role === 'assistant') {
+        this.appendAssistantMessage(message);
+        continue;
+      }
+
+      if (HISTORY_TOOL_ROLES.has(role)) {
+        this.appendToolResult(message);
+      }
+    }
+
+    this.flushAssistant();
+    return this.output;
+  };
+
+  private buildId = (role: UIMessage['role'], timestamp: string): string => {
+    this.cursor += 1;
+    return `history-${role}-${timestamp || 'unknown'}-${this.cursor}`;
+  };
+
+  private ensureAssistant = (timestamp: string): UIMessage => {
+    if (!this.activeAssistant) {
+      this.assistantIndex += 1;
+      this.activeAssistant = {
+        id: `history-assistant-${this.assistantIndex}-${timestamp || 'unknown'}`,
+        role: 'assistant',
+        parts: [],
+        meta: { source: 'history', status: 'final', timestamp }
+      };
+      return this.activeAssistant;
+    }
+
+    this.activeAssistant = {
+      ...this.activeAssistant,
+      meta: { ...this.activeAssistant.meta, timestamp }
+    };
+    return this.activeAssistant;
+  };
+
+  private flushAssistant = (): void => {
+    if (this.activeAssistant?.parts.length) {
+      this.output.push(this.activeAssistant);
+    }
+    this.activeAssistant = null;
+  };
+
+  private appendTextMessage = (message: SessionMessageView, role: UIMessage['role']): void => {
+    this.flushAssistant();
+    const text = extractMessageText(message.content).trim();
+    if (!text) return;
+    this.output.push({
+      id: this.buildId(role, message.timestamp),
+      role,
+      parts: [{ type: 'text', text }],
+      meta: { source: 'history', status: 'final', timestamp: message.timestamp }
+    });
+  };
+
+  private appendAssistantText = (timestamp: string, text: string): void => {
+    if (!text) return;
+    const assistant = this.ensureAssistant(timestamp);
+    assistant.parts = [...assistant.parts, { type: 'text', text }];
+  };
+
+  private appendAssistantReasoning = (timestamp: string, reasoning: string): void => {
+    if (!reasoning) return;
+    const assistant = this.ensureAssistant(timestamp);
+    assistant.parts = [...assistant.parts, { type: 'reasoning', reasoning, details: [] }];
+  };
+
+  private appendAssistantToolCall = (params: {
+    timestamp: string;
+    toolCallId: string;
+    toolName: string;
+    args: string;
+    parsedArgs?: unknown;
+  }): void => {
+    const { timestamp, toolCallId, toolName, args, parsedArgs } = params;
+    const assistant = this.ensureAssistant(timestamp);
+    const partIndex = findToolPartIndex(assistant.parts, toolCallId);
+    const part = {
+      type: 'tool-invocation' as const,
+      toolInvocation: {
+        status: ToolInvocationStatus.CALL,
+        toolCallId,
+        toolName,
+        args,
+        parsedArgs
+      }
+    };
+    assistant.parts =
+      partIndex >= 0
+        ? [...assistant.parts.slice(0, partIndex), part, ...assistant.parts.slice(partIndex + 1)]
+        : [...assistant.parts, part];
+  };
+
+  private appendToolResult = (message: SessionMessageView): void => {
+    const toolCallId = typeof message.tool_call_id === 'string' ? message.tool_call_id.trim() : '';
+    if (!toolCallId) return;
+    const assistant = this.ensureAssistant(message.timestamp);
+    const partIndex = findToolPartIndex(assistant.parts, toolCallId);
+    const toolName = typeof message.name === 'string' && message.name.trim() ? message.name.trim() : 'tool';
+    if (partIndex < 0) {
+      assistant.parts = [
+        ...assistant.parts,
+        {
+          type: 'tool-invocation',
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId,
+            toolName,
+            args: '{}',
+            parsedArgs: undefined,
+            result: message.content
+          }
+        }
+      ];
+      return;
+    }
+    const part = assistant.parts[partIndex];
+    if (part.type !== 'tool-invocation') return;
+    assistant.parts = [
+      ...assistant.parts.slice(0, partIndex),
+      {
+        ...part,
+        toolInvocation: {
+          ...part.toolInvocation,
+          status: ToolInvocationStatus.RESULT,
+          result: message.content
+        }
+      },
+      ...assistant.parts.slice(partIndex + 1)
+    ];
+  };
+
+  private appendAssistantMessage = (message: SessionMessageView): void => {
+    const timestamp = message.timestamp;
+    const text = extractMessageText(message.content).trim();
+    if (text) {
+      this.appendAssistantText(timestamp, text);
+    }
+    if (typeof message.reasoning_content === 'string' && message.reasoning_content.trim()) {
+      this.appendAssistantReasoning(timestamp, message.reasoning_content.trim());
+    }
+    if (!Array.isArray(message.tool_calls)) return;
+    for (const call of message.tool_calls) {
+      if (!call || typeof call !== 'object') {
+        continue;
+      }
+      const callRecord = call as Record<string, unknown>;
+      const functionValue = callRecord.function;
+      const fn =
+        typeof functionValue === 'object' && functionValue
+          ? (functionValue as { name?: unknown; arguments?: unknown })
+          : null;
+      const toolCallId = typeof callRecord.id === 'string' ? callRecord.id.trim() : '';
+      if (!toolCallId) {
+        continue;
+      }
+      const toolName =
+        typeof fn?.name === 'string' ? fn.name : typeof callRecord.name === 'string' ? callRecord.name : 'tool';
+      const payload = parseToolArgsPayload(fn?.arguments ?? callRecord.arguments ?? '');
+      this.appendAssistantToolCall({
+        timestamp,
+        toolCallId,
+        toolName,
+        args: payload.args,
+        parsedArgs: payload.parsedArgs
+      });
+    }
+  };
+}
+
+export function normalizeRequestedSkills(value: string[] | undefined): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const deduped = new Set<string>();
+  for (const item of value) {
+    const trimmed = item.trim();
+    if (trimmed) {
+      deduped.add(trimmed);
+    }
+  }
+  return [...deduped];
+}
+
+export function buildUiMessagesFromHistoryMessages(messages: SessionMessageView[]): UIMessage[] {
+  return new HistoryMessageBuilder().build(messages);
+}

package/src/{components/chat/chat-session-display.test.ts → features/chat/utils/chat-session-display.utils.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import type { SessionEntryView } from '@/api/types';
-import { sessionDisplayName, sessionMatchesQuery } from '@/components/chat/chat-session-display';
+import type { SessionEntryView } from '@/shared/lib/api';
+import { sessionDisplayName, sessionMatchesQuery } from './chat-session-display.utils';
 
 function createSession(overrides: Partial<SessionEntryView> = {}): SessionEntryView {
   return {

package/src/{components/chat/chat-session-display.ts → features/chat/utils/chat-session-display.utils.ts}

@@ -1,8 +1,9 @@
-import type { SessionEntryView } from '@/api/types';
+import type { SessionEntryView } from '@/shared/lib/api';
 
 export function sessionDisplayName(session: SessionEntryView): string {
-  if (session.label && session.label.trim()) {
-    return session.label.trim();
+  const label = session.label?.trim();
+  if (label) {
+    return label;
   }
   const chunks = session.key.split(':');
   return chunks[chunks.length - 1] || session.key;
@@ -18,12 +19,7 @@ export function sessionMatchesQuery(session: SessionEntryView, query: string): b
     return true;
   }
 
-  return [
-    session.key,
-    sessionDisplayName(session),
-    session.projectRoot ?? '',
-    session.projectName ?? '',
-  ]
+  return [session.key, sessionDisplayName(session), session.projectRoot ?? '', session.projectName ?? '']
     .map(normalizeSessionSearchValue)
     .some((value) => value.includes(normalizedQuery));
 }