@nextclaw/ui 0.20.0-beta.0 → 0.20.1

package/src/features/chat/features/message/utils/__tests__/chat-message-file-operation.utils.test.ts

@@ -154,6 +154,12 @@ it("uses structured edit-file result line numbers after the tool finishes", () =
       },
     },
   });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
 });
 
 it("builds write-file previews from partial native args before the JSON is complete", () => {
@@ -261,6 +267,12 @@ it("keeps completed write-file cards in preview mode instead of falling back to
       output: "Wrote 3906 bytes to games/snake.html",
     },
   });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
 });
 
 it("renders codex file_change results as structured diff previews", () => {
@@ -337,4 +349,178 @@ it("renders codex file_change results as structured diff previews", () => {
       },
     },
   });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
+});
+
+it("uses a read-file preview as the single visible representation of file content", () => {
+  const adapted = adapt([
+    {
+      id: "assistant-read-result",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "read-result-1",
+            toolName: "read_file",
+            args: JSON.stringify({ path: "docs/readme.md" }),
+            parsedArgs: { path: "docs/readme.md" },
+            result: "1: first line\n2: second line\n</content>",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "read_file",
+      summary: "docs/readme.md",
+      fileOperation: {
+        blocks: [
+          {
+            display: "preview",
+            path: "docs/readme.md",
+            lines: expect.arrayContaining([
+              expect.objectContaining({ text: "1: first line" }),
+              expect.objectContaining({ text: "2: second line" }),
+            ]),
+          },
+        ],
+      },
+    },
+  });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
+});
+
+it("uses an apply-patch preview as the single visible representation of the patch", () => {
+  const patch = [
+    "*** Begin Patch",
+    "*** Update File: src/app.ts",
+    "@@",
+    "-const color = 'red';",
+    "+const color = 'blue';",
+    "*** End Patch",
+  ].join("\n");
+  const adapted = adapt([
+    {
+      id: "assistant-apply-patch-result",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "apply-patch-result-1",
+            toolName: "apply_patch",
+            args: patch,
+            result: "Done!",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "apply_patch",
+      summary: "src/app.ts",
+      fileOperation: {
+        blocks: [
+          {
+            path: "src/app.ts",
+            lines: [
+              expect.objectContaining({ kind: "remove", text: "const color = 'red';" }),
+              expect.objectContaining({ kind: "add", text: "const color = 'blue';" }),
+            ],
+          },
+        ],
+      },
+    },
+  });
+  expect(adapted[0]?.parts[0]).not.toMatchObject({
+    type: "tool-card",
+    card: {
+      outputData: expect.anything(),
+    },
+  });
+});
+
+it("keeps raw file-tool results when no structured preview can be built", () => {
+  const adapted = adapt([
+    {
+      id: "assistant-read-result-without-path",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "read-result-without-path-1",
+            toolName: "read_file",
+            result: "raw file content",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "read_file",
+      outputData: "raw file content",
+    },
+  });
+});
+
+it("keeps file-tool errors visible even when input can build a preview", () => {
+  const adapted = adapt([
+    {
+      id: "assistant-write-error",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-invocation",
+          toolInvocation: {
+            status: ToolInvocationStatus.RESULT,
+            toolCallId: "write-error-1",
+            toolName: "write_file",
+            parsedArgs: {
+              path: "src/app.ts",
+              content: "const color = 'blue';",
+            },
+            error: "Permission denied",
+            result: "write failed",
+          },
+        },
+      ],
+    },
+  ] as unknown as ChatMessageSource[]);
+
+  expect(adapted[0]?.parts[0]).toMatchObject({
+    type: "tool-card",
+    card: {
+      toolName: "write_file",
+      statusTone: "error",
+      output: "Permission denied",
+      outputData: "write failed",
+      fileOperation: {
+        blocks: [expect.objectContaining({ path: "src/app.ts" })],
+      },
+    },
+  });
 });

package/src/features/chat/features/message/utils/__tests__/chat-message-texts.utils.test.ts

@@ -1,6 +1,7 @@
 import { expect, it, vi } from "vitest";
 import {
   buildChatMessageExecutionLabels,
+  buildChatMessageTriggerLabels,
   buildChatMessageTexts,
 } from "@/features/chat/features/message/utils/chat-message-texts.utils";
 
@@ -25,6 +26,14 @@ it("provides localized status keys for built-in tool categories", () => {
   });
 });
 
+it("provides localized labels for run trigger details", () => {
+  expect(buildChatMessageTriggerLabels("zh")).toMatchObject({
+    viewTrigger: "chatRunTriggerView",
+    fields: { sourceModel: "chatRunTriggerSourceModel" },
+    actors: { agent: "chatRunTriggerActorAgent" },
+  });
+});
+
 it("provides localized labels for the AI execution metadata action", () => {
   expect(buildChatMessageExecutionLabels("zh")).toMatchObject({
     moreActions: "chatMessageMoreActions",

package/src/features/chat/features/message/utils/__tests__/chat-message-timeline.utils.test.ts

@@ -125,7 +125,9 @@ describe("chat message timeline visibility", () => {
     })).toBe(false);
     expect(isVisibleChatMessage(visibleMessage)).toBe(true);
   });
+});
 
+describe("chat message continuation projection", () => {
   it("projects continued assistant output into the interrupted message", () => {
     const messages = projectVisibleChatMessages([
       {
@@ -253,3 +255,72 @@ describe("chat message timeline visibility", () => {
     ]).map((message) => message.id)).toEqual(["user-1", "assistant-1"]);
   });
 });
+
+describe("child session timeline visibility", () => {
+  it("does not repeat inherited compaction markers", () => {
+    const childMessage = {
+      ...visibleMessage,
+      id: "child-user",
+      role: "user" as const,
+      timestamp: "2026-08-24T15:50:23.415Z",
+      parts: [{ type: "text" as const, text: "child request" }],
+    };
+    const inheritedCompactions = Array.from({ length: 5 }, (_, index) => ({
+      ...visibleMessage,
+      id: `child-session:inherited:${index + 1}`,
+      role: "service" as const,
+      timestamp: `2026-08-24T15:0${index}:00.000Z`,
+      parts: [{ type: "text" as const, text: "Earlier context was auto-compacted" }],
+      metadata: {
+        inherited_from_session_id: "parent-session",
+        inherited_from_message_id: `parent-compaction-${index + 1}`,
+        nextclaw_timeline_kind: "context_compaction",
+        checkpoint: {
+          id: "parent-checkpoint",
+          status: "compressed",
+          summary: "Compressed parent context",
+          coveredMessageCount: (index + 1) * 100,
+          coveredSessionMessageCount: (index + 1) * 100,
+          originalEstimatedTokens: 76_000,
+          projectedEstimatedTokens: 51_000,
+          createdAt: "2026-08-24T15:00:00.000Z",
+          updatedAt: `2026-08-24T15:0${index}:00.000Z`,
+        },
+      },
+    } satisfies NcpMessage));
+    const items = buildChatMessageTimelineItems({
+      rawMessages: [...inheritedCompactions, childMessage],
+      messages: [{ id: childMessage.id } as never],
+    });
+
+    expect(items.map((item) => item.kind)).toEqual([
+      "context-inheritance",
+      "message",
+    ]);
+
+    const childCompaction = {
+      ...inheritedCompactions[0]!,
+      id: "child-compaction",
+      metadata: {
+        ...inheritedCompactions[0]!.metadata,
+        inherited_from_session_id: undefined,
+        inherited_from_message_id: undefined,
+      },
+    } satisfies NcpMessage;
+    const childAssistant = {
+      ...visibleMessage,
+      id: "child-assistant",
+      timestamp: "2026-08-24T15:51:00.000Z",
+    };
+
+    expect(buildChatMessageTimelineItems({
+      rawMessages: [...inheritedCompactions, childMessage, childCompaction, childAssistant],
+      messages: [{ id: childMessage.id } as never, { id: childAssistant.id } as never],
+    }).map((item) => item.kind)).toEqual([
+      "context-inheritance",
+      "message",
+      "compaction",
+      "message",
+    ]);
+  });
+});

package/src/features/chat/features/message/utils/__tests__/chat-message-trigger-details.utils.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildChatMessageTriggerDetails,
+  mergeChatMessageMoreActions,
+} from "@/features/chat/features/message/utils/chat-message-trigger-details.utils";
+
+const labels = {
+  moreActions: "More actions",
+  viewTrigger: "View trigger details",
+  title: "Run trigger",
+  description: "Why this run started.",
+  close: "Close",
+  notAvailable: "Not available",
+  fields: {
+    actor: "Actor",
+    source: "Source",
+    triggeredAt: "Triggered at",
+    targetRunId: "Target run",
+    sourceSessionId: "Source session",
+    sourceMessageId: "Source message",
+    sourceRunId: "Source run",
+    sourceToolCallId: "Source tool call",
+    sourceRequestId: "Source request",
+    sourceModel: "Source model",
+    targetModel: "Run model",
+    sourceContext: "Source context",
+    raw: "Raw metadata",
+  },
+  actors: {
+    human: "Human",
+    agent: "Agent",
+    automation: "Automation",
+    system: "System",
+  },
+};
+
+describe("buildChatMessageTriggerDetails", () => {
+  it("projects structured and raw provenance rows", () => {
+    const details = buildChatMessageTriggerDetails({
+      labels,
+      message: {
+        metadata: {
+          run_trigger: {
+            version: 1,
+            actor: "agent",
+            source: "sessions_spawn",
+            triggeredAt: "2026-08-25T00:00:00.000Z",
+            targetRunId: "target-run",
+            sourceSessionId: "source-session",
+            sourceMessageId: "source-message",
+            sourceRunId: "source-run",
+            sourceToolCallId: "source-tool-call",
+            sourceRequestId: "source-request",
+            sourceModel: "openai/gpt-5.6",
+            sourceContext: { channel: "telegram", chatId: "chat-1" },
+          },
+          run_spec: {
+            runId: "target-run",
+            model: "minimax/MiniMax-M3",
+          },
+        },
+      },
+    });
+
+    expect(details?.triggerLabel).toBe("More actions");
+    expect(details?.items[0]?.dialog.rows).toEqual(expect.arrayContaining([
+      { label: "Actor", value: "Agent" },
+      { label: "Source model", value: "openai/gpt-5.6" },
+      { label: "Run model", value: "minimax/MiniMax-M3" },
+      { label: "Source context", value: expect.stringContaining("telegram") },
+      expect.objectContaining({ label: "Raw metadata" }),
+    ]));
+    expect(details?.items[0]?.dialog.rows.find(
+      (row) => row.label === "Raw metadata",
+    )?.value).toContain("run_spec");
+  });
+
+  it("does not create an empty action for legacy messages", () => {
+    expect(buildChatMessageTriggerDetails({ labels, message: {} })).toBeNull();
+  });
+
+  it("keeps trigger-only messages actionable and merges assistant details in order", () => {
+    const triggerDetails = buildChatMessageTriggerDetails({
+      labels,
+      message: {
+        metadata: {
+          run_trigger: {
+            version: 1,
+            actor: "human",
+            source: "ui-http",
+            triggeredAt: "2026-08-25T00:00:00.000Z",
+            targetRunId: "run-1",
+          },
+        },
+      },
+    });
+    expect(mergeChatMessageMoreActions(null, triggerDetails)?.items.map(
+      (item) => item.key,
+    )).toEqual(["run-trigger-metadata"]);
+    expect(mergeChatMessageMoreActions({
+      triggerLabel: "More actions",
+      items: [{
+        key: "ai-execution-metadata",
+        label: "View run metadata",
+        dialog: { title: "Run", closeLabel: "Close", rows: [] },
+      }],
+    }, triggerDetails)?.items.map((item) => item.key)).toEqual([
+      "ai-execution-metadata",
+      "run-trigger-metadata",
+    ]);
+  });
+});

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

@@ -174,7 +174,7 @@ function buildToolInvocationPart(
     detail,
     inputData: fileOperationCardData ? undefined : invocation.parsedArgs ?? invocation.args,
     text: shouldShowRawResult && rawResult ? rawResult : undefined,
-    outputData: invocation.result,
+    outputData: shouldShowRawResult ? invocation.result : undefined,
     callId: invocation.toolCallId || undefined,
     toolCallId: invocation.toolCallId || undefined,
     ...(invocation.execution ? { execution: invocation.execution } : {}),

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

@@ -1,5 +1,6 @@
 import type { ChatMessageTexts } from "@nextclaw/agent-chat-ui";
 import type { ChatMessageExecutionPresentationLabels } from "./chat-message-execution-summary.utils";
+import type { ChatMessageTriggerDetailsLabels } from "./chat-message-trigger-details.utils";
 import type { ChatMessageAdapterTexts } from "@/features/chat/features/message/utils/chat-message.utils";
 import { t } from "@/shared/lib/i18n";
 
@@ -140,6 +141,41 @@ export function buildChatMessageExecutionLabels(
   };
 }
 
+export function buildChatMessageTriggerLabels(
+  language: string,
+): ChatMessageTriggerDetailsLabels {
+  void language;
+  return {
+    moreActions: t("chatMessageMoreActions"),
+    viewTrigger: t("chatRunTriggerView"),
+    title: t("chatRunTriggerTitle"),
+    description: t("chatRunTriggerDescription"),
+    close: t("chatRunTriggerClose"),
+    notAvailable: t("chatAiExecutionNotAvailable"),
+    fields: {
+      actor: t("chatRunTriggerActor"),
+      source: t("chatRunTriggerSource"),
+      triggeredAt: t("chatRunTriggerTime"),
+      targetRunId: t("chatRunTriggerTargetRun"),
+      sourceSessionId: t("chatRunTriggerSourceSession"),
+      sourceMessageId: t("chatRunTriggerSourceMessage"),
+      sourceRunId: t("chatRunTriggerSourceRun"),
+      sourceToolCallId: t("chatRunTriggerSourceToolCall"),
+      sourceRequestId: t("chatRunTriggerSourceRequest"),
+      sourceModel: t("chatRunTriggerSourceModel"),
+      targetModel: t("chatRunTriggerTargetModel"),
+      sourceContext: t("chatRunTriggerSourceContext"),
+      raw: t("chatRunTriggerRaw"),
+    },
+    actors: {
+      human: t("chatRunTriggerActorHuman"),
+      agent: t("chatRunTriggerActorAgent"),
+      automation: t("chatRunTriggerActorAutomation"),
+      system: t("chatRunTriggerActorSystem"),
+    },
+  };
+}
+
 export function buildChatMessageTexts(
   language: string,
 ): ChatMessageTexts {

package/src/features/chat/features/message/utils/chat-message-trigger-details.utils.ts

@@ -0,0 +1,118 @@
+import type { ChatMessageMoreActionsViewModel } from "@nextclaw/agent-chat-ui";
+import {
+  readNcpAiExecutionMetadata,
+  readNcpRunTriggerMetadata,
+  type NcpMessage,
+  type NcpRunTriggerActor,
+} from "@nextclaw/ncp";
+
+export type ChatMessageTriggerDetailsLabels = {
+  moreActions: string;
+  viewTrigger: string;
+  title: string;
+  description: string;
+  close: string;
+  notAvailable: string;
+  fields: {
+    actor: string;
+    source: string;
+    triggeredAt: string;
+    targetRunId: string;
+    sourceSessionId: string;
+    sourceMessageId: string;
+    sourceRunId: string;
+    sourceToolCallId: string;
+    sourceRequestId: string;
+    sourceModel: string;
+    targetModel: string;
+    sourceContext: string;
+    raw: string;
+  };
+  actors: Record<NcpRunTriggerActor, string>;
+};
+
+export function mergeChatMessageMoreActions(
+  ...candidates: Array<ChatMessageMoreActionsViewModel | null | undefined>
+): ChatMessageMoreActionsViewModel | undefined {
+  const available = candidates.filter(
+    (candidate): candidate is ChatMessageMoreActionsViewModel =>
+      Boolean(candidate?.items.length),
+  );
+  if (available.length === 0) return undefined;
+  return {
+    triggerLabel: available[0]!.triggerLabel,
+    items: available.flatMap((candidate) => candidate.items),
+  };
+}
+
+function readRunSpec(
+  metadata: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | null {
+  const value = metadata?.run_spec;
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function readTargetModel(
+  metadata: Record<string, unknown> | null | undefined,
+): string | undefined {
+  const runSpecModel = readRunSpec(metadata)?.model;
+  if (typeof runSpecModel === "string" && runSpecModel.trim()) {
+    return runSpecModel.trim();
+  }
+  return readNcpAiExecutionMetadata(metadata)?.model;
+}
+
+export function buildChatMessageTriggerDetails(params: {
+  labels: ChatMessageTriggerDetailsLabels;
+  message: Pick<NcpMessage, "metadata">;
+}): ChatMessageMoreActionsViewModel | null {
+  const { labels, message } = params;
+  const trigger = readNcpRunTriggerMetadata(message.metadata);
+  if (!trigger) return null;
+  const { fields } = labels;
+  const runSpec = readRunSpec(message.metadata);
+  const rows = [
+    { label: fields.actor, value: labels.actors[trigger.actor] },
+    { label: fields.source, value: trigger.source },
+    { label: fields.triggeredAt, value: trigger.triggeredAt },
+    { label: fields.targetRunId, value: trigger.targetRunId },
+    { label: fields.sourceSessionId, value: trigger.sourceSessionId },
+    { label: fields.sourceMessageId, value: trigger.sourceMessageId },
+    { label: fields.sourceRunId, value: trigger.sourceRunId },
+    { label: fields.sourceToolCallId, value: trigger.sourceToolCallId },
+    { label: fields.sourceRequestId, value: trigger.sourceRequestId },
+    { label: fields.sourceModel, value: trigger.sourceModel },
+    { label: fields.targetModel, value: readTargetModel(message.metadata) },
+    {
+      label: fields.sourceContext,
+      value: trigger.sourceContext
+        ? JSON.stringify(trigger.sourceContext, null, 2)
+        : undefined,
+    },
+  ].map((row) => ({
+    label: row.label,
+    value: row.value ?? labels.notAvailable,
+  }));
+  rows.push({
+    label: fields.raw,
+    value: JSON.stringify({
+      run_trigger: trigger,
+      ...(runSpec ? { run_spec: runSpec } : {}),
+    }, null, 2),
+  });
+  return {
+    triggerLabel: labels.moreActions,
+    items: [{
+      key: "run-trigger-metadata",
+      label: labels.viewTrigger,
+      dialog: {
+        title: labels.title,
+        description: labels.description,
+        closeLabel: labels.close,
+        rows,
+      },
+    }],
+  };
+}