@spzxg/cli-ui 0.1.0 → 0.3.1

package/src/core/conversation.ts

@@ -6,13 +6,44 @@
  *   · 节点转录（transcript + node 事件）：Agent 实际的对话过程，规则与 Operator 的 useTaskStream 一致。
  * 界面以节点转录为主；转录还没有（没派发、节点连不上）时用轮次的 input / reply 兜底。
  */
-import type { AskAnswers, AskQuestion, CenterTurn, ConversationClosedCallback, ConversationTurnCallback, JobStatus, Message, Msg, NodeEvent, StreamItem, StreamSnapshot, ToolData, TurnUsage } from "./types.js";
+import { isBatchSnapshot, type AskAnswers, type AskQuestion, type BatchStreamSnapshot, type BatchStreamTask, type CenterTurn, type ConversationClosedCallback, type ConversationTurnCallback, type JobStatus, type Message, type Msg, type NodeEvent, type StreamItem, type StreamSnapshot, type StreamTask, type ToolData, type TurnUsage } from "./types.js";
 import { indexFromEnd, mergeSnapshot, toolDataOf } from "../ui/transcriptModel.js";
 import { formatAnswersText } from "../ui/format.js";
 
 export const TERMINAL_TURN = new Set(["succeeded", "failed", "cancelled", "merged"]);
 export const ACTIVE_TURN = new Set(["queued", "dispatching", "running"]);
 export const TERMINAL_JOB = new Set(["succeeded", "failed", "cancelled"]);
+/** 一次性任务的子任务：结束了的、正在节点上跑的。 */
+export const TERMINAL_TASK = TERMINAL_JOB;
+const ACTIVE_TASK = new Set(["dispatching", "running", "verifying"]);
+
+// ── 对话键 ─────────────────────────────────────────────
+//
+// 一个对话任务（job）里可以有几个对话（几个子任务，各自一个 Agent 会话，共用节点和工作区）。
+// 组件里「一个对话」用对话键标识：
+//   · "job_x"            对话任务的第一个对话（只有一个对话时就是它，和以前一样）；
+//   · "job_x#task_y"     对话任务里的某个对话；
+//   · "job_x#new"        在这个对话任务里新开一个对话（还没发第一条消息）。
+
+/** 「在这个对话任务里新开一个对话」的子任务占位。 */
+export const NEW_TASK = "new";
+
+export function convKey(jobId: string, taskId?: string | null): string {
+  return taskId ? `${jobId}#${taskId}` : jobId;
+}
+
+export function parseConvKey(key: string): { jobId: string; taskId: string | null } {
+  const at = key.indexOf("#");
+  return at < 0 ? { jobId: key, taskId: null } : { jobId: key.slice(0, at), taskId: key.slice(at + 1) || null };
+}
+
+/** 对话键里的真实子任务（「新开」的占位不算）。 */
+export function taskOfKey(key: string): string | null {
+  const { taskId } = parseConvKey(key);
+  return taskId && taskId !== NEW_TASK ? taskId : null;
+}
+
+export const isNewInJob = (key: string | null | undefined) => !!key && parseConvKey(key).taskId === NEW_TASK;
 /** Operator 首轮固定的启动语句：正文其实在任务描述里（= 中枢第 1 轮的 input）。 */
 export const OPERATOR_INITIAL_PROMPT = "Start working on the task described in the task context.";
 
@@ -24,8 +55,14 @@ export interface ConvJob {
 }
 
 export interface ConvState {
+  /** 对话键（见 convKey）。 */
+  key: string;
   jobId: string;
+  /** 对话键里指定的子任务；只有 job_id 时为 null（看第一个对话）。 */
+  taskId: string | null;
   job: ConvJob | null;
+  /** 实时流看的这个对话（子任务）的状态；关闭了 closed=true。旧版 center 没有。 */
+  task: StreamTask | null;
   /** 中枢轮次，按 seq 升序。 */
   turns: CenterTurn[];
   /** 节点转录（Operator 消息）。 */
@@ -38,14 +75,23 @@ export interface ConvState {
   stream: "idle" | "connecting" | "live" | "reconnecting" | "ended" | "error";
   streamError: string | null;
   endReason: string | null;
+  /** 接续这个对话的新对话的键（对话任务结束后再发消息开出来的）。 */
   continuedBy: string | null;
   /** 本页提交过的提问回答（askId → 答案）。节点上那一轮已被中枢结束，不会回 ask_answered，只能本地记。 */
   localAnswers: Record<string, AskAnswers>;
+  /**
+   * 一次性任务（含续派，不是对话任务）：只读查看其中一个子任务。没有轮次，task 是那个子任务，
+   * batchTask 是它的原样（状态、错误、原文），remoteTaskId 是它在节点上的对话（流里只认这个对话的转录）。
+   */
+  batch: boolean;
+  batchTask: BatchStreamTask | null;
+  remoteTaskId: string | null;
 }
 
-export const emptyConv = (jobId: string): ConvState => ({
-  jobId, job: null, turns: [], msgs: [], hasTranscript: false, nodeRunning: false, resolvedModel: null,
+export const emptyConv = (key: string): ConvState => ({
+  key, ...parseConvKey(key), job: null, task: null, turns: [], msgs: [], hasTranscript: false, nodeRunning: false, resolvedModel: null,
   liveUsage: { fresh: 0, cacheRead: 0 }, stream: "idle", streamError: null, endReason: null, continuedBy: null, localAnswers: {},
+  batch: false, batchTask: null, remoteTaskId: null,
 });
 
 export function upsertTurns(turns: CenterTurn[], incoming: CenterTurn[]): CenterTurn[] {
@@ -55,21 +101,81 @@ export function upsertTurns(turns: CenterTurn[], incoming: CenterTurn[]): Center
   return [...byId.values()].sort((a, b) => a.seq - b.seq);
 }
 
-export function applySnapshot(conv: ConvState, snapshot: StreamSnapshot): ConvState {
+/**
+ * 只补上还不认识的轮次（发消息 / 撤回的接口响应用）。接口响应是请求那一刻的快照，可能比实时流晚到：
+ * 实时流已经报了「执行中 / 已结束」，再拿响应里的「排队中」去盖，这一轮就会一直显示排队（之后也不会再有更新）。
+ * 已有的轮次只认实时流——状态可能合法地往回走（节点忙时中枢会把派发中的轮次放回队列），不能按状态大小判断新旧。
+ */
+export function addTurnsIfAbsent(turns: CenterTurn[], incoming: CenterTurn[]): CenterTurn[] {
+  const known = new Set(turns.map((turn) => turn.turn_id));
+  const fresh = incoming.filter((turn) => !known.has(turn.turn_id));
+  return fresh.length ? upsertTurns(turns, fresh) : turns;
+}
+
+export function applySnapshot(conv: ConvState, snapshot: StreamSnapshot | BatchStreamSnapshot): ConvState {
+  if (isBatchSnapshot(snapshot)) return applyBatchSnapshot(conv, snapshot);
   const { job } = snapshot;
   return {
     ...conv,
     job: { status: job.status, closed_reason: job.closed_reason, node_id: job.node_id, title: job.title },
-    turns: upsertTurns([], snapshot.turns),
+    task: snapshot.task ?? conv.task,
+    turns: upsertTurns([], Array.isArray(snapshot.turns) ? snapshot.turns : []),
     resolvedModel: conv.resolvedModel ?? job.conversation?.last_turn?.resolved_model ?? null,
   };
 }
 
-const toMsg = (m: Message): Msg => ({ id: m.id, role: m.role, content: m.content, generation: m.generation, ts: m.created_at });
+// ── 一次性任务（含续派）：只读查看其中一个子任务 ─────────
+//
+// 指定了子任务就看它；没指定看最近一个派发过的（续派开出新的子任务时跟过去）。
+// 流里可能同时有几个节点对话的事件（带 remote_task_id），只认看的这个子任务所在的那个。
+
+const batchStreamTask = (task: BatchStreamTask): StreamTask => ({
+  id: task.id, seq: task.seq, title: task.title, status: task.status, closed: TERMINAL_TASK.has(task.status),
+  remote_task_id: task.remote_task_id, continue_from_task_id: task.continue_from_task_id,
+});
+
+/** 没指定子任务时看哪个：最近一个派发过的，都没派发过就是最后一个。 */
+export const latestBatchTask = (tasks: BatchStreamTask[]) =>
+  [...tasks].sort((a, b) => a.seq - b.seq).reverse().find((task) => task.remote_task_id) ?? tasks.reduce<BatchStreamTask | null>((last, task) => (!last || task.seq > last.seq ? task : last), null);
+
+/** 换成看另一个子任务（或同一个子任务换了节点对话，例如重试）：节点转录清掉，等新对话的转录。 */
+function focusBatchTask(conv: ConvState, task: BatchStreamTask | null): ConvState {
+  const remote = task?.remote_task_id ?? null;
+  const sameRemote = remote === conv.remoteTaskId;
+  // 状态变化事件不一定带原文（没指定子任务时）：沿用已有的。
+  const kept = conv.batchTask && task && conv.batchTask.id === task.id ? { prompt: conv.batchTask.prompt, opener_prompt: conv.batchTask.opener_prompt } : {};
+  const batchTask = task ? { ...kept, ...task } : null;
+  return {
+    ...conv, batch: true, batchTask, task: batchTask ? batchStreamTask(batchTask) : null, remoteTaskId: remote,
+    ...(sameRemote ? {} : { msgs: [], hasTranscript: false, nodeRunning: false }),
+  };
+}
+
+function applyBatchSnapshot(conv: ConvState, snapshot: BatchStreamSnapshot): ConvState {
+  const { job } = snapshot;
+  const tasks = Array.isArray(snapshot.tasks) ? snapshot.tasks : [];
+  // 指定了子任务就看它；没指定看流给的那个（最近一个派发过的），旧版中枢不给时自己挑。
+  const wanted = conv.taskId ? tasks.find((task) => task.id === conv.taskId) ?? null : snapshot.task ?? latestBatchTask(tasks);
+  const shown = wanted && snapshot.task?.id === wanted.id ? { ...wanted, ...snapshot.task } : wanted;
+  return focusBatchTask({ ...conv, job: { status: job.status, closed_reason: null, node_id: job.node_id, title: job.title }, turns: [] }, shown);
+}
+
+/** 一次性任务里的子任务状态变化。 */
+function applyBatchTask(conv: ConvState, task: BatchStreamTask): ConvState {
+  if (conv.batchTask?.id === task.id) return focusBatchTask(conv, task);
+  // 没指定子任务：续派开出了更新的子任务（已经派发到节点），跟过去。
+  if (!conv.taskId && task.remote_task_id && (!conv.batchTask || task.seq > conv.batchTask.seq)) return focusBatchTask(conv, task);
+  return conv;
+}
+
+// 缺字段时兜底：generation 缺省 1（按它分会话，缺了会把顺序排乱）；时间缺就不显示。
+const toMsg = (m: Message): Msg => ({ id: m.id, role: m.role, content: m.content, generation: typeof m.generation === "number" ? m.generation : 1, ...(typeof m.created_at === "number" ? { ts: m.created_at } : {}) });
 
 export function applyItems(conv: ConvState, items: StreamItem[]): ConvState {
   let next = conv;
   for (const item of items) {
+    // 一次性任务：只认看的这个子任务所在的节点对话。
+    if (next.batch && (item.type === "transcript" || item.type === "node") && item.remote_task_id && item.remote_task_id !== next.remoteTaskId) continue;
     if (item.type === "transcript") {
       // 节点转录全量（连上 / 重连节点时各一次）：整体替换，没变的消息保留对象引用。
       const messages = Array.isArray(item.messages) ? item.messages.map(toMsg) : [];
@@ -77,9 +183,15 @@ export function applyItems(conv: ConvState, items: StreamItem[]): ConvState {
     } else if (item.type === "node") {
       next = applyNodeEvent(next, item.event);
     } else if (item.type === "turn") {
-      next = { ...next, turns: upsertTurns(next.turns, [item.turn]), resolvedModel: item.turn.resolved_model ?? next.resolvedModel };
+      const turns = upsertTurns(next.turns, [item.turn]);
+      // 中枢只在节点上的回合真的停下后才把执行过的一轮收尾，所以一轮结束、又没有别的轮次在排队或执行时，
+      // 节点一定没在跑了——不只靠节点的 turn_end 事件（重连的空档里可能错过，界面就会一直显示「运行中」）。
+      const settled = TERMINAL_TURN.has(item.turn.status) && !turns.some((turn) => ACTIVE_TURN.has(turn.status));
+      next = { ...next, turns, resolvedModel: item.turn.resolved_model ?? next.resolvedModel, ...(settled ? { nodeRunning: false } : {}) };
     } else if (item.type === "job") {
-      next = { ...next, job: { ...next.job, status: item.job.status, closed_reason: item.job.closed_reason, node_id: item.job.node_id } };
+      next = { ...next, job: { ...next.job, status: item.job.status, closed_reason: item.job.closed_reason ?? null, node_id: item.job.node_id } };
+    } else if (item.type === "task") {
+      next = next.batch ? applyBatchTask(next, item.task as BatchStreamTask) : { ...next, task: item.task as StreamTask };
     }
   }
   return next;
@@ -167,10 +279,13 @@ export function applyNodeEvent(conv: ConvState, ev: NodeEvent): ConvState {
   }
 }
 
+/** 这个对话结束了：整个对话任务结束，或者只是这一个对话被关闭。 */
+export const convEnded = (conv: Pick<ConvState, "job" | "task">) => !!conv.task?.closed || (!!conv.job && TERMINAL_JOB.has(conv.job.status));
+
 /** 正在执行的那一轮（派发中或执行中）。 */
 export const runningTurn = (conv: ConvState) => conv.turns.find((turn) => turn.status === "running" || turn.status === "dispatching") ?? null;
 
-export const isRunning = (conv: ConvState) => conv.nodeRunning || !!runningTurn(conv);
+export const isRunning = (conv: ConvState) => conv.nodeRunning || !!runningTurn(conv) || (conv.batch && ACTIVE_TASK.has(conv.batchTask?.status ?? ""));
 
 /**
  * 界面上的转录：
@@ -179,17 +294,25 @@ export const isRunning = (conv: ConvState) => conv.nodeRunning || !!runningTurn(
  *   3. 还在中枢排队的消息，作为「排队中」气泡（可撤回），由界面钉在最下面。
  */
 export function viewMessages(conv: ConvState): Msg[] {
+  if (conv.batch) return batchViewMessages(conv);
   let out: Msg[] = [];
   // 有节点消息就以节点为准：通常先收到全量转录，但新对话可能先来增量事件（user / assistant / tool），也算。
   if (conv.msgs.length) {
     // 节点转录只有当前这个 Operator 会话：它的开场是固定的启动语句，正文其实是开出这个会话的那一轮——
-    // 第 1 轮，或者节点会话重建过（context_reset）时最近重建的那一轮。
-    const opener = [...conv.turns].reverse().find((turn) => turn.context_reset && turn.started_at) ?? conv.turns.find((turn) => turn.seq === 1);
+    // 这个对话的第一轮，或者节点会话重建过（context_reset）时最近重建的那一轮。
+    // 轮次号在整个对话任务里统一编号：对话任务里后开的对话，第一轮不是 1，取这个对话最早的那一轮。
+    const opener = [...conv.turns].reverse().find((turn) => turn.context_reset && turn.started_at) ?? conv.turns[0];
+    // 认开场语句：Operator 一个会话的第一条用户消息总是固定的启动语句（忽略请求正文），所以按位置认——
+    // 转录里的第一条用户消息、内容又不是开出会话那一轮的原文，就是它；措辞以后变了也认得出。
+    // 之后的消息里再出现这句固定语句（例如会话被重启），按原文匹配。
+    const openerText = opener ? opener.sent_input ?? opener.input : null;
     let replaced = false;
     for (const m of conv.msgs) {
-      if (!replaced && m.role === "user" && m.content.trim() === OPERATOR_INITIAL_PROMPT && opener) {
-        replaced = true;
-        out.push({ ...m, content: opener.sent_input ?? opener.input });
+      const firstUser = !replaced && m.role === "user";
+      if (firstUser) replaced = true;
+      if (openerText && m.role === "user" && m.content.trim() !== openerText.trim()
+        && ((firstUser && m.id === conv.msgs.find((x) => x.role === "user")?.id) || m.content.trim() === OPERATOR_INITIAL_PROMPT)) {
+        out.push({ ...m, content: openerText });
       } else out.push(m);
     }
   } else {
@@ -212,7 +335,9 @@ export function viewMessages(conv: ConvState): Msg[] {
     const ts = new Date(turn.ended_at ?? turn.created_at).getTime();
     const reason = turn.last_error ? `：${describeTurnError(turn.last_error)}` : "";
     if ((turn.status === "failed" || turn.status === "cancelled") && !turn.started_at) {
-      notices.push({ id: `turn-fail-${turn.turn_id}`, role: "system", content: `⚠ 第 ${turn.seq} 条消息${turn.status === "cancelled" ? "已撤回" : "没有执行"}${reason}`, generation, ts });
+      // 用户自己撤回的不用再写原因（「已撤回：已取消」是同一件事）；中枢取消的（例如对话结束时还在排队）写明原因。
+      const byCaller = turn.status === "cancelled" && /cancelled by caller/i.test(turn.last_error ?? "");
+      notices.push({ id: `turn-fail-${turn.turn_id}`, role: "system", content: `⚠ 第 ${turn.seq} 条消息${turn.status === "cancelled" ? "已撤回" : "没有执行"}${byCaller ? "" : reason}`, generation, ts });
     } else if (turn.status === "failed") {
       notices.push({ id: `turn-fail-${turn.turn_id}`, role: "system", content: `⚠ 这一轮没有完成${reason}`, generation, ts });
     }
@@ -230,6 +355,48 @@ export function viewMessages(conv: ConvState): Msg[] {
   return out;
 }
 
+// 中枢派发一次性任务时加在正文前的标记行，和完成后的自动核对（见 center scheduler.ts）。
+const CENTER_MARKER_LINES = /^(?:\[CENTER-(?:ATTEMPT|TERMINAL-REVISION):[^\]\n]*\][ \t]*(?:\r?\n|$))+/;
+const CONFIRM_MARK = "[CENTER-CONFIRM]";
+const BATCH_TASK_ERROR: Record<string, string> = { failed: "子任务失败", cancelled: "子任务已取消" };
+
+/**
+ * 一次性任务（含续派）的转录，只读：
+ *   1. 第一条用户消息是 Operator 固定的启动语句，换成开出这个节点对话的子任务原文（流里给了才换）；
+ *   2. 去掉中枢加在正文前的标记行（[CENTER-ATTEMPT:…]、[CENTER-TERMINAL-REVISION:…]）；
+ *   3. 中枢的完成核对（[CENTER-CONFIRM] 追问 + Agent 回的 TASK_COMPLETE / TASK_INCOMPLETE）合成一行说明；
+ *   4. 还没派发、拿不到执行记录、失败 / 取消时补一行说明。
+ */
+function batchViewMessages(conv: ConvState): Msg[] {
+  const out: Msg[] = [];
+  const task = conv.batchTask;
+  const opener = task?.opener_prompt ?? null;
+  const firstUserId = conv.msgs.find((m) => m.role === "user")?.id;
+  for (let i = 0; i < conv.msgs.length; i++) {
+    const m = conv.msgs[i];
+    if (m.role === "user" && m.content.includes(CONFIRM_MARK)) {
+      const reply = conv.msgs[i + 1]?.role === "assistant" ? conv.msgs[++i] : null;
+      const content = !reply ? "中枢正在核对任务是否完成…" : /^\s*TASK_COMPLETE\b/.test(reply.content) ? "✓ 中枢核对：任务已完成" : "⚠ 中枢核对：任务没有完成";
+      out.push({ id: `confirm-${m.id}`, role: "system", content, generation: m.generation, ...(m.ts !== undefined ? { ts: m.ts } : {}) });
+      continue;
+    }
+    if (m.role !== "user") { out.push(m); continue; }
+    const content = m.id === firstUserId && opener ? opener : m.content.replace(CENTER_MARKER_LINES, "");
+    out.push(content === m.content ? m : { ...m, content });
+  }
+  const generation = out.length ? out[out.length - 1].generation : 1;
+  const note = (id: string, content: string) => out.push({ id: `batch-${id}`, role: "system", content, generation });
+  if (!task) {
+    if (conv.job) note("none", "这个任务里还没有子任务");
+  } else if (!conv.msgs.length && !task.remote_task_id && !TERMINAL_TASK.has(task.status)) {
+    note("waiting", "子任务还没派发到执行节点，派发后这里会实时显示执行过程");
+  } else if (!conv.msgs.length && conv.stream === "ended") {
+    note("empty", "没有拿到这个子任务的执行记录（执行节点上的会话可能已经清理）");
+  }
+  if (task && BATCH_TASK_ERROR[task.status]) note(`err-${task.id}-${task.attempt}`, `⚠ ${BATCH_TASK_ERROR[task.status]}${task.last_error ? `：${describeTurnError(task.last_error)}` : ""}`);
+  return out;
+}
+
 /** 把说明行按时间插进转录：放在时间不晚于它的最后一条消息之后（没有时间的消息沿用前一条的时间）。 */
 function insertByTime(msgs: Msg[], notices: Msg[]): Msg[] {
   if (!notices.length) return msgs;
@@ -362,8 +529,10 @@ export function closedCallback(conv: ConvState): ConversationClosedCallback {
     mode: "conversation",
     callback_seq: turns + 1,
     job_id: conv.jobId,
-    status: conv.job?.status ?? "succeeded",
-    closed_reason: conv.job?.closed_reason ?? null,
+    // 只关掉了这一个对话（对话任务还开着）：带上是哪个，原因写 conversation_closed。
+    ...(conv.task?.closed && !TERMINAL_JOB.has(conv.job?.status ?? "") ? { task_id: conv.task.id } : {}),
+    status: conv.task?.closed && !TERMINAL_JOB.has(conv.job?.status ?? "") ? "succeeded" : conv.job?.status ?? "succeeded",
+    closed_reason: conv.task?.closed && !TERMINAL_JOB.has(conv.job?.status ?? "") ? "conversation_closed" : conv.job?.closed_reason ?? null,
     turns,
     continued_by_job_id: conv.continuedBy,
     occurred_at: new Date().toISOString(),

package/src/core/provider.tsx

@@ -1,6 +1,6 @@
 import { createContext, useContext, useEffect, useMemo, useRef, useSyncExternalStore, type ReactNode } from "react";
 import { createCliStore, type CliEvent, type CliState, type CliStore, type CliStoreOptions } from "./store.js";
-import type { ConversationCallback } from "./types.js";
+import type { ConversationCallback, ConversationEndPayload, TurnEndPayload } from "./types.js";
 
 /**
  * 积木的拼接点。放在同一个 <CliCenterProvider> 里的组件共享一个仓库：
@@ -15,30 +15,43 @@ import type { ConversationCallback } from "./types.js";
  */
 const StoreContext = createContext<CliStore | null>(null);
 
-export interface CliCenterProviderProps extends CliStoreOptions {
+export interface CliCenterProviderProps extends CliStoreOptions, ResultHandlers {
   /** 外部建好的仓库（例如 Web Component 按 group 共享的）；给了就不再自己建。 */
   store?: CliStore;
   /** 监听仓库事件：选中、一轮结束、对话结束、job 变化、错误。 */
   onEvent?: (event: CliEvent) => void;
-  /**
-   * 前端回调：每轮结束 / 对话结束时调用，载荷与 center 投递给 callback.url 的请求体同名同义
-   * （conversation_turn / conversation_closed）。用来刷新业务界面；落库以后端回调为准。
-   */
-  onCallback?: (payload: ConversationCallback) => void;
   children: ReactNode;
 }
 
-export function CliCenterProvider({ store: external, onEvent, onCallback, children, ...options }: CliCenterProviderProps) {
+/**
+ * 结果通知：组件从实时流里看到一轮结束 / 对话结束时调用，全在浏览器里发生，**和 center 的 callback.url 无关**——
+ * 不配 callback 也照样会调。载荷字段与 center 回调体一致，方便业务后端和前端用同一套代码解析。
+ */
+export interface ResultHandlers {
+  /** 一轮结束（成功 / 失败 / 取消）。 */
+  onTurnEnd?: (payload: TurnEndPayload) => void;
+  /** 对话结束（关闭 / 取消 / 过期……）。 */
+  onConversationEnd?: (payload: ConversationEndPayload) => void;
+  /** @deprecated 旧名字，等同于同时监听 onTurnEnd 和 onConversationEnd（payload.type 区分）。 */
+  onCallback?: (payload: ConversationCallback) => void;
+}
+
+export function dispatchResult(event: CliEvent, handlers: ResultHandlers) {
+  if (event.type === "conversation_turn") { handlers.onTurnEnd?.(event.payload); handlers.onCallback?.(event.payload); }
+  else if (event.type === "conversation_closed") { handlers.onConversationEnd?.(event.payload); handlers.onCallback?.(event.payload); }
+}
+
+export function CliCenterProvider({ store: external, onEvent, onTurnEnd, onConversationEnd, onCallback, children, ...options }: CliCenterProviderProps) {
   // 连接参数只在建仓库时用一次：中途换 baseUrl / token 请换 key 重建。
   const optionsRef = useRef(options);
   const store = useMemo(() => external ?? createCliStore(optionsRef.current), [external]);
   const onEventRef = useRef(onEvent);
   onEventRef.current = onEvent;
-  const onCallbackRef = useRef(onCallback);
-  onCallbackRef.current = onCallback;
+  const resultRef = useRef<ResultHandlers>({});
+  resultRef.current = { onTurnEnd, onConversationEnd, onCallback };
   useEffect(() => store.on((event) => {
     onEventRef.current?.(event);
-    if (event.type === "conversation_turn" || event.type === "conversation_closed") onCallbackRef.current?.(event.payload);
+    dispatchResult(event, resultRef.current);
   }), [store]);
   return <StoreContext.Provider value={store}>{children}</StoreContext.Provider>;
 }
@@ -60,30 +73,31 @@ export function useCliState<T>(selector: (state: CliState) => T): T {
 }
 
 /** 组件外面没有 Provider 时，用组件自己的 props 包一层。 */
-export function withOwnProvider<P extends object>(props: P & CliStoreOptions & { onEvent?: (event: CliEvent) => void; onCallback?: (payload: ConversationCallback) => void; store?: CliStore }, inner: ReactNode, hasContext: boolean) {
+export function withOwnProvider<P extends object>(props: P & CliStoreOptions & ResultHandlers & { onEvent?: (event: CliEvent) => void; store?: CliStore }, inner: ReactNode, hasContext: boolean) {
   if (hasContext) return inner;
-  const { baseUrl, token, line, headers, fetch, client, namespace, newConversation, createConversation, businessIdFor, onEvent, onCallback, store } = props;
+  const { baseUrl, token, line, headers, fetch, client, namespace, newConversation, createConversation, businessIdFor, onEvent, onTurnEnd, onConversationEnd, onCallback, store } = props;
   // 连接参数变了（换了中枢地址、令牌、产品线、命名空间）就换一个新仓库重连，不沿用旧连接。
   const connection = [baseUrl ?? "", token ?? "", line ?? "", namespace ?? ""].join("\u0000");
   return (
-    <CliCenterProvider key={store ? "external" : connection} {...{ baseUrl, token, line, headers, fetch, client, namespace, newConversation, createConversation, businessIdFor, onEvent, onCallback, store }}>
+    <CliCenterProvider key={store ? "external" : connection} {...{ baseUrl, token, line, headers, fetch, client, namespace, newConversation, createConversation, businessIdFor, onEvent, onTurnEnd, onConversationEnd, onCallback, store }}>
       {inner}
     </CliCenterProvider>
   );
 }
 
 /**
- * 组件自己的 onEvent / onCallback：组件放在外层 Provider 里时由这里订阅（自己建 Provider 时交给那个 Provider，免得调两次）。
+ * 组件自己的 onEvent / onTurnEnd / onConversationEnd：组件放在外层 Provider 里时由这里订阅
+ * （自己建 Provider 时交给那个 Provider，免得调两次）。
  */
-export function useComponentEvents(onEvent: ((event: CliEvent) => void) | undefined, onCallback: ((payload: ConversationCallback) => void) | undefined, enabled: boolean) {
+export function useComponentEvents(onEvent: ((event: CliEvent) => void) | undefined, results: ResultHandlers, enabled: boolean) {
   const store = useContext(StoreContext);
-  const ref = useRef({ onEvent, onCallback });
-  ref.current = { onEvent, onCallback };
+  const ref = useRef({ onEvent, results });
+  ref.current = { onEvent, results };
   useEffect(() => {
     if (!enabled || !store) return;
     return store.on((event) => {
       ref.current.onEvent?.(event);
-      if (event.type === "conversation_turn" || event.type === "conversation_closed") ref.current.onCallback?.(event.payload);
+      dispatchResult(event, ref.current.results);
     });
   }, [store, enabled]);
 }