@ai-zen/cli 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/tui/chat-session.js

@@ -1,101 +1,251 @@
 /**
- * TUI 对话会话 —— Agent 装配与结构化流式事件
+ * TUI 对话会话 —— Agent 装配 + 「内容变更」信号
  *
- * 与旧的行式渲染器（`src/conversation-runner.ts`）不同，这里把流式 delta
- * 翻译成**结构化事件**交给 React 层渲染，而非直接写 stdout，从而支持 Ink 的
- * 可控重绘（增量、无撕裂）。
+ * 渲染以 SDK 的 `agent.messages` 为**唯一数据源**：本模块不再把流式 delta 翻译成
+ * 自定义事件 / 中间模型（Block / LiveAssistant），只做两件事：
+ *   1. SDK 事件到达时通知上层「messages 变了，该重渲染了」；
+ *   2. 把系统级提示（notice / error）转发到独立通道（绝不写进 messages）。
  *
  * 本模块不依赖 React / Ink，可独立单测。
  */
-import { AgentNS } from "@ai-zen/agents-core";
+import { AgentNS, sumUsage } from "@ai-zen/agents-core";
+import { t } from "../i18n/index.js";
 import { AutoRefreshToolsPlugin, ContextGuardPlugin, } from "@ai-zen/agents-sdk";
 import { createAgent, resetScope } from "../agent-creator.js";
 import { readConfig } from "../config.js";
+import { buildUserContent } from "../user-content.js";
 import { CwdTrackerPlugin } from "../cwd-tracker-plugin.js";
 import { ConversationPersistPlugin } from "../conversation-persist-plugin.js";
 import { SubAgentGuardInstallerPlugin } from "../sub-agent-guard-plugin.js";
-import { AutoMigrateConfirmPlugin } from "../auto-migrate-confirm-plugin.js";
-import { createMigrationService } from "../migration-service.js";
-import { conversationRepository, generateConversationId } from "../conversation-repository.js";
-import { writeLastSession } from "../session-pointer.js";
-/** 去掉 CwdTrackerPlugin 追加在用户消息末尾的工作目录提示 */
-export function stripCwdNote(text) {
-    return text.replace(/\n+(?:\[工作目录变更\]\n)?当前工作目录: [^\n]*$/, "");
+import { createAutoMigratePlugin } from "../auto-migrate-confirm.js";
+import { createHandoffService } from "../handoff-service.js";
+import { promises as fs } from "node:fs";
+import { generateConversationId, conversationRepository, persistConversation, } from "../conversation-repository.js";
+import { stripCwdNote } from "./text.js";
+import { TokenRateMeter, deltaText } from "./token-rate.js";
+import { PhaseTracker } from "./phase.js";
+/**
+ * 把「请求即将发出」报给阶段跟踪器。
+ *
+ * SDK 的 `open` 事件是在 `chat.completions.create()` **await 返回之后**才发的，
+ * 也就是说它只代表响应头到了；在那之前的 DNS / TCP / TLS / 服务端受理都是静黙的。
+ * 所以要一个插件钩子把这一段补上——否则首轮会一直停在上一个状态。
+ */
+class PhasePlugin {
+    tracker;
+    constructor(tracker) {
+        this.tracker = tracker;
+    }
+    onInnerLoopStart() {
+        this.tracker.connecting();
+    }
 }
+/** 去掉 CwdTrackerPlugin 追加在用户消息末尾的工作目录提示（转发自 ./text.js） */
+export { stripCwdNote };
 export class ChatSession {
-    modelId;
+    /**
+     * 当前模型 id —— 从 Agent 定义读，**不再单独存一份**。
+     *
+     * 模型的唯一真相源是 `AgentDefinition.modelId`：会话不记模型，配置也没有
+     * `defaultModel`。这样状态栏、落盘与 SDK 实发请求用的永远是同一个值。
+     */
+    get modelId() {
+        return this.agent.definition.modelId ?? "";
+    }
     agentId;
-    maxTokens;
-    currentName;
-    currentId;
+    /** 当前模型的上下文阈值（交接软线 + 阻断硬线），缺省时不装护栏插件 */
+    tokenThresholds;
+    /**
+     * 会话 id / 名称的**唯一真相源是 `ctx`**（`ConversationContext`）。
+     *
+     * 为什么必须代理而不是各存一份：自动迁移由 SDK 的 `AutoMigratePlugin` 直接驱动
+     * `HandoffService.migrate()`，**不经过本类任何方法**，新 id 只会写进 `ctx.currentId`
+     * （`onMigrated` 钩子）。若本类另持一份 `currentId`，自动迁移后它就停在旧值上，
+     * 而 `ConversationPersistPlugin.getId()` 读的正是这份旧值——于是 prune 之后的
+     * 「系统提示 + 交接断点」会被写进**旧会话文件**，把已保存的完整历史覆盖掉。
+     */
+    get currentId() {
+        return this.ctx.currentId;
+    }
+    set currentId(id) {
+        this.ctx.currentId = id;
+    }
+    get currentName() {
+        return this.ctx.currentName;
+    }
+    set currentName(name) {
+        this.ctx.currentName = name;
+    }
     agent;
     ctx;
-    migrationService;
-    onEvent;
-    requestConfirm;
+    handoffService;
+    notifier;
+    requestMode;
     disposers = [];
-    constructor(migrationService, ctx, options, maxTokens, onEvent) {
-        this.migrationService = migrationService;
+    /** 生成过程的 token 速率统计（状态栏展示，见 `token-rate.ts`） */
+    rate = new TokenRateMeter();
+    /** 当前生成阶段（消息栏 spinner 文案，见 `phase.ts`） */
+    phaseTracker = new PhaseTracker();
+    /**
+     * 进行中的交接/迁移的取消句柄（`null` = 当前没有交接）。
+     *
+     * 为什么不能只靠 `agent.abort()`：交接的 `summary` 模式走的是独立的
+     * `chat.completions.create` 请求，`agent.abort()` 根本够不到它；而 `self` 模式
+     * 虽然能中断，但 core 层把中止收敛成「消息标记 Aborted、send 正常返回」，SDK 那边
+     * 会误判成「模型没写出文档」而重试 + 降级 summary 再跑一轮。
+     * 所以交接必须自己带一条 `AbortSignal`。
+     */
+    handoffAbort = null;
+    /** 本次会话中已出现的子 Agent（只保留当前一轮，见 {@link SubAgentView} 的生命周期说明） */
+    subAgentViews = [];
+    /** 展示序号（每轮归零，标签回到「子AGENT1」） */
+    subAgentSeq = 0;
+    /**
+     * 视图 id 序号（**永久递增，每轮也不清零**）。
+     *
+     * 与展示序号分开是必要的：若 id 也跟着归零，下一轮的 `sub-1` 会与上一轮同名，
+     * 而选中态是按 id 匹配的——残留的选中 id 会突然「接上」新一轮的子 Agent。
+     */
+    subAgentIdSeq = 0;
+    /** Agent 工厂 / Scope 重置（构造时可注入，见 `ChatSessionOptions.deps`） */
+    createAgentFn;
+    resetScopeFn;
+    constructor(handoffService, ctx, options, tokenThresholds, notifier) {
+        this.handoffService = handoffService;
         this.ctx = ctx;
-        this.modelId = options.modelId;
         this.agentId = options.agentId || "default";
-        this.maxTokens = maxTokens;
+        this.tokenThresholds = tokenThresholds;
         this.currentId = ctx.currentId || generateConversationId();
         this.currentName = ctx.currentName;
-        this.onEvent = onEvent;
-        this.requestConfirm = options.requestConfirm;
+        this.notifier = notifier;
+        this.requestMode = options.requestMode;
+        this.createAgentFn = options.deps?.createAgent ?? createAgent;
+        this.resetScopeFn = options.deps?.resetScope ?? resetScope;
     }
-    /** 创建会话：装配 Agent、插件与流式事件 */
-    static async create(options, onEvent) {
+    /** 创建会话：装配 Agent、插件与「变更信号」 */
+    static async create(options, notifier) {
         const config = await readConfig();
-        const model = config.models.find((m) => m.id === options.modelId);
-        const maxTokens = model?.maxContextTokens ??
-            (model?.maxContextChars ? Math.floor(model.maxContextChars / 4) : undefined);
-        const agent = await createAgent({ messages: options.messages, agentId: options.agentId });
+        // 先建 Agent：模型来自 Agent 定义（`createAgent` 内部解析 modelId），
+        // 阈值再按该模型查配置——不存在「CLI 以为的模型」与「实发模型」两套值。
+        const createAgentFn = options.deps?.createAgent ?? createAgent;
+        const agent = await createAgentFn({ messages: options.messages, agentId: options.agentId });
+        const model = config.models.find((m) => m.id === agent.definition.modelId);
+        // 阈值由配置直接给出（旧字段已在 SDK 的 ConfigManager.read() 里迁移过）
+        const tokenThresholds = model?.tokenThresholds;
         const currentId = options.conversationId || generateConversationId();
         const ctx = {
             agent,
-            input: "",
             currentName: options.conversationName || currentId,
             currentId,
-            modelId: options.modelId,
             agentId: options.agentId,
-            running: true,
         };
-        const migrationService = createMigrationService(ctx, {
-            // 迁移进度/结果经 Ink 渲染为 notice 块，避免直接写 stdout 撕裂画面
-            log: (text) => onEvent({ type: "notice", text }),
+        const handoffService = createHandoffService(ctx, {
+            // 迁移进度/结果经通知通道渲染，避免直接写 stdout 撕裂画面
+            log: (text) => notifier.onNotice(text, "info"),
         });
-        ctx.migrationService = migrationService;
-        const session = new ChatSession(migrationService, ctx, options, maxTokens, onEvent);
+        ctx.handoffService = handoffService;
+        const session = new ChatSession(handoffService, ctx, options, tokenThresholds, notifier);
         session.agent = agent;
         await session.attach(agent);
         return session;
     }
+    /** 对话消息（唯一真相源） */
     get messages() {
         return this.agent.messages;
     }
-    /** 最近一次响应的 token 用量 */
+    /** 本次会话已出现的子 Agent（按出现顺序）；对话屏据此渲染 Agent 栏目 */
+    get subAgents() {
+        return this.subAgentViews;
+    }
+    /** 最近一次响应的 token 用量（供「本轮 / 当前上下文占用」展示与阈值判定） */
     get lastUsage() {
         return this.agent.lastUsage;
     }
-    /** 发送一条消息；事件通过 `onEvent` 持续回传；resolve 表示本轮结束 */
-    async send(input) {
-        this.onEvent({ type: "user", text: input });
+    /**
+     * 本会话累计 token 用量。
+     *
+     * 逐消息求和（`sumUsage`）：含各 assistant 消息的 `usage`（自身响应）与工具消息的
+     * `subAgentUsage`（内部委派——含所有层级子 Agent）。每轮请求都会重发完整历史，
+     * 故求和即计费口径的累计消耗；且随消息持久化，续接 / `/load` 亦不丢。
+     */
+    get totalUsage() {
+        return sumUsage(this.agent.messages);
+    }
+    /** 当前速率快照：生成中看 `live`（实时），结束后看 `average`（本轮平均） */
+    get rateSample() {
+        return this.rate.snapshot();
+    }
+    /** 当前生成阶段；空闲时为 null（消息栏据此显示「处理中」或不起 spinner） */
+    get phase() {
+        return this.phaseTracker.phase;
+    }
+    /** 清空 Agent 栏目（新一轮输入 / 换 Agent / 换会话时调用；序号一并归零） */
+    clearSubAgents() {
+        this.subAgentViews = [];
+        this.subAgentSeq = 0;
+    }
+    /**
+     * 发送一条消息；内容变化经 `notifier.onChange` 通知，`resolve` 表示本轮结束。
+     *
+     * `images` 非空时，消息内容由「文本段 + 图片内容块」组成（转换规则与降级全在
+     * `user-content.ts`）：这是粘贴图片唯一的入口，不另开一条发送路径。
+     */
+    async send(input, images = []) {
+        this.rate.begin();
+        this.phaseTracker.connecting();
         try {
-            await this.agent.send(input);
+            if (images.length === 0) {
+                await this.agent.send(input);
+            }
+            else {
+                const config = await readConfig();
+                const { content, warnings } = await buildUserContent({
+                    text: input,
+                    images,
+                    config,
+                    // 端点 / 视觉能力按**实发模型名**反查：`file_id` 是端点维度资源，传错端点会 not found
+                    apiModelName: this.agent.model,
+                });
+                for (const warning of warnings)
+                    this.notifier.onNotice(warning, "info");
+                await this.agent.send(content);
+            }
         }
         catch (error) {
-            this.onEvent({ type: "error", text: error?.message ?? String(error) });
+            this.notifier.onNotice(error?.message ?? String(error), "error");
         }
         finally {
-            this.onEvent({ type: "done" });
+            this.rate.finish();
+            this.phaseTracker.reset();
+            // 本轮内循环（含全部工具调用）已结束：子 Agent 只剩历史价值，栏目随之消失。
+            // 放 `finally` 是为了中止 / 出错时也不留残影；序号一并归零，下一轮又是「子AGENT1」。
+            this.clearSubAgents();
+            this.notifier.onChange(true);
         }
     }
     /** 中止当前请求（Ctrl+C 语义：仅取消本轮，不退出） */
     abort() {
+        // 交接/迁移进行中：先按交接的取消通道（否则 summary 那步压根拦不住）
+        this.handoffAbort?.abort();
         this.agent.abort();
     }
+    /**
+     * 按「可取消」方式跑一段交接：创建 `AbortController` 并在结束时收尾。
+     *
+     * 收尾放 `finally`：成功后也要清掉，否则下一次 Ctrl+C 会往一个已完成的
+     * controller 上发出无意义的 abort。
+     */
+    async runCancellable(run) {
+        const controller = new AbortController();
+        this.handoffAbort = controller;
+        try {
+            return await run(controller.signal);
+        }
+        finally {
+            if (this.handoffAbort === controller)
+                this.handoffAbort = null;
+        }
+    }
     /**
      * 重置会话（/new）：先把当前对话归档（有内容才存），再清空历史并重建 Agent。
      *
@@ -107,16 +257,16 @@ export class ChatSession {
         const hasContent = this.agent.messages.some((m) => m.role === AgentNS.Role.User);
         const archivedId = hasContent ? await this.save() : null;
         this.dispose();
-        const agent = await createAgent({
+        this.clearSubAgents();
+        const agent = await this.createAgentFn({
             agentId: this.agentId === "default" ? undefined : this.agentId,
         });
         this.agent = agent;
         this.ctx.agent = agent;
         this.currentId = generateConversationId();
-        this.ctx.currentId = this.currentId;
         this.currentName = this.currentId;
-        this.ctx.currentName = this.currentName;
         await this.attach(agent);
+        this.notifier.onChange(true);
         return archivedId;
     }
     /**
@@ -129,24 +279,52 @@ export class ChatSession {
     async reload() {
         const messages = [...this.agent.messages];
         this.dispose();
-        await resetScope();
-        const agent = await createAgent({
+        this.clearSubAgents();
+        await this.resetScopeFn();
+        const agent = await this.createAgentFn({
             messages,
             agentId: this.agentId === "default" ? undefined : this.agentId,
         });
         this.agent = agent;
         this.ctx.agent = agent;
         await this.attach(agent);
+        this.notifier.onChange(true);
     }
-    /** 手动任务迁移（/migrate）：与自动迁移共用同一服务实例 */
-    async migrate() {
+    /** 手动任务迁移（`/migrate`）：交接 + 开新会话；与自动迁移共用同一服务实例 */
+    async migrate(mode) {
         if (!this.messages.some((m) => m.role === AgentNS.Role.User)) {
-            throw new Error("当前对话还没有可迁移的内容");
+            throw new Error(t("chat.noMigratable"));
         }
-        await this.migrationService.migrate({ agent: this.agent });
-        // 迁移后服务会开启新会话，同步会话元信息
-        this.currentName = this.ctx.currentName;
-        this.currentId = this.ctx.currentId ?? generateConversationId();
+        const ctx = await this.runCancellable((signal) => this.handoffService.migrate({
+            agent: this.agent,
+            mode,
+            conversationId: this.currentId,
+            signal,
+        }));
+        // 迁移后服务会开启新会话：新 id 已写进 ctx（唯一真相源），这里只需同步名称并刷新界面
+        this.currentName = this.currentId;
+        this.clearSubAgents();
+        this.notifier.onChange(true);
+        return ctx.handoffPath;
+    }
+    /**
+     * 只产出交接文档（`/handoff`）：不切换会话、不改动历史。
+     *
+     * 交接回合（指令 + 工具调用 + 回执）会留在 `agent.messages` 里，
+     * 用户可继续要求细化同一份文档（重写同一路径即可）。
+     */
+    async handoff(mode) {
+        if (!this.messages.some((m) => m.role === AgentNS.Role.User)) {
+            throw new Error(t("chat.noHandoffable"));
+        }
+        const ctx = await this.runCancellable((signal) => this.handoffService.handoff({
+            agent: this.agent,
+            mode,
+            conversationId: this.currentId,
+            signal,
+        }));
+        this.notifier.onChange(true);
+        return ctx.handoffPath;
     }
     /** 撤回：删除索引 index 起的消息，返回被撤回的首条用户消息文本（用于预填输入） */
     rollbackTo(index) {
@@ -160,113 +338,171 @@ export class ChatSession {
     }
     /** 保存当前对话到存档 */
     async save() {
-        const id = this.currentId;
-        const existing = await conversationRepository.read(id);
-        const now = new Date().toISOString();
-        await conversationRepository.write({
+        return persistConversation({
+            id: this.currentId,
+            agentId: this.agentId,
+            messages: this.agent.messages,
+            cwd: process.cwd(),
+        });
+    }
+    /**
+     * 把当前会话存成指定文件名（`/save <名字>`），成功后 `currentId` 与 last-session
+     * 指针一并跟过去，于是后续自动落盘直接写新文件。
+     *
+     * 实现是「写新文件 → 删旧文件」，而不是 `fs.rename`：
+     *   · rename 要求旧文件**已存在**，而刚开的新会话还没落过盘（会 ENOENT）；
+     *   · 覆盖已有目标在 Windows 上还得先 unlink，跨平台两边都得写分支；
+     *   · 写新文件时父目录由仓储 `write()` 的 `mkdir(recursive)` 负责（`/save a/b` 可用）。
+     * 中途被杀最多留下两份副本（可读、无损），不会丢内容。
+     */
+    async saveAs(id) {
+        const previous = this.currentId;
+        await persistConversation({
             id,
             agentId: this.agentId,
-            modelId: this.modelId,
             messages: this.agent.messages,
             cwd: process.cwd(),
-            createdAt: existing?.createdAt ?? now,
-            updatedAt: now,
         });
-        await writeLastSession(process.cwd(), id);
+        if (id === previous)
+            return id; // 自己盖自己：不删
+        // 旧文件不能留：同一份对话出现两条记录会让 `/load` 里分不清哪条是新的
+        await fs.rm(conversationRepository().filePath(previous), { force: true });
+        this.currentId = id;
+        this.currentName = id;
         return id;
     }
     /** 释放事件监听（重建 Agent 时调用，避免监听器泄漏） */
     dispose() {
         for (const off of this.disposers.splice(0))
             off();
+        this.rate.reset();
+        this.phaseTracker.reset();
     }
     // ==================== 内部：装配 Agent 与插件 ====================
     async attach(agent) {
+        agent.use(new PhasePlugin(this.phaseTracker));
         agent.use(new CwdTrackerPlugin());
         agent.use(new AutoRefreshToolsPlugin());
         agent.use(new ConversationPersistPlugin({
             getId: () => this.currentId,
             agentId: this.agentId,
-            modelId: this.modelId,
             cwd: process.cwd(),
-            onError: (text) => this.onEvent({ type: "notice", text }),
+            // 每轮自动落盘失败是真错误（用户会以为什么都没丢）—— 走 error 语气
+            onError: (text) => this.notifier.onNotice(text, "error"),
         }));
-        if (this.maxTokens && this.maxTokens > 0) {
-            agent.use(new ContextGuardPlugin({ maxTokens: this.maxTokens }));
-            agent.use(new AutoMigrateConfirmPlugin({
-                service: this.migrationService,
-                maxTokens: this.maxTokens,
-                // TUI 下由 Ink 层提供确认通道
-                shouldConfirm: () => Boolean(this.requestConfirm),
-                confirm: (info) => this.requestConfirm(`上下文即将超限（${info.promptTokens}/${info.maxTokens} tokens），是否立即执行任务迁移？`),
-                log: (text) => this.onEvent({ type: "notice", text }),
+        if (this.tokenThresholds) {
+            const { handoff, guard } = this.tokenThresholds;
+            // 硬线：请求前用量超过 guard 即中断本轮（绝对值，不再有 ratio/放宽档）
+            agent.use(new ContextGuardPlugin({ guardTokens: guard }));
+            agent.use(createAutoMigratePlugin({
+                service: this.handoffService,
+                handoffTokens: handoff,
+                // TUI 下由 Ink 层提供执行者选择器；无选择通道时按默认执行者（原 agent 自交接）迁移
+                shouldConfirm: () => Boolean(this.requestMode),
+                choose: (info) => this.requestMode(info),
+                log: (text) => this.notifier.onNotice(text, "info"),
             }));
-            agent.use(new SubAgentGuardInstallerPlugin({ maxTokens: this.maxTokens }));
+            agent.use(new SubAgentGuardInstallerPlugin({ guardTokens: guard }));
         }
         this.wire(agent);
         await agent.init();
     }
+    /**
+     * 订阅 SDK 事件，仅把它们当作「messages 可能已变化」的信号：
+     * - `chunk-parsed`（每片 delta 应用后）：高频 → 走合帧（`immediate=false`）；
+     * - `open` / `parsed` / `finally`：轮次边界 → 立即上屏；
+     * - `error`：转发到通知通道。
+     */
     wire(agent) {
-        const onOpen = () => this.onEvent({ type: "assistant-start" });
-        const onChunk = (chunk) => this.emitDelta(chunk);
-        const onError = (error) => this.onEvent({ type: "error", text: error?.message ?? String(error) });
-        const onSubStart = ({ subAgent, toolCallContext }) => {
-            const name = toolCallContext?.tool_call?.function?.name || "子任务";
-            this.onEvent({ type: "subagent-start", name });
-            subAgent.events.on("open", onOpen);
-            subAgent.events.on("chunk", onChunk);
-            subAgent.events.on("error", onError);
+        const notify = (immediate) => this.notifier.onChange(immediate);
+        const onOpen = () => {
+            this.phaseTracker.opened();
+            notify(true);
+        };
+        /**
+         * 每片 delta 应用后：除了通知重渲染，还要把这段文本计入速率统计。
+         *
+         * 子 Agent 的 chunk 也走这个回调（`onSubStart` 里同样订阅），因此速率包含
+         * 委派出去的子任务输出——它们也是真实从网络接收的 token。
+         */
+        const onChunk = (_receiver, chunk) => {
+            this.rate.addDelta(deltaText(chunk));
+            // 流末 chunk 携带真实用量（`stream_options.include_usage`）：多轮工具调用逐轮累加
+            this.rate.addExact(chunk?.usage?.completion_tokens);
+            this.phaseTracker.delta(chunk);
+            notify(false);
+        };
+        const onParsed = (receiver) => {
+            // 该轮带工具调用 → 接下来是工具执行（模型不在跑），阶段转「等工具返回」
+            this.phaseTracker.streamEnded(receiver);
+            notify(true);
+        };
+        /** 子 Agent 的事件：只重绘，不推进主阶段（理由见 `onSubStart`） */
+        const onSubOpen = () => notify(true);
+        const onSubChunk = (_receiver, chunk) => {
+            this.rate.addDelta(deltaText(chunk));
+            this.rate.addExact(chunk?.usage?.completion_tokens);
+            notify(false);
+        };
+        const onFinally = () => notify(true);
+        const onError = (error) => {
+            this.notifier.onNotice(error?.message ?? String(error), "error");
+            notify(true);
         };
-        const onSubEnd = ({ toolCallContext }) => {
-            const name = toolCallContext?.tool_call?.function?.name || "子任务";
-            this.onEvent({ type: "subagent-end", name });
+        const onSubStart = ({ subAgent }) => {
+            // 执行状态内联到栏目标签（`●` / `✓` / `✖`），**不再推「子任务运行中」通知**：
+            // 那种通知让通知栏凭空多出一行，整帧高度跟着跳。
+            const index = ++this.subAgentSeq;
+            const view = {
+                id: `sub-${++this.subAgentIdSeq}`,
+                index,
+                agent: subAgent,
+                status: "running",
+            };
+            this.subAgentViews.push(view);
+            // 记进 Agent 栏目：实例在委派结束后仍保留 messages，所以这里存引用即可随时回看。
+            // 不看 `sub_agent_*` 与 `call_skill_sub_agent` 的差别——两条路径现在都走 core 的
+            // AgentToolLazy，全部会在 onSubAgentStart 出现。
+            // 子 Agent 的流只计入速率并触发重绘，**不推进主阶段**：此刻主 Agent 正在等
+            // 这个工具（委派）返回，阶段应停在「等待 xxx 返回」；而子 Agent 自己的思考 / 输出
+            // 是工具内部的事，拿它的 delta 去改主阶段，界面会变成「输出中」——正好盖掉了
+            // 用户最需要知道的那句话。
+            // 这里挂的监听**不需要**在 `onSubEnd` 撤销：子 Agent 实例是「每次委派新建」的
+            // （core 的 `AgentTool.exec()` 里 `new Agent(...)`、`AgentToolLazy.exec()` 里
+            // `buildAgent(...)`），随本次 run 结束回收，监听器跟着走。别为此再加 off。
+            subAgent.events.on("open", onSubOpen);
+            subAgent.events.on("chunk-parsed", onSubChunk);
+            // 出错要落到标签上（✖）；错误信息仍送通知栏——那是错误，不是进度
+            subAgent.events.on("error", (error) => {
+                view.status = "failed";
+                this.notifier.onNotice(error?.message ?? String(error), "error");
+                notify(true);
+            });
+            notify(true);
+        };
+        const onSubEnd = ({ subAgent }) => {
+            // 只把「还在跑」的置为完成：失败已由 error 监听标成 failed，不能被这里覆盖
+            const view = this.subAgentViews.find((item) => item.agent === subAgent);
+            if (view && view.status === "running")
+                view.status = "done";
+            notify(true);
         };
         agent.events.on("open", onOpen);
-        agent.events.on("chunk", onChunk);
+        agent.events.on("chunk-parsed", onChunk);
+        agent.events.on("parsed", onParsed);
+        agent.events.on("finally", onFinally);
         agent.events.on("error", onError);
         agent.events.on("sub-agent-start", onSubStart);
         agent.events.on("sub-agent-end", onSubEnd);
         this.disposers.push(() => {
             agent.events.off("open", onOpen);
-            agent.events.off("chunk", onChunk);
+            agent.events.off("chunk-parsed", onChunk);
+            agent.events.off("parsed", onParsed);
+            agent.events.off("finally", onFinally);
             agent.events.off("error", onError);
             agent.events.off("sub-agent-start", onSubStart);
             agent.events.off("sub-agent-end", onSubEnd);
         });
     }
-    /** 把流式 delta 翻译为结构化事件 */
-    emitDelta(chunk) {
-        const delta = chunk?.choices?.[0]?.delta;
-        if (!delta)
-            return;
-        if (delta.reasoning_content) {
-            this.onEvent({ type: "reasoning", text: delta.reasoning_content });
-        }
-        if (delta.content) {
-            if (typeof delta.content === "string") {
-                this.onEvent({ type: "content", text: delta.content });
-            }
-            else if (Array.isArray(delta.content)) {
-                for (const part of delta.content) {
-                    if (part.type === "text" && part.text) {
-                        this.onEvent({ type: "content", text: part.text });
-                    }
-                    else if (part.type === "image_url") {
-                        this.onEvent({ type: "notice", text: `[图片: ${part.image_url.url}]` });
-                    }
-                }
-            }
-        }
-        if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-                this.onEvent({
-                    type: "tool",
-                    index: tc.index ?? 0,
-                    name: tc.function?.name,
-                    args: tc.function?.arguments,
-                });
-            }
-        }
-    }
 }
 //# sourceMappingURL=chat-session.js.map