@nextclaw/ui 0.15.10 → 0.15.11

package/src/features/chat/features/message/utils/chat-message-execution-summary.utils.ts

@@ -0,0 +1,178 @@
+import type { ChatMessageMoreActionsViewModel } from "@nextclaw/agent-chat-ui";
+import {
+  readNcpAiExecutionMetadata,
+  type NcpAiExecutionMetadata,
+  type NcpMessage,
+} from "@nextclaw/ncp";
+
+export type ChatMessageExecutionSummaryLabels = {
+  input: string;
+  output: string;
+  tokens: string;
+  partial: string;
+  unavailable: string;
+};
+
+export type ChatMessageExecutionPresentationLabels =
+  ChatMessageExecutionSummaryLabels & {
+    moreActions: string;
+    viewMetadata: string;
+    metadataTitle: string;
+    metadataDescription: string;
+    close: string;
+    notAvailable: string;
+    fields: {
+      runId: string;
+      runtime: string;
+      model: string;
+      requestedModel: string;
+      outcome: string;
+      inputTokens: string;
+      outputTokens: string;
+      cachedInputTokens: string;
+      totalTokens: string;
+      modelCallCount: string;
+      reportedModelCallCount: string;
+      usageStatus: string;
+    };
+    outcomes: Record<NcpAiExecutionMetadata["outcome"], string>;
+    usageStatuses: Record<NcpAiExecutionMetadata["usage"]["status"], string>;
+  };
+
+export type ChatMessageExecutionPresentation = {
+  cacheKey: string;
+  summaryLabel: string;
+  moreActions: ChatMessageMoreActionsViewModel;
+};
+
+function formatTokenCount(value: number): string {
+  const unit =
+    value >= 1_000_000_000
+      ? { divisor: 1_000_000_000, suffix: "b" }
+      : value >= 1_000_000
+        ? { divisor: 1_000_000, suffix: "m" }
+        : value >= 1_000
+          ? { divisor: 1_000, suffix: "k" }
+          : null;
+  if (!unit) return String(value);
+  const scaled = Math.round((value / unit.divisor) * 10) / 10;
+  return `${scaled}${unit.suffix}`;
+}
+
+function formatTokenDetail(value: number | null, notAvailable: string): string {
+  if (value === null) return notAvailable;
+  const compact = formatTokenCount(value);
+  return value >= 1_000 ? `${compact} (${value})` : compact;
+}
+
+function buildExecutionSummary(
+  execution: NcpAiExecutionMetadata,
+  labels: ChatMessageExecutionSummaryLabels,
+): string {
+  if (execution.usage.status === "unavailable") {
+    return `${execution.model} · ${labels.unavailable}`;
+  }
+
+  const tokenSegments: string[] = [];
+  if (execution.usage.inputTokens !== null) {
+    tokenSegments.push(
+      `${formatTokenCount(execution.usage.inputTokens)} ${labels.input}`,
+    );
+  }
+  if (execution.usage.outputTokens !== null) {
+    tokenSegments.push(
+      `${formatTokenCount(execution.usage.outputTokens)} ${labels.output}`,
+    );
+  }
+  if (tokenSegments.length === 0 && execution.usage.totalTokens !== null) {
+    tokenSegments.push(
+      `${formatTokenCount(execution.usage.totalTokens)} ${labels.tokens}`,
+    );
+  }
+  if (tokenSegments.length === 0) {
+    tokenSegments.push(labels.unavailable);
+  }
+  const summary = `${execution.model} · ${tokenSegments.join(" / ")}`;
+  return execution.usage.status === "partial"
+    ? `${summary} · ${labels.partial}`
+    : summary;
+}
+
+export function buildChatMessageExecutionSummary(params: {
+  message: Pick<NcpMessage, "metadata" | "role">;
+  labels: ChatMessageExecutionSummaryLabels;
+}): string | null {
+  const { labels, message } = params;
+  if (message.role !== "assistant") return null;
+  const execution = readNcpAiExecutionMetadata(message.metadata);
+  if (!execution) return null;
+  return buildExecutionSummary(execution, labels);
+}
+
+export function buildChatMessageExecutionPresentation(params: {
+  message: Pick<NcpMessage, "metadata" | "role">;
+  labels: ChatMessageExecutionPresentationLabels;
+}): ChatMessageExecutionPresentation | null {
+  const { labels, message } = params;
+  if (message.role !== "assistant") return null;
+  const execution = readNcpAiExecutionMetadata(message.metadata);
+  if (!execution) return null;
+  const { usage } = execution;
+  const rows = [
+    { label: labels.fields.runId, value: execution.runId },
+    { label: labels.fields.runtime, value: execution.runtimeId },
+    { label: labels.fields.model, value: execution.model },
+    {
+      label: labels.fields.requestedModel,
+      value: execution.requestedModel ?? labels.notAvailable,
+    },
+    { label: labels.fields.outcome, value: labels.outcomes[execution.outcome] },
+    {
+      label: labels.fields.inputTokens,
+      value: formatTokenDetail(usage.inputTokens, labels.notAvailable),
+    },
+    {
+      label: labels.fields.outputTokens,
+      value: formatTokenDetail(usage.outputTokens, labels.notAvailable),
+    },
+    {
+      label: labels.fields.cachedInputTokens,
+      value: formatTokenDetail(usage.cachedInputTokens, labels.notAvailable),
+    },
+    {
+      label: labels.fields.totalTokens,
+      value: formatTokenDetail(usage.totalTokens, labels.notAvailable),
+    },
+    {
+      label: labels.fields.modelCallCount,
+      value: usage.modelCallCount?.toString() ?? labels.notAvailable,
+    },
+    {
+      label: labels.fields.reportedModelCallCount,
+      value: usage.reportedModelCallCount?.toString() ?? labels.notAvailable,
+    },
+    {
+      label: labels.fields.usageStatus,
+      value: labels.usageStatuses[usage.status],
+    },
+  ];
+  return {
+    cacheKey: JSON.stringify(execution),
+    summaryLabel: buildExecutionSummary(execution, labels),
+    moreActions: {
+      triggerLabel: labels.moreActions,
+      items: [
+        {
+          key: "ai-execution-metadata",
+          label: labels.viewMetadata,
+          dialog: {
+            title: labels.metadataTitle,
+            description: labels.metadataDescription,
+            closeLabel: labels.close,
+            rows,
+          },
+        },
+      ],
+    },
+  };
+}

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

@@ -1,4 +1,5 @@
 import type { ChatMessageTexts } from "@nextclaw/agent-chat-ui";
+import type { ChatMessageExecutionPresentationLabels } from "./chat-message-execution-summary.utils";
 import type { ChatMessageAdapterTexts } from "@/features/chat/features/message/utils/chat-message.utils";
 import { t } from "@/shared/lib/i18n";
 
@@ -97,6 +98,49 @@ function buildBuiltInToolStatusLabels() {
   };
 }
 
+export function buildChatMessageExecutionLabels(
+  language: string,
+): ChatMessageExecutionPresentationLabels {
+  void language;
+  return {
+    input: t("chatAiExecutionInput"),
+    output: t("chatAiExecutionOutput"),
+    tokens: t("chatAiExecutionTokens"),
+    partial: t("chatAiExecutionPartial"),
+    unavailable: t("chatAiExecutionUnavailable"),
+    moreActions: t("chatMessageMoreActions"),
+    viewMetadata: t("chatAiExecutionViewMetadata"),
+    metadataTitle: t("chatAiExecutionMetadataTitle"),
+    metadataDescription: t("chatAiExecutionMetadataDescription"),
+    close: t("chatAiExecutionMetadataClose"),
+    notAvailable: t("chatAiExecutionNotAvailable"),
+    fields: {
+      runId: t("chatAiExecutionRunId"),
+      runtime: t("chatAiExecutionRuntime"),
+      model: t("chatAiExecutionModel"),
+      requestedModel: t("chatAiExecutionRequestedModel"),
+      outcome: t("chatAiExecutionOutcome"),
+      inputTokens: t("chatAiExecutionInputTokens"),
+      outputTokens: t("chatAiExecutionOutputTokens"),
+      cachedInputTokens: t("chatAiExecutionCachedInputTokens"),
+      totalTokens: t("chatAiExecutionTotalTokens"),
+      modelCallCount: t("chatAiExecutionModelCallCount"),
+      reportedModelCallCount: t("chatAiExecutionReportedModelCallCount"),
+      usageStatus: t("chatAiExecutionUsageStatus"),
+    },
+    outcomes: {
+      completed: t("chatAiExecutionOutcomeCompleted"),
+      failed: t("chatAiExecutionOutcomeFailed"),
+      aborted: t("chatAiExecutionOutcomeAborted"),
+    },
+    usageStatuses: {
+      reported: t("chatAiExecutionUsageReported"),
+      partial: t("chatAiExecutionUsagePartial"),
+      unavailable: t("chatAiExecutionUsageUnavailable"),
+    },
+  };
+}
+
 export function buildChatMessageTexts(
   language: string,
 ): ChatMessageTexts {

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

@@ -0,0 +1,194 @@
+import type { NcpMessage } from "@nextclaw/ncp";
+import type { ChatMessageViewModel } from "@nextclaw/agent-chat-ui";
+import {
+  readContextCompactionTimeline,
+  type ContextCompactionTimelineView,
+} from "@/features/chat/features/session/utils/ncp-session-context-metadata.utils";
+
+const INHERITED_FROM_SESSION_METADATA_KEY = "inherited_from_session_id";
+
+export type ContextInheritanceTimelineView = {
+  sourceSessionId: string;
+  inheritedMessageCount: number;
+};
+
+type ContextInheritanceTimelineBoundary = ContextInheritanceTimelineView & {
+  boundaryIndex: number;
+};
+
+export type ChatTimelineItem =
+  | {
+      kind: "message";
+      key: string;
+      message: ChatMessageViewModel;
+    }
+  | {
+      kind: "compaction";
+      key: string;
+      checkpoint: ContextCompactionTimelineView;
+    }
+  | {
+      kind: "context-inheritance";
+      key: string;
+      inheritance: ContextInheritanceTimelineView;
+    }
+  | {
+      kind: "typing";
+      key: "typing";
+    }
+  | {
+      kind: "empty";
+      key: "empty";
+    };
+
+function readInheritedSourceSessionId(message: NcpMessage): string | null {
+  const value = message.metadata?.[INHERITED_FROM_SESSION_METADATA_KEY];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+export function isVisibleChatMessage(message: NcpMessage): boolean {
+  return (
+    !readContextCompactionTimeline(message) &&
+    !readInheritedSourceSessionId(message)
+  );
+}
+
+function resolveCompactionBoundaryIndex(params: {
+  rawMessages: readonly NcpMessage[];
+  visibleRawMessages: readonly NcpMessage[];
+  rawMessageId: string;
+}): number {
+  const { rawMessageId, rawMessages, visibleRawMessages } = params;
+  const physicalIndex = rawMessages.findIndex(
+    (message) => message.id === rawMessageId,
+  );
+  if (physicalIndex < 0) {
+    return visibleRawMessages.length - 1;
+  }
+  return (
+    rawMessages.slice(0, physicalIndex).filter(isVisibleChatMessage).length - 1
+  );
+}
+
+function resolveContextInheritanceBoundary(
+  messages: readonly NcpMessage[],
+): ContextInheritanceTimelineBoundary | null {
+  const boundaryIndex = messages.findIndex((message) =>
+    readInheritedSourceSessionId(message),
+  );
+  if (boundaryIndex < 0) {
+    return null;
+  }
+  const sourceSessionId = readInheritedSourceSessionId(messages[boundaryIndex]);
+  if (!sourceSessionId) {
+    return null;
+  }
+  return {
+    boundaryIndex: messages.slice(0, boundaryIndex).filter(isVisibleChatMessage)
+      .length,
+    sourceSessionId,
+    inheritedMessageCount: messages.filter(
+      (message) => readInheritedSourceSessionId(message) === sourceSessionId,
+    ).length,
+  };
+}
+
+export function buildChatMessageTimelineItems(params: {
+  rawMessages: readonly NcpMessage[];
+  messages: ChatMessageViewModel[];
+}): ChatTimelineItem[] {
+  const visibleRawMessages = params.rawMessages.filter(isVisibleChatMessage);
+  const checkpoints = params.rawMessages
+    .map((message) => ({
+      rawMessageId: message.id,
+      checkpoint: readContextCompactionTimeline(message),
+    }))
+    .filter(
+      (
+        entry,
+      ): entry is {
+        rawMessageId: string;
+        checkpoint: ContextCompactionTimelineView;
+      } => Boolean(entry.checkpoint),
+    )
+    .map((entry) => ({
+      key: `compaction:${entry.rawMessageId}`,
+      checkpoint: entry.checkpoint,
+      boundaryIndex: resolveCompactionBoundaryIndex({
+        rawMessages: params.rawMessages,
+        visibleRawMessages,
+        rawMessageId: entry.rawMessageId,
+      }),
+    }))
+    .sort((left, right) => left.boundaryIndex - right.boundaryIndex);
+  const contextInheritance = resolveContextInheritanceBoundary(
+    params.rawMessages,
+  );
+  const items: ChatTimelineItem[] = [];
+  let pendingMessages: ChatMessageViewModel[] = [];
+  let checkpointCursor = 0;
+  const flushPendingMessages = () => {
+    if (pendingMessages.length === 0) {
+      return;
+    }
+    items.push(
+      ...pendingMessages.map((message) => ({
+        kind: "message" as const,
+        key: `message:${message.id}`,
+        message,
+      })),
+    );
+    pendingMessages = [];
+  };
+
+  visibleRawMessages.forEach((rawMessage, index) => {
+    if (contextInheritance?.boundaryIndex === index) {
+      flushPendingMessages();
+      items.push({
+        kind: "context-inheritance",
+        key: `context-inheritance:${contextInheritance.sourceSessionId}`,
+        inheritance: contextInheritance,
+      });
+    }
+    const message = params.messages[index];
+    if (message) {
+      pendingMessages.push(message);
+    }
+    while (
+      checkpointCursor < checkpoints.length &&
+      checkpoints[checkpointCursor]?.boundaryIndex <= index
+    ) {
+      const currentCheckpoint = checkpoints[checkpointCursor];
+      flushPendingMessages();
+      items.push({
+        kind: "compaction",
+        key: currentCheckpoint.key,
+        checkpoint: currentCheckpoint.checkpoint,
+      });
+      checkpointCursor += 1;
+    }
+  });
+  if (contextInheritance?.boundaryIndex === visibleRawMessages.length) {
+    flushPendingMessages();
+    items.push({
+      kind: "context-inheritance",
+      key: `context-inheritance:${contextInheritance.sourceSessionId}`,
+      inheritance: contextInheritance,
+    });
+  }
+  while (checkpointCursor < checkpoints.length) {
+    const currentCheckpoint = checkpoints[checkpointCursor];
+    flushPendingMessages();
+    items.push({
+      kind: "compaction",
+      key: currentCheckpoint.key,
+      checkpoint: currentCheckpoint.checkpoint,
+    });
+    checkpointCursor += 1;
+  }
+  flushPendingMessages();
+  if (items.length === 0) {
+    items.push({ kind: "empty", key: "empty" });
+  }
+  return items;
+}

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

@@ -1,6 +1,7 @@
 import { adaptChatMessagePart } from "./chat-message-part.utils";
 import type { ChatInlineTokenSource } from "@/features/chat/features/input/utils/chat-inline-token.utils";
 import type {
+  ChatMessageMoreActionsViewModel,
   ChatMessageRole,
   ChatMessageViewModel,
 } from "@nextclaw/agent-chat-ui";
@@ -23,6 +24,8 @@ export type ChatMessageSource = {
     status?: string;
     inlineTokens?: ChatInlineTokenSource[];
     processSummary?: ChatMessageProcessSummarySource;
+    executionSummaryLabel?: string;
+    moreActions?: ChatMessageMoreActionsViewModel;
   };
   parts: ChatMessagePartSource[];
 };
@@ -82,6 +85,8 @@ export function adaptChatMessage(
     timestampLabel: params.formatTimestamp(resolveMessageTimestamp(message)),
     status: message.meta?.status,
     processSummary: message.meta?.processSummary,
+    executionSummaryLabel: message.meta?.executionSummaryLabel,
+    moreActions: message.meta?.moreActions,
     parts: message.parts
       .map((part) =>
         adaptChatMessagePart({