@springbrand/message-panel 0.1.3-alpha.3 → 0.1.3-alpha.30

package/cloud-os/chat/transcript-model.ts

@@ -5,6 +5,7 @@ import {
   buildToolCallGroups,
   toCloudOsToolCall,
   type CloudOsToolCall,
+  type CloudOsToolKind,
   type ToolCallGroup,
 } from "./tool-presentation";
 
@@ -26,9 +27,17 @@ export interface CloudOsMessageMetadata extends UnknownRecord {
   createdAt?: number;
   error?: string;
   interruptedByUser?: boolean;
+  turnId?: string;
   turnDurationMs?: number;
   turnStartedAt?: number;
   turnStatus?: string;
+  requestedCapabilities?: unknown;
+}
+
+export interface CloudOsRequestedCapability {
+  kind: "skill" | "tool" | "plan";
+  name: string;
+  label: string;
 }
 
 export interface CloudOsAttachment {
@@ -37,13 +46,38 @@ export interface CloudOsAttachment {
   mediaType?: string;
 }
 
+interface CloudOsActionPresentationFile {
+  type: "file";
+  url: string;
+  mediaType?: string;
+}
+
+interface CloudOsActionProduces {
+  type: "image" | "audio" | "video" | "document" | "archive" | "data" | "other";
+  mediaType?: string;
+}
+
+export interface CloudOsActionPresentation {
+  type: "action-execution";
+  executionId: string;
+  state: "running" | "ready" | "failed" | "outcome_unknown";
+  failureCode?: "insufficient_credits";
+  produces?: CloudOsActionProduces;
+  content: CloudOsActionPresentationFile[];
+}
+
 export interface PlanStep {
   text: string;
   status: "pending" | "in_progress" | "done";
 }
 
 export type AssistantBlock =
-  | { kind: "reasoning"; key: string; text: string }
+  | {
+      kind: "reasoning";
+      key: string;
+      text: string;
+      running: boolean;
+    }
   | { kind: "text"; key: string; text: string }
   | { kind: "toolGroup"; key: string; group: ToolCallGroup }
   | { kind: "plan"; key: string; steps: PlanStep[]; running: boolean }
@@ -58,7 +92,19 @@ export type AssistantBlock =
   | { kind: "approval"; key: string; call: CloudOsToolCall; approvalId: string }
   | { kind: "parallel"; key: string; label: string; tools: ParallelTool[] }
   | { kind: "subagents"; key: string; agents: SubAgentView[] }
-  | { kind: "image"; key: string; src: string; alt: string }
+  | {
+      kind: "image";
+      key: string;
+      src: string;
+      alt: string;
+      mediaType?: string;
+    }
+  | { kind: "file"; key: string; file: CloudOsAttachment }
+  | {
+      kind: "actionPresentation";
+      key: string;
+      presentation: CloudOsActionPresentation;
+    }
   | { kind: "error"; key: string; title: string; body?: string };
 
 export interface ParallelTool {
@@ -80,6 +126,7 @@ export type CloudOsEntry =
       messageId: string;
       text: string;
       attachments: CloudOsAttachment[];
+      capabilities: CloudOsRequestedCapability[];
       authorName?: string;
       timestamp?: number;
     }
@@ -97,8 +144,10 @@ export type CloudOsEntry =
       type: "assistant";
       key: string;
       messageId: string;
+      turnId?: string;
       blocks: AssistantBlock[];
       copyText: string;
+      durationMs?: number;
       timestamp?: number;
       terminal?: { kind: "interrupted" | "error"; title: string; body?: string };
     };
@@ -122,10 +171,39 @@ function nonNegativeNumber(value: unknown): number | undefined {
     : undefined;
 }
 
+function nonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
 export function cloudOsMetadata(message: UIMessage): CloudOsMessageMetadata {
   return recordOf(message.metadata) as CloudOsMessageMetadata;
 }
 
+export function requestedCapabilitiesOf(
+  metadata: CloudOsMessageMetadata,
+): CloudOsRequestedCapability[] {
+  if (!Array.isArray(metadata.requestedCapabilities)) return [];
+  const seen = new Set<string>();
+  return metadata.requestedCapabilities.flatMap((value) => {
+    const capability = recordOf(value);
+    if (
+      (capability.kind !== "skill" && capability.kind !== "tool" && capability.kind !== "plan") ||
+      typeof capability.name !== "string" ||
+      !capability.name.trim() ||
+      typeof capability.label !== "string" ||
+      !capability.label.trim()
+    ) return [];
+    const key = `${capability.kind}:${capability.name}`;
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [{
+      kind: capability.kind,
+      name: capability.name,
+      label: capability.label,
+    }];
+  });
+}
+
 export function messageText(message: UIMessage): string {
   return message.parts
     .filter(
@@ -151,6 +229,54 @@ export function formatFullTimestamp(timestamp: number): string {
   });
 }
 
+function turnDuration(metadata: CloudOsMessageMetadata): number | undefined {
+  const explicit = nonNegativeNumber(metadata.turnDurationMs);
+  if (explicit !== undefined) return explicit;
+  const startedAt = nonNegativeNumber(metadata.turnStartedAt);
+  const completedAt = nonNegativeNumber(metadata.completedAt);
+  return startedAt !== undefined && completedAt !== undefined
+    ? Math.max(0, completedAt - startedAt)
+    : undefined;
+}
+
+function isWorkBlock(block: AssistantBlock): boolean {
+  return (
+    block.kind === "reasoning" ||
+    block.kind === "toolGroup" ||
+    block.kind === "plan" ||
+    block.kind === "parallel" ||
+    block.kind === "subagents"
+  );
+}
+
+/**
+ * 把一条 assistant 消息拆成可折叠的工作过程与始终可见的最终内容。
+ * 最后一段工作之前的 text 是过程旁白；最后一次工作之后的 text 才是正文。
+ */
+export function partitionAssistantBlocks(blocks: readonly AssistantBlock[]): {
+  work: AssistantBlock[];
+  content: AssistantBlock[];
+} {
+  let lastWorkIndex = -1;
+  blocks.forEach((block, index) => {
+    if (isWorkBlock(block)) lastWorkIndex = index;
+  });
+
+  const work: AssistantBlock[] = [];
+  const content: AssistantBlock[] = [];
+  blocks.forEach((block, index) => {
+    if (
+      isWorkBlock(block) ||
+      (block.kind === "text" && index < lastWorkIndex)
+    ) {
+      work.push(block);
+    } else {
+      content.push(block);
+    }
+  });
+  return { work, content };
+}
+
 function toolNameOf(part: unknown): string | null {
   const type = String(recordOf(part).type ?? "");
   if (type === "dynamic-tool") {
@@ -198,6 +324,74 @@ function normalizeStatus(value: unknown): ParallelTool["status"] {
   return "pending";
 }
 
+function actionPresentationOf(value: unknown): CloudOsActionPresentation | null {
+  const presentation = recordOf(recordOf(value).presentation);
+  const state = presentation.state;
+  if (
+    presentation.type !== "action-execution" ||
+    typeof presentation.executionId !== "string" ||
+    !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+      presentation.executionId,
+    ) ||
+    (state !== "running" &&
+      state !== "ready" &&
+      state !== "failed" &&
+      state !== "outcome_unknown") ||
+    !Array.isArray(presentation.content)
+  ) return null;
+
+  let produces: CloudOsActionProduces | undefined;
+  if (presentation.produces !== undefined) {
+    const hint = recordOf(presentation.produces);
+    if (
+      !["image", "audio", "video", "document", "archive", "data", "other"].includes(
+        String(hint.type),
+      ) ||
+      (hint.mediaType !== undefined &&
+        (typeof hint.mediaType !== "string" || !/^[^\s/]+\/[^\s/]+$/.test(hint.mediaType)))
+    ) return null;
+    produces = {
+      type: hint.type as CloudOsActionProduces["type"],
+      ...(hint.mediaType === undefined ? {} : { mediaType: hint.mediaType as string }),
+    };
+  }
+  if (state !== "running" && produces) return null;
+
+  const content: CloudOsActionPresentationFile[] = [];
+  for (const value of presentation.content) {
+    const file = recordOf(value);
+    if (file.type !== "file" || typeof file.url !== "string") return null;
+    try {
+      if (new URL(file.url).protocol !== "https:") return null;
+    } catch {
+      return null;
+    }
+    if (
+      file.mediaType !== undefined &&
+      (typeof file.mediaType !== "string" || !file.mediaType.trim())
+    ) return null;
+    content.push({
+      type: "file" as const,
+      url: file.url,
+      ...(file.mediaType !== undefined
+        ? { mediaType: file.mediaType }
+        : {}),
+    });
+  }
+  if (state !== "ready" && content.length > 0) return null;
+
+  return {
+    type: "action-execution",
+    executionId: presentation.executionId,
+    state,
+    ...(state === "failed" && presentation.failureCode === "insufficient_credits"
+      ? { failureCode: presentation.failureCode }
+      : {}),
+    ...(produces ? { produces } : {}),
+    content,
+  };
+}
+
 // ── 独立消息(非 assistant 回合)判定 ────────────────────────────────────────
 
 function standaloneEntry(
@@ -285,7 +479,12 @@ function assistantBlocks(
       const text = String(record.text ?? "").trim();
       if (!text || !showThinkingTraces) return;
       flush();
-      blocks.push({ kind: "reasoning", key, text });
+      blocks.push({
+        kind: "reasoning",
+        key,
+        text,
+        running: record.state === "streaming",
+      });
       return;
     }
 
@@ -343,15 +542,32 @@ function assistantBlocks(
       const data = dataOf(part);
       const src = String(data.src ?? data.url ?? record.url ?? "");
       const mediaType = String(record.mediaType ?? data.mediaType ?? "");
-      if (src && (dataKind === "image" || mediaType.startsWith("image/"))) {
-        flush();
+      if (!src) return;
+
+      flush();
+      const filename = String(
+        data.alt ?? data.filename ?? record.filename ?? "Attachment",
+      );
+      if (dataKind === "image" || mediaType.startsWith("image/")) {
         blocks.push({
           kind: "image",
           key,
           src,
-          alt: String(data.alt ?? data.filename ?? record.filename ?? "Image"),
+          alt: filename,
+          mediaType: mediaType || undefined,
         });
+        return;
       }
+
+      blocks.push({
+        kind: "file",
+        key,
+        file: {
+          url: src,
+          filename,
+          mediaType: mediaType || undefined,
+        },
+      });
       return;
     }
 
@@ -359,6 +575,13 @@ function assistantBlocks(
     if (toolName === null) return;
 
     const call = toCloudOsToolCall(part, key, isActive);
+    const presentation = actionPresentationOf(call.output);
+    if (presentation) {
+      pendingCalls.push(call);
+      flush();
+      blocks.push({ kind: "actionPresentation", key, presentation });
+      return;
+    }
 
     if (call.awaitingApproval) {
       const approvalId = approvalIdOf(part);
@@ -379,6 +602,7 @@ function assistantBlocks(
     }
 
     if (call.kind === "ask-user") {
+      if (call.failed) return;
       flush();
       blocks.push({
         kind: "askUser",
@@ -455,6 +679,9 @@ export function buildCloudOsEntries({
     }
     return -1;
   })();
+  const activeTurnId = isActive && lastAssistantIndex >= 0
+    ? nonEmptyString(cloudOsMetadata(messages[lastAssistantIndex]!).turnId)
+    : undefined;
 
   messages.forEach((message, index) => {
     if (message.role === "system") return;
@@ -488,6 +715,7 @@ export function buildCloudOsEntries({
         messageId: message.id,
         text,
         attachments,
+        capabilities: requestedCapabilitiesOf(metadata),
         authorName: metadata.authorDisplayName,
         timestamp:
           nonNegativeNumber(metadata.createdAt) ??
@@ -508,8 +736,10 @@ export function buildCloudOsEntries({
       type: "assistant",
       key: `assistant-${message.id}-${index}`,
       messageId: message.id,
+      turnId: nonEmptyString(metadata.turnId),
       blocks,
       copyText: messageText(message),
+      durationMs: turnDuration(metadata),
       timestamp:
         nonNegativeNumber(metadata.completedAt) ??
         nonNegativeNumber(metadata.createdAt),
@@ -517,7 +747,100 @@ export function buildCloudOsEntries({
     });
   });
 
-  return dropSupersededPlans(entries);
+  return aggregateCompletedTurnWork(
+    dropSupersededActionPresentations(dropSupersededPlans(entries)),
+    activeTurnId,
+  );
+}
+
+/** Collapse every completed Turn's assistant segments into one display entry. */
+function aggregateCompletedTurnWork(
+  entries: CloudOsEntry[],
+  activeTurnId: string | undefined,
+): CloudOsEntry[] {
+  const indexesByTurn = new Map<string, number[]>();
+  entries.forEach((entry, index) => {
+    if (entry.type !== "assistant" || !entry.turnId) return;
+    const indexes = indexesByTurn.get(entry.turnId) ?? [];
+    indexes.push(index);
+    indexesByTurn.set(entry.turnId, indexes);
+  });
+
+  const hidden = new Set<number>();
+  const replacements = new Map<number, CloudOsEntry>();
+  for (const [turnId, indexes] of indexesByTurn) {
+    if (turnId === activeTurnId || indexes.length < 2) continue;
+    const assistantEntries = indexes.map(
+      (index) => entries[index] as Extract<CloudOsEntry, { type: "assistant" }>,
+    );
+    const anchorIndex = indexes[indexes.length - 1]!;
+    const anchor = assistantEntries[assistantEntries.length - 1]!;
+    const durations = assistantEntries.flatMap((entry) =>
+      entry.durationMs === undefined ? [] : [entry.durationMs]
+    );
+    const timestamps = assistantEntries.flatMap((entry) =>
+      entry.timestamp === undefined ? [] : [entry.timestamp]
+    );
+
+    indexes.slice(0, -1).forEach((index) => hidden.add(index));
+    replacements.set(anchorIndex, {
+      ...anchor,
+      key: `assistant-turn-${turnId}`,
+      blocks: assistantEntries.flatMap((entry) => entry.blocks),
+      ...(durations.length > 0 ? { durationMs: Math.max(...durations) } : {}),
+      ...(timestamps.length > 0 ? { timestamp: Math.max(...timestamps) } : {}),
+    });
+  }
+
+  return entries.flatMap((entry, index) =>
+    hidden.has(index) ? [] : [replacements.get(index) ?? entry]
+  );
+}
+
+function dropSupersededActionPresentations(entries: CloudOsEntry[]): CloudOsEntry[] {
+  const snapshots = new Map<string, {
+    entryIndex: number;
+    blockIndex: number;
+    presentation: CloudOsActionPresentation;
+  }>();
+  entries.forEach((entry, entryIndex) => {
+    if (entry.type !== "assistant") return;
+    entry.blocks.forEach((block, blockIndex) => {
+      if (block.kind !== "actionPresentation") return;
+      const current = snapshots.get(block.presentation.executionId);
+      if (!current) {
+        snapshots.set(block.presentation.executionId, {
+          entryIndex,
+          blockIndex,
+          presentation: block.presentation,
+        });
+        return;
+      }
+      if (block.presentation.state !== "running") {
+        current.presentation = block.presentation;
+      } else if (current.presentation.state === "running") {
+        current.presentation = {
+          ...block.presentation,
+          produces: block.presentation.produces ?? current.presentation.produces,
+        };
+      }
+    });
+  });
+
+  return entries.map((entry, entryIndex) =>
+    entry.type !== "assistant"
+      ? entry
+      : {
+          ...entry,
+          blocks: entry.blocks.flatMap<AssistantBlock>((block, blockIndex) => {
+            if (block.kind !== "actionPresentation") return [block];
+            const snapshot = snapshots.get(block.presentation.executionId)!;
+            return snapshot.entryIndex === entryIndex && snapshot.blockIndex === blockIndex
+              ? [{ ...block, presentation: snapshot.presentation }]
+              : [];
+          }),
+        }
+  );
 }
 
 /**
@@ -562,75 +885,124 @@ export interface CloudOsActivity {
   label: string;
 }
 
-/**
- * 尾巴是否**自己会说话** —— 有它在动,就不该再挂一个活动指示器。
- *
- * 正在流的正文/思考、还在跑的工具组或计划,以及一张**还等着你作答**的
- * `ask_user` 卡都算:前三者自身就有动效,最后一个等的是人不是模型,这时候
- * 显示「Thinking」是在撒谎。
- */
-function isLiveBlock(block: AssistantBlock): boolean {
+const SEARCHING_TOOL_KINDS: ReadonlySet<CloudOsToolKind> = new Set([
+  "read",
+  "glob",
+  "grep",
+  "list",
+  "web-search",
+  "web-fetch",
+]);
+const SHAPING_TOOL_KINDS: ReadonlySet<CloudOsToolKind> = new Set([
+  "write",
+  "edit",
+  "tasks",
+  "create-agent",
+  "publish-extension",
+]);
+
+function activityForTool(call: CloudOsToolCall | undefined): CloudOsActivity {
+  if (!call) return { state: "working", label: "Working…" };
+  const name = call.toolName.replaceAll("-", "_").toLowerCase();
+  if (call.kind === "agent") {
+    return {
+      state: "weaving",
+      label: call.running ? "Coordinating agents…" : "Combining results…",
+    };
+  }
+  if (SEARCHING_TOOL_KINDS.has(call.kind)) {
+    return {
+      state: "searching",
+      label: call.running ? "Searching…" : "Reading results…",
+    };
+  }
+  if (SHAPING_TOOL_KINDS.has(call.kind)) {
+    return { state: "shaping", label: "Shaping result…" };
+  }
+  if (call.kind === "skill" || name === "activate_skill") {
+    return { state: "working", label: "Loading skill…" };
+  }
+  if (name === "run_skill_script") {
+    return { state: "working", label: "Running skill…" };
+  }
+  return { state: "working", label: "Working…" };
+}
+
+function activityForTail(block: AssistantBlock | undefined): CloudOsActivity {
+  if (!block) return { state: "solving", label: "Thinking…" };
   switch (block.kind) {
-    case "text":
     case "reasoning":
-      return true;
+      return { state: "solving", label: "Reasoning…" };
+    case "text":
+    case "suggestions":
+      return { state: "composing", label: "Composing answer…" };
     case "toolGroup":
-      return block.group.hasRunning;
+      return activityForTool(block.group.calls.at(-1));
     case "plan":
-      return block.running;
+    case "image":
+    case "file":
+      return { state: "shaping", label: "Shaping result…" };
     case "askUser":
-      return block.pending;
-    // approval 块只在 awaitingApproval 时才建出来,所以它在场就是在等人。
+      return block.pending
+        ? { state: "listening", label: "Waiting for your answer…" }
+        : { state: "solving", label: "Picking up your answer…" };
     case "approval":
-      return true;
+      return { state: "breathing", label: "Waiting for approval…" };
+    case "schedule":
+      return block.call.awaitingApproval
+        ? { state: "breathing", label: "Waiting for approval…" }
+        : { state: "working", label: "Working…" };
     case "parallel":
-      return block.tools.some((tool) => tool.status === "running");
+      return {
+        state: "weaving",
+        label: block.tools.some((tool) => tool.status === "running")
+          ? "Coordinating tasks…"
+          : "Combining results…",
+      };
     case "subagents":
-      return block.agents.some((agent) => agent.status === "running");
+      return {
+        state: "weaving",
+        label: block.agents.some((agent) => agent.status === "running")
+          ? "Coordinating agents…"
+          : "Combining results…",
+      };
     default:
-      return false;
+      return { state: "working", label: "Working…" };
   }
 }
 
-// 已结算的尾巴 → 此刻真正在发生的事。措辞刻意只说得出口的那部分:
-// 工具跑完了,模型在读它的输出;卡答完了,模型在接你的答案。
-function activityForTail(block: AssistantBlock | undefined): CloudOsActivity {
-  if (!block) return { state: "solving", label: "Thinking…" };
-  if (block.kind === "askUser") {
-    return { state: "solving", label: "Picking up your answer…" };
-  }
-  if (block.kind === "toolGroup") {
-    const kind = block.group.calls.at(-1)?.kind;
-    return kind !== undefined &&
-        ["web-search", "web-fetch", "grep", "glob", "list", "read"].includes(
-          kind,
-        )
-      ? { state: "searching", label: "Reading results…" }
-      : { state: "working", label: "Working…" };
-  }
-  return { state: "working", label: "Working…" };
-}
-
 /**
- * 本回合此刻该显示什么活动;`null` = 尾巴自己会说话,别再叠一个。
- *
- * @remarks
- * 判据是「**尾巴有没有活口**」,不是「本回合有没有出过内容」。后者曾经是这里的
- * 写法,于是答完 `ask_user`(卡片变成 Submitted,读起来就是"结束了")到模型下一
- * 个 chunk 之间整屏没有任何在跑的迹象 —— 而那段恰好是最长的一次 TTFT,看起来
- * 就是卡死。凡是尾巴为**已结算卡片**的断档都是同一个洞,这里一并补上。
+ * 回合活着时始终返回一个 Orb 状态;只有回合终止时才返回 `null`。
  */
 export function deriveTurnActivity(
   entries: readonly CloudOsEntry[],
-  options: { isActive: boolean; hasPendingSteer?: boolean },
+  options: {
+    isActive: boolean;
+    isRecovering?: boolean;
+    recoveryStatusLabel?: string;
+    awaitingApproval?: boolean;
+    hasPendingSteer?: boolean;
+  },
 ): CloudOsActivity | null {
+  if (options.isRecovering) {
+    return {
+      state: "connecting",
+      label: options.recoveryStatusLabel ?? "Reconnecting…",
+    };
+  }
   if (!options.isActive) return null;
+  if (options.awaitingApproval) {
+    return { state: "breathing", label: "Waiting for approval…" };
+  }
+  if (options.hasPendingSteer) {
+    return {
+      state: "breathing",
+      label: "Waiting for the current step to finish…",
+    };
+  }
   const tail = entries.at(-1) ?? null;
   const block = tail?.type === "assistant" ? tail.blocks.at(-1) : undefined;
-  if (block && isLiveBlock(block)) return null;
-  return options.hasPendingSteer
-    ? { state: "solving", label: "Waiting for the current step to finish…" }
-    : activityForTail(block);
+  return activityForTail(block);
 }
 
 // ── 行间距节奏(照搬原 rhythmTopClass)──────────────────────────────────────