@aipack-ai/multi-agent 1.1.6 → 1.1.8

package/dist/index.js

@@ -57,6 +57,10 @@ function createSharedContext(init) {
     meta: init?.meta ?? {}
   };
 }
+function storeOriginalInput(ctx, input) {
+  const inputText = typeof input === "string" ? input : input.message;
+  ctx.blackboard.set("__original_input__", inputText);
+}
 
 // ../agent/core/types.ts
 function extractText(content) {
@@ -74,7 +78,50 @@ function createEmptyUsage() {
   return { input: 0, output: 0, total: 0 };
 }
 
+// ../agent/core/tokens.ts
+function estimateTextTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+function estimateMessageTokens(message) {
+  const content = message.content;
+  if (typeof content === "string") return estimateTextTokens(content);
+  try {
+    return Math.ceil(JSON.stringify(content ?? []).length / 4);
+  } catch {
+    return 0;
+  }
+}
+
+// ../agent/core/errors.ts
+var AgentErrorCategory = {
+  RETRYABLE: "retryable",
+  TIMEOUT: "timeout",
+  AUTH: "auth",
+  CONTEXT_OVERFLOW: "context-overflow",
+  RATE_LIMIT: "rate-limit",
+  INVALID_REQUEST: "invalid-request",
+  UNKNOWN: "unknown"
+};
+
 // ../agent/core/tapable.ts
+var tapFailurePolicy = "log";
+var tapErrorHandler;
+function setTapErrorHandler(handler) {
+  tapErrorHandler = handler;
+}
+function handleTapError(hook, tap, err) {
+  if (tapErrorHandler) {
+    try {
+      tapErrorHandler({ hook, tap: tap.name, error: err });
+    } catch {
+    }
+  }
+  if (tapFailurePolicy === "throw") throw err;
+  if (tapFailurePolicy === "log") {
+    console.warn(`[aipack] extension tap "${tap.name}" on hook "${hook}" \u5931\u8D25:`, err);
+  }
+}
 var AsyncSeriesHook = class {
   constructor(name) {
     this.name = name;
@@ -90,6 +137,7 @@ var AsyncSeriesHook = class {
       try {
         await tap.fn(...args);
       } catch (err) {
+        handleTapError(this.name, tap, err);
       }
     }
   }
@@ -116,6 +164,7 @@ var AsyncSeriesWaterfallHook = class {
       try {
         current = await tap.fn(current, ...rest);
       } catch (err) {
+        handleTapError(this.name, tap, err);
       }
     }
     return current;
@@ -602,15 +651,6 @@ function resourcesToMessages(resources) {
 import { Type } from "@sinclair/typebox";
 
 // ../agent/ai/errors.ts
-var AgentErrorCategory = {
-  RETRYABLE: "retryable",
-  TIMEOUT: "timeout",
-  AUTH: "auth",
-  CONTEXT_OVERFLOW: "context-overflow",
-  RATE_LIMIT: "rate-limit",
-  INVALID_REQUEST: "invalid-request",
-  UNKNOWN: "unknown"
-};
 var RETRYABLE_CATEGORIES = /* @__PURE__ */ new Set([
   AgentErrorCategory.RETRYABLE,
   AgentErrorCategory.RATE_LIMIT
@@ -798,62 +838,7 @@ function isContextOverflow(message, contextWindow) {
   return false;
 }
 
-// ../agent/transformer/index.ts
-function ensureToolPairing(messages) {
-  const toolCallIds = /* @__PURE__ */ new Set();
-  const toolResultIds = /* @__PURE__ */ new Set();
-  for (const msg of messages) {
-    if (msg.role === "assistant") {
-      const content = msg.content;
-      if (Array.isArray(content)) {
-        for (const tc of extractToolCalls(content)) {
-          toolCallIds.add(tc.id);
-        }
-      }
-    }
-    if (msg.role === "toolResult") {
-      toolResultIds.add(msg.toolCallId);
-    }
-  }
-  const orphanedCalls = /* @__PURE__ */ new Set();
-  const orphanedResults = /* @__PURE__ */ new Set();
-  for (const id of toolCallIds) {
-    if (!toolResultIds.has(id)) orphanedCalls.add(id);
-  }
-  for (const id of toolResultIds) {
-    if (!toolCallIds.has(id)) orphanedResults.add(id);
-  }
-  if (orphanedCalls.size === 0 && orphanedResults.size === 0) {
-    return messages;
-  }
-  const result = [];
-  for (const msg of messages) {
-    if (msg.role === "assistant") {
-      const content = msg.content;
-      if (Array.isArray(content)) {
-        const filteredContent = content.filter((block) => {
-          if (block.type === "toolCall") {
-            return !orphanedCalls.has(block.id);
-          }
-          return true;
-        });
-        if (filteredContent.length === 0 && content.length > 0) continue;
-        result.push({ ...msg, content: filteredContent });
-      } else {
-        result.push(msg);
-      }
-    } else if (msg.role === "toolResult") {
-      if (!orphanedResults.has(msg.toolCallId)) {
-        result.push(msg);
-      }
-    } else {
-      result.push(msg);
-    }
-  }
-  return result;
-}
-
-// ../agent/runtime/index.ts
+// ../agent/runtime/shared.ts
 import { randomUUID } from "crypto";
 function newTraceId() {
   return `${Date.now().toString(36)}-${randomUUID()}`;
@@ -925,19 +910,25 @@ function buildImageContent(media) {
   }
   return { type: "image", mimeType: "image/url", data: media };
 }
-var OVERFLOW_RECOVERY_LIMIT = 2;
-function estimateMessageTokens(message) {
-  const content = message.content;
-  if (typeof content === "string") return Math.ceil(content.length / 4);
-  try {
-    return Math.ceil(JSON.stringify(content ?? []).length / 4);
-  } catch {
-    return 0;
+function buildUserMessage(request) {
+  if (request.media && request.media.length > 0) {
+    const blocks = [
+      createTextContent(request.message),
+      ...request.media.filter(Boolean).map(buildImageContent)
+    ];
+    return {
+      role: "user",
+      content: blocks,
+      timestamp: Date.now()
+    };
   }
+  return {
+    role: "user",
+    content: request.message,
+    timestamp: Date.now()
+  };
 }
-function estimateTextTokens(text) {
-  return Math.ceil(text.length / 4);
-}
+var OVERFLOW_RECOVERY_LIMIT = 2;
 var COMPACTION_SUMMARY_BUDGET_RATIO = 0.6;
 var COMPACTION_LINE_CLAMP = 4e3;
 var DEFAULT_COMPACTION_PROMPT = [
@@ -988,150 +979,146 @@ function messageToSummaryLine(msg) {
     }
   }
 }
-var AgentRuntime = class _AgentRuntime {
-  _config;
-  _extensions;
-  _hooks;
-  /** 上下文转换器列表，按数组顺序链式执行（上一个输出作为下一个输入） */
-  _transformers;
-  _model;
-  _streamFn;
-  _systemPrompt;
-  _thinkingLevel;
-  _globalTools = /* @__PURE__ */ new Map();
-  /** 多会话状态表：key = sessionKey。模型/工具/扩展/转换器等资源跨会话共享 */
-  _sessions;
-  /** 默认会话 key（常量 'default'；请求未指定 sessionKey 时路由到此会话） */
-  _sessionKey;
-  /** 内存会话状态表 LRU 上限 */
-  _maxSessions;
-  _sessionStorage;
-  /** Extension 应用时的上下文（shared Map 供 ToolCallContext 引用） */
-  _extensionContext;
-  _maxTurns;
-  _toolTimeoutMs;
-  _parallelToolCalls;
-  _contextBudgetRatio;
-  /** 内置摘要压缩配置（未配置 = 保持旧行为，仅硬截断兜底） */
-  _compaction;
-  _telemetry;
-  /** 框架级工具权限策略（未配置 → 放行，向后兼容） */
-  _permissionPolicy;
-  /** 审批管理器（pending 决策挂起等待外部批准；未配置 → pending 视为 deny） */
-  _approvals;
-  /** 审批等待超时（毫秒） */
-  _approvalTimeoutMs;
-  /** traceId 生成器（测试可注入确定性 id） */
-  _traceIdGenerator;
-  constructor(options) {
-    this._config = options.config ?? {};
-    this._extensions = new ExtensionManager();
-    this._hooks = this._extensions.getHooks();
-    this._transformers = [...options.transformers ?? []];
-    this._model = options.model ?? {
-      id: "unknown",
-      name: "unknown",
-      provider: "unknown",
-      contextWindow: 128e3,
-      maxTokens: 8192,
-      reasoning: false
-    };
-    this._streamFn = options.streamFn ?? (async function* () {
-      throw new Error("streamFn \u672A\u8BBE\u7F6E\uFF0C\u8BF7\u901A\u8FC7 setStreamFn() \u6216 RuntimeOptions.streamFn \u63D0\u4F9B");
-    });
-    this._systemPrompt = options.systemPrompt ?? "";
-    this._thinkingLevel = options.thinkingLevel ?? "off";
-    this._sessionStorage = options.sessionStorage;
-    this._maxTurns = options.maxTurns ?? 50;
-    this._toolTimeoutMs = options.toolTimeoutMs ?? 12e4;
-    this._parallelToolCalls = options.parallelToolCalls ?? true;
-    this._contextBudgetRatio = options.contextBudgetRatio ?? 0.8;
-    this._compaction = options.compaction;
-    this._telemetry = options.telemetry;
-    this._permissionPolicy = options.permissionPolicy;
-    this._approvals = options.approvals;
-    this._approvalTimeoutMs = options.approvalTimeoutMs ?? 3e5;
-    this._traceIdGenerator = options.traceIdGenerator;
-    if (options.tools) {
-      for (const tool of options.tools) {
-        this._globalTools.set(tool.name, tool);
+function buildResult(compilation) {
+  const messages = compilation.messages;
+  let content = "";
+  let stopReason = "completed";
+  let error;
+  const toolsUsed = [];
+  const usage = {};
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const assistant = msg;
+      content = extractText(assistant.content);
+      stopReason = assistant.stopReason ?? "completed";
+      error = assistant.errorMessage;
+      if (assistant.usage) {
+        usage.input = (usage.input ?? 0) + assistant.usage.input;
+        usage.output = (usage.output ?? 0) + assistant.usage.output;
+        usage.total = (usage.total ?? 0) + assistant.usage.total;
+        if (assistant.usage.cacheRead) usage.cacheRead = (usage.cacheRead ?? 0) + assistant.usage.cacheRead;
+        if (assistant.usage.cacheWrite) usage.cacheWrite = (usage.cacheWrite ?? 0) + assistant.usage.cacheWrite;
       }
     }
-    this._sessionKey = "default";
-    this._maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
-    this._sessions = /* @__PURE__ */ new Map([[this._sessionKey, createSessionState()]]);
-  }
-  // ─── 静态工厂 ───────────────────────────────────────────────────
-  static create(options = {}) {
-    const runtime = new _AgentRuntime(options);
-    if (options.extensions) {
-      runtime._extensions.registerAll(options.extensions);
+    if (msg.role === "toolResult") {
+      const toolMsg = msg;
+      if (!toolsUsed.includes(toolMsg.toolName)) {
+        toolsUsed.push(toolMsg.toolName);
+      }
     }
-    const ctx = {
-      config: runtime._config,
-      workspace: options.workspace ?? process.cwd(),
-      sessionKey: runtime._sessionKey,
-      shared: /* @__PURE__ */ new Map(),
-      runtime
-    };
-    runtime._extensionContext = ctx;
-    runtime._extensions.applyAll(ctx);
-    return runtime;
   }
-  // ─── Runtime 接口实现 ───────────────────────────────────────────
-  get config() {
-    return this._config;
+  const resources = messagesToResources(messages);
+  const builder = new ResultBuilder().content(content).toolsUsed(toolsUsed).usage(usage).stopReason(stopReason).error(error).resources(resources).metadata("traceId", compilation.traceId);
+  if (compilation.terminateReason) {
+    builder.stopReason("terminated").metadata("terminateReason", compilation.terminateReason);
   }
-  get extensions() {
-    return this._extensions;
+  if (compilation.maxTurnsExhausted) {
+    builder.stopReason("max_turns").metadata("maxTurns", true);
   }
-  get hooks() {
-    return this._hooks;
+  return builder.build();
+}
+function streamEventToChunk(event) {
+  switch (event.type) {
+    case "text_delta":
+      return { type: "text", content: event.delta };
+    case "thinking_delta":
+      return { type: "thinking", content: event.delta };
+    case "error":
+      return {
+        type: "error",
+        content: event.message.errorMessage || "\u6A21\u578B\u8C03\u7528\u51FA\u9519"
+      };
+    default:
+      return null;
   }
-  // ─── 工具/模型/流管理 ───────────────────────────────────────────
-  registerTool(tool) {
-    if (this._globalTools.has(tool.name)) {
-      console.warn(`[Runtime] \u5DE5\u5177 "${tool.name}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6`);
-    }
-    this._globalTools.set(tool.name, tool);
-    return this;
+}
+
+// ../agent/runtime/session-store.ts
+var SessionStore = class {
+  /** 多会话状态表：key = sessionKey。模型/工具/扩展/转换器等资源跨会话共享 */
+  _sessions;
+  /** 内存会话状态表 LRU 上限 */
+  _maxSessions;
+  /** 默认会话 key（常量 'default'；请求未指定 sessionKey 时路由到此会话） */
+  defaultKey;
+  constructor(defaultKey, maxSessions = DEFAULT_MAX_SESSIONS) {
+    this.defaultKey = defaultKey;
+    this._maxSessions = maxSessions;
+    this._sessions = /* @__PURE__ */ new Map();
+    this._sessions.set(defaultKey, createSessionState());
   }
-  registerTools(tools) {
-    for (const tool of tools) {
-      this.registerTool(tool);
+  /**
+   * 获取（懒创建）会话状态。同一 Runtime 下不同 sessionKey 的消息历史、
+   * 串行队列、abort 控制相互独立；共享模型/工具/扩展/转换器。
+   * 超过 maxSessions 时淘汰最久未用的非活动会话（仅清内存态，不删存储）。
+   */
+  ensure(key) {
+    let session = this._sessions.get(key);
+    if (session) {
+      this._sessions.delete(key);
+      this._sessions.set(key, session);
+      return session;
     }
-    return this;
-  }
-  unregisterTool(name) {
-    return this._globalTools.delete(name);
-  }
-  setModel(model) {
-    this._model = model;
-    return this;
+    session = createSessionState();
+    this._sessions.set(key, session);
+    this.evictIdleSessions();
+    return session;
   }
-  setSystemPrompt(prompt) {
-    this._systemPrompt = prompt;
-    return this;
+  /** 只读访问（不创建、不刷新 LRU；会话不存在返回 undefined） */
+  peek(key) {
+    return this._sessions.get(key);
   }
-  setThinkingLevel(level) {
-    this._thinkingLevel = level;
-    return this;
+  /** LRU 淘汰：仅淘汰非活动（未运行、未排队）的最久未用会话 */
+  evictIdleSessions() {
+    if (this._sessions.size <= this._maxSessions) return;
+    for (const [key, session] of this._sessions) {
+      if (this._sessions.size <= this._maxSessions) break;
+      if (session.isStreaming || session.lockHeld) continue;
+      if (session.idleResolvers.length > 0) {
+        const resolvers = session.idleResolvers.splice(0);
+        for (const resolve of resolvers) resolve();
+      }
+      this._sessions.delete(key);
+    }
   }
-  setStreamFn(fn) {
-    this._streamFn = fn;
-    return this;
+  /** 当前活跃的会话 key 列表（含默认会话） */
+  keys() {
+    return Array.from(this._sessions.keys());
   }
-  registerExtension(extension) {
-    this._extensions.register(extension);
-    return this;
+  /** 某会话是否存在（内存中） */
+  has(key) {
+    return this._sessions.has(key);
   }
-  useTransformer(transformer) {
-    this._transformers.push(transformer);
-    return this;
+  /**
+   * 获取同一会话的执行锁：返回 release 函数，调用后释放。
+   * 同一 sessionKey 的 run/stream 会串行执行，避免消息数组交错、
+   * abortController 互相覆盖、hydrate 竞态。
+   */
+  async acquire(session) {
+    let release;
+    const prev = session.queue;
+    session.queue = new Promise((resolve) => {
+      release = () => resolve();
+    });
+    await prev;
+    session.lockHeld = true;
+    return () => {
+      session.lockHeld = false;
+      release();
+    };
   }
-  /** 获取指定会话的消息列表（默认会话；会话不存在返回空数组） */
-  getMessages(sessionKey) {
-    const session = this._sessions.get(sessionKey ?? this._sessionKey);
+  /** 标记会话空闲并唤醒所有 waitForIdle 等待者 */
+  markIdle(session) {
+    session.isStreaming = false;
+    session.abortController = null;
+    if (session.idleResolvers.length > 0) {
+      const resolvers = session.idleResolvers.splice(0);
+      for (const resolve of resolvers) resolve();
+    }
+  }
+  /** 指定会话的消息列表深拷贝（避免外部直接修改会话内部状态；不存在返回空数组） */
+  getMessagesCopy(key) {
+    const session = this._sessions.get(key);
     if (!session) return [];
     const messages = session.messages;
     try {
@@ -1140,372 +1127,253 @@ var AgentRuntime = class _AgentRuntime {
       return JSON.parse(JSON.stringify(messages));
     }
   }
-  // ─── 核心运行逻辑 ───────────────────────────────────────────────
-  /** 解析请求路由的会话 key：request.sessionKey ?? 默认会话 key */
-  resolveSessionKey(request) {
-    return request.sessionKey ?? this._sessionKey;
+  /**
+   * 指定会话消息的只读视图（高频轮询用）：仅浅拷贝数组（O(n) 引用，
+   * 不做 structuredClone 深拷贝），消息对象与内部共享——调用方不得修改，
+   * 需要可变副本时用 getMessagesCopy。
+   */
+  peekMessages(key) {
+    return this._sessions.get(key)?.messages.slice() ?? [];
+  }
+  /** 等待指定会话空闲（基于 promise，无轮询；会话不存在或非运行中直接返回） */
+  async waitForIdle(key, timeoutMs) {
+    const session = this._sessions.get(key);
+    if (!session || !session.isStreaming) return;
+    if (timeoutMs === void 0) {
+      await new Promise((resolve) => {
+        session.idleResolvers.push(resolve);
+      });
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const resolver = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        const i = session.idleResolvers.indexOf(resolver);
+        if (i >= 0) session.idleResolvers.splice(i, 1);
+        reject(new Error(
+          `[Runtime] waitForIdle \u8D85\u65F6\uFF08${timeoutMs}ms\uFF09: ${key}`
+        ));
+      }, timeoutMs);
+      session.idleResolvers.push(resolver);
+    });
+  }
+  /** 清除指定会话消息（仅内存；下次 run 会从存储恢复） */
+  clearMessages(key) {
+    const session = this._sessions.get(key);
+    if (!session) return;
+    session.messages = [];
+    session.hydrated = false;
   }
   /**
-   * 获取（懒创建）会话状态。同一 Runtime 下不同 sessionKey 的消息历史、
-   * 串行队列、abort 控制相互独立；共享模型/工具/扩展/转换器。
-   * 超过 _maxSessions 时淘汰最久未用的非活动会话（仅清内存态，不删存储）。
+   * 删除指定会话（仅内存态）：等待在途任务完成后移除，返回被移除的会话。
    */
-  getSession(key) {
-    let session = this._sessions.get(key);
+  async remove(key) {
+    const session = this._sessions.get(key);
     if (session) {
+      await session.queue;
       this._sessions.delete(key);
-      this._sessions.set(key, session);
-      return session;
     }
-    session = createSessionState();
-    this._sessions.set(key, session);
-    this.evictIdleSessions();
     return session;
   }
-  /** LRU 淘汰：仅淘汰非活动（未运行、未排队）的最久未用会话 */
-  evictIdleSessions() {
-    if (this._sessions.size <= this._maxSessions) return;
-    for (const [key, session] of this._sessions) {
-      if (this._sessions.size <= this._maxSessions) break;
-      if (session.isStreaming || session.lockHeld) continue;
-      this._sessions.delete(key);
+  /** 关闭用：等待所有会话的在途任务完成后清空状态表 */
+  async drainAndClear() {
+    await Promise.allSettled(Array.from(this._sessions.values(), (s) => s.queue));
+    for (const session of this._sessions.values()) {
+      session.messages = [];
+      session.hydrated = false;
     }
+    this._sessions.clear();
   }
-  /** 当前活跃的会话 key 列表（含默认会话） */
-  getSessionKeys() {
-    return Array.from(this._sessions.keys());
+};
+
+// ../agent/runtime/session-persistence.ts
+var SessionPersistence = class {
+  constructor(_storage, _defaultModel, _store) {
+    this._storage = _storage;
+    this._defaultModel = _defaultModel;
+    this._store = _store;
+  }
+  _storage;
+  _defaultModel;
+  _store;
+  get storage() {
+    return this._storage;
   }
-  /** 某会话是否存在（内存中） */
-  hasSession(sessionKey) {
-    return this._sessions.has(sessionKey);
+  /** 从存储懒加载会话（串行化后无竞态，每个会话仅恢复一次） */
+  async hydrate(sessionKey, session) {
+    if (!this._storage) return;
+    if (session.hydrated) return;
+    session.hydrated = true;
+    const stored = await this._storage.load(sessionKey);
+    if (!stored) return;
+    session.messages = stored.messages;
+    session.createdAt = stored.createdAt;
   }
-  async run(request) {
-    const validation = validateRequest(request);
-    if (!validation.valid) {
-      const invalidResult = new ResultBuilder().error(`\u8BF7\u6C42\u6821\u9A8C\u5931\u8D25: ${validation.errors.join("; ")}`).build();
-      await this.emitTelemetry("onRunEnd", {
-        traceId: this.newTraceId(),
-        sessionKey: this.resolveSessionKey(request),
-        request,
-        durationMs: 0,
-        activeMs: 0,
-        queuedMs: 0,
-        turnCount: 0,
-        result: invalidResult,
-        success: false,
-        errorClass: "validation",
-        tokens: { input: 0, output: 0 }
-      });
-      return invalidResult;
-    }
-    const finalRequest = normalizeRequest(request);
-    const sessionKey = this.resolveSessionKey(finalRequest);
-    const traceId = this.newTraceId();
-    const queuedAt = Date.now();
-    await this.emitTelemetry("onRunStart", {
-      traceId,
-      sessionKey,
-      request: finalRequest,
-      queuedAt
-    });
-    const session = this.getSession(sessionKey);
-    const release = await this.acquire(session);
-    const queuedMs = Date.now() - queuedAt;
+  /** 整体保存指定会话（ephemeral 跳过；失败不影响运行结果） */
+  async persist(sessionKey, session) {
+    if (!this._storage) return;
+    const stored = {
+      key: sessionKey,
+      version: SESSION_VERSION,
+      messages: session.messages,
+      model: this.deriveModel(session.messages),
+      usage: this.sumUsage(session.messages),
+      createdAt: session.createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this._storage.save(sessionKey, stored);
+  }
+  /**
+   * 实时持久化指定会话：每轮 assistant 回复/工具结果完成后调用，
+   * 让运行中的会话随时可被持久化数据观测到。ephemeral 跳过；
+   * 存储失败仅告警，不影响对话循环继续。
+   */
+  async persistSafe(request, sessionKey) {
+    if (request.ephemeral || !this._storage) return;
     try {
-      return await this.runWithStorageLock(
-        finalRequest,
-        sessionKey,
-        () => this._run(finalRequest, sessionKey, session, traceId, queuedMs)
-      );
-    } finally {
-      release();
+      const session = this._store.peek(sessionKey);
+      if (!session) return;
+      await this.persist(sessionKey, session);
+    } catch (err) {
+      console.warn("[Runtime] \u4F1A\u8BDD\u6301\u4E45\u5316\u5931\u8D25:", err?.message);
     }
   }
-  async *stream(request) {
-    const validation = validateRequest(request);
-    if (!validation.valid) {
-      const message = `\u8BF7\u6C42\u6821\u9A8C\u5931\u8D25: ${validation.errors.join("; ")}`;
-      await this.emitTelemetry("onRunEnd", {
-        traceId: this.newTraceId(),
-        sessionKey: this.resolveSessionKey(request),
-        request,
-        durationMs: 0,
-        activeMs: 0,
-        queuedMs: 0,
-        turnCount: 0,
-        result: new ResultBuilder().error(message).build(),
-        success: false,
-        errorClass: "validation",
-        tokens: { input: 0, output: 0 }
-      });
-      yield { type: "error", content: message };
-      yield { type: "done" };
-      return;
+  /** 从消息中推导最后使用的模型 */
+  deriveModel(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role === "assistant" && msg.model) {
+        return {
+          provider: msg.provider ?? this._defaultModel().provider,
+          modelId: msg.model
+        };
+      }
     }
-    const finalRequest = normalizeRequest(request);
-    const sessionKey = this.resolveSessionKey(finalRequest);
-    const traceId = this.newTraceId();
-    const queuedAt = Date.now();
-    await this.emitTelemetry("onRunStart", {
-      traceId,
-      sessionKey,
-      request: finalRequest,
-      queuedAt
-    });
-    const session = this.getSession(sessionKey);
-    const release = await this.acquire(session);
-    const queuedMs = Date.now() - queuedAt;
-    try {
-      yield* this.streamWithStorageLock(
-        finalRequest,
-        sessionKey,
-        () => this._stream(finalRequest, sessionKey, session, traceId, queuedMs)
-      );
-    } finally {
-      release();
+    return null;
+  }
+  /** 汇总所有 assistant 消息的 token 用量（含 cache） */
+  sumUsage(messages) {
+    const usage = createEmptyUsage();
+    for (const msg of messages) {
+      if (msg.role === "assistant") {
+        const u = msg.usage;
+        if (u) {
+          usage.input += u.input;
+          usage.output += u.output;
+          usage.total += u.total;
+          usage.cacheRead = (usage.cacheRead ?? 0) + (u.cacheRead ?? 0);
+          usage.cacheWrite = (usage.cacheWrite ?? 0) + (u.cacheWrite ?? 0);
+          usage.reasoning = (usage.reasoning ?? 0) + (u.reasoning ?? 0);
+        }
+      }
     }
+    return usage;
   }
   /**
    * 非 ephemeral 请求在"读(load)-改(run)-写(save)"全程持有存储级锁，
    * 防止多进程并发写同一会话导致 last-write-wins 丢消息。
    * ephemeral / 无锁支持 / 无存储时直接执行。
    */
-  async runWithStorageLock(request, sessionKey, fn) {
-    const storage = this._sessionStorage;
-    if (request.ephemeral || !storage?.withLock) return fn();
-    return storage.withLock(sessionKey, fn);
+  async withStorageLock(request, sessionKey, fn) {
+    if (request.ephemeral || !this._storage?.withLock) return fn();
+    return this._storage.withLock(sessionKey, fn);
   }
   /** 流式版本：无法用回调包住生成器，改用手动锁（acquire/release） */
   async *streamWithStorageLock(request, sessionKey, gen) {
-    const storage = this._sessionStorage;
-    if (request.ephemeral || !storage?.acquireLock) {
+    if (request.ephemeral || !this._storage?.acquireLock) {
       yield* gen();
       return;
     }
-    const lock = await storage.acquireLock(sessionKey);
+    const lock = await this._storage.acquireLock(sessionKey);
     try {
       yield* gen();
     } finally {
       await lock.release();
     }
   }
-  async _run(request, sessionKey, session, traceId, queuedMs) {
-    const activeStartedAt = Date.now();
-    await this._hooks.beforeInitialize.promise(request);
-    await this._hooks.afterInitialize.promise(request);
-    const finalRequest = await this._hooks.beforeRun.promise(request);
-    if (!finalRequest.ephemeral) {
-      await this.hydrateSession(sessionKey, session);
-    }
-    const compilation = this.createCompilation(finalRequest, sessionKey, session, traceId);
-    compilation.messages.push(this.buildUserMessage(finalRequest));
+};
+
+// ../agent/runtime/telemetry.ts
+var RuntimeTelemetry = class {
+  constructor(_telemetry, _traceIdGenerator) {
+    this._telemetry = _telemetry;
+    this._traceIdGenerator = _traceIdGenerator;
+  }
+  _telemetry;
+  _traceIdGenerator;
+  /** traceId 生成：优先用注入的生成器（测试可确定性） */
+  newTraceId() {
+    return this._traceIdGenerator ? this._traceIdGenerator() : newTraceId();
+  }
+  /**
+   * 触发遥测回调。全可选、失败不阻断主流程。
+   */
+  async emit(event, info) {
+    const fn = this._telemetry?.[event];
+    if (!fn) return;
     try {
-      await this.runLoop(compilation, finalRequest, session);
-      const result = this.buildResult(compilation);
-      await this._hooks.beforeEmit.promise(result);
-      await this._hooks.afterEmit.promise(result);
-      await this._hooks.done.promise(result, finalRequest);
-      compilation.completed = true;
-      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
-      return result;
+      await Promise.resolve(fn(info));
     } catch (err) {
-      const error = err;
-      if (error?.name !== "AbortError") {
-        console.error("[Runtime] \u8FD0\u884C\u5931\u8D25:", error?.stack ?? error);
-      }
-      await this._hooks.failed.promise(error, finalRequest);
-      const result = new ResultBuilder().error(error.message).build();
-      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
-      return result;
-    } finally {
-      await this.persistSessionSafe(finalRequest, sessionKey);
-    }
-  }
-  async *_stream(request, sessionKey, session, traceId, queuedMs) {
-    const activeStartedAt = Date.now();
-    await this._hooks.beforeInitialize.promise(request);
-    await this._hooks.afterInitialize.promise(request);
-    const finalRequest = await this._hooks.beforeRun.promise(request);
-    if (!finalRequest.ephemeral) {
-      await this.hydrateSession(sessionKey, session);
-    }
-    const compilation = this.createCompilation(finalRequest, sessionKey, session, traceId);
-    compilation.messages.push(this.buildUserMessage(finalRequest));
-    try {
-      for await (const chunk of this.runLoopStream(compilation, finalRequest, session)) {
-        yield chunk;
-      }
-      const result = this.buildResult(compilation);
-      await this._hooks.beforeEmit.promise(result);
-      await this._hooks.afterEmit.promise(result);
-      await this._hooks.done.promise(result, finalRequest);
-      yield { type: "done", result };
-      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
-    } catch (err) {
-      const error = err;
-      if (error?.name !== "AbortError") {
-        console.error("[Runtime] \u6D41\u5F0F\u8FD0\u884C\u5931\u8D25:", error?.stack ?? error);
-      }
-      await this._hooks.failed.promise(error, finalRequest);
-      const result = new ResultBuilder().error(error.message).build();
-      yield { type: "error", content: error.message };
-      yield { type: "done", result };
-      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
-    } finally {
-      await this.persistSessionSafe(finalRequest, sessionKey);
-    }
-  }
-  createCompilation(request, sessionKey, session, traceId) {
-    return {
-      request,
-      graph: createTaskGraph(),
-      resources: [],
-      messages: (session ?? this.getSession(sessionKey ?? this._sessionKey)).messages,
-      completed: false,
-      traceId: traceId ?? this.newTraceId()
-    };
-  }
-  async close() {
-    await Promise.allSettled(Array.from(this._sessions.values(), (s) => s.queue));
-    for (const session of this._sessions.values()) {
-      session.messages = [];
-      session.hydrated = false;
+      console.warn(`[aipack] telemetry "${String(event)}" \u4E0A\u62A5\u5931\u8D25:`, err);
     }
-    this._sessions.clear();
-    this._extensions.clear();
-    this._transformers = [];
   }
-  // ─── 对话循环（同步） ───────────────────────────────────────────
-  async runLoop(compilation, request, session) {
-    session.isStreaming = true;
-    session.abortController = new AbortController();
-    const sessionKey = this.resolveSessionKey(request);
-    try {
-      let maxTurns = this._maxTurns;
-      let turnCount = 0;
-      while (maxTurns-- > 0) {
-        turnCount += 1;
-        await this.transformMessages(compilation, sessionKey);
-        await this.maybeCompactByThreshold(
-          compilation,
-          sessionKey,
-          session.abortController.signal
-        );
-        const assistantMessage = await this.streamModel(
-          compilation,
-          session.abortController.signal,
-          sessionKey
-        );
-        compilation.messages.push(assistantMessage);
-        await this.persistSessionSafe(request, sessionKey);
-        const toolCalls = extractToolCalls(assistantMessage.content);
-        if (toolCalls.length === 0) {
-          break;
-        }
-        const outcome = await this.executeToolCalls(
-          compilation,
-          toolCalls,
-          session.abortController.signal
-        );
-        await this.persistSessionSafe(request, sessionKey);
-        if (outcome.terminate) {
-          compilation.terminateReason = outcome.terminateReason ?? "terminated";
-          break;
-        }
-      }
-      if (maxTurns < 0) compilation.maxTurnsExhausted = true;
-      compilation.turnCount = turnCount;
-    } finally {
-      this.markIdle(session);
-    }
+  /** 组装并上报 run 级完成事件（run/stream 内部统一调用） */
+  async emitRunEnd(request, sessionKey, compilation, result, queuedMs, activeStartedAt, defaultModelId) {
+    const activeMs = Date.now() - activeStartedAt;
+    await this.emit("onRunEnd", {
+      traceId: compilation.traceId,
+      sessionKey,
+      // 请求未显式指定 model 时补实际模型（模型排行按 run 级 requests 统计，缺省会落入 'unknown'）
+      request: request.model ? request : { ...request, model: defaultModelId },
+      durationMs: activeMs + queuedMs,
+      activeMs,
+      queuedMs,
+      turnCount: compilation.turnCount ?? 0,
+      result,
+      success: result.success,
+      errorClass: this.runErrorClass(compilation),
+      tokens: {
+        input: result.usage.input ?? 0,
+        output: result.usage.output ?? 0,
+        cacheRead: result.usage.cacheRead,
+        cacheWrite: result.usage.cacheWrite
+      },
+      ttftMs: compilation.ttftMs
+    });
   }
-  // ─── 对话循环（流式） ───────────────────────────────────────────
-  async *runLoopStream(compilation, request, session) {
-    session.isStreaming = true;
-    session.abortController = new AbortController();
-    const sessionKey = this.resolveSessionKey(request);
-    try {
-      let maxTurns = this._maxTurns;
-      let turnCount = 0;
-      while (maxTurns-- > 0) {
-        turnCount += 1;
-        await this.transformMessages(compilation, sessionKey);
-        await this.maybeCompactByThreshold(
-          compilation,
-          sessionKey,
-          session.abortController.signal
-        );
-        const turn = this.modelTurnWithRecovery(
-          compilation,
-          session.abortController.signal,
-          sessionKey,
-          true
-          // stream 模式：同时统计首 token 延迟
-        );
-        let turnResult = await turn.next();
-        while (!turnResult.done) {
-          yield turnResult.value;
-          turnResult = await turn.next();
-        }
-        const assistantMessage = turnResult.value;
-        if (!assistantMessage) break;
-        compilation.messages.push(assistantMessage);
-        await this.persistSessionSafe(request, sessionKey);
-        const toolCalls = extractToolCalls(assistantMessage.content);
-        if (toolCalls.length === 0) {
-          break;
-        }
-        for (const toolCall of toolCalls) {
-          yield {
-            type: "tool_start",
-            toolName: toolCall.name,
-            toolCallId: toolCall.id
-          };
-        }
-        const outcome = await this.executeToolCalls(
-          compilation,
-          toolCalls,
-          session.abortController.signal
-        );
-        await this.persistSessionSafe(request, sessionKey);
-        for (let i = 0; i < toolCalls.length; i++) {
-          yield {
-            type: "tool_end",
-            toolName: toolCalls[i].name,
-            toolCallId: toolCalls[i].id,
-            isError: this.isErrorResult(outcome.results[i])
-          };
-        }
-        if (outcome.terminate) {
-          compilation.terminateReason = outcome.terminateReason ?? "terminated";
-          break;
-        }
+  /** run 级错误分类：terminate → 'terminated'；否则只看最后一条 assistant 消息（与 buildResult 的 result.success 同口径） */
+  runErrorClass(compilation) {
+    if (compilation.terminateReason) return "terminated";
+    const messages = compilation.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (m.role === "assistant") {
+        if (!m.errorMessage) return void 0;
+        const cls = errorClassFromMessage(m.errorMessage);
+        return cls ?? "unknown";
       }
-      if (maxTurns < 0) compilation.maxTurnsExhausted = true;
-      compilation.turnCount = turnCount;
-    } finally {
-      this.markIdle(session);
     }
+    return void 0;
   }
-  // ─── 工具执行 ───────────────────────────────────────────────────
-  /** 同步循环：执行工具调用并将结果消息按原顺序追加 */
-  async executeToolCalls(compilation, toolCalls, signal) {
-    const outcome = await this.runTools(toolCalls, signal, compilation.request, compilation.traceId);
-    for (let i = 0; i < toolCalls.length; i++) {
-      compilation.messages.push(
-        this.buildToolResultMessage(toolCalls[i], outcome.results[i])
-      );
-    }
-    return outcome;
+};
+
+// ../agent/runtime/tool-executor.ts
+var ToolExecutor = class {
+  constructor(_d) {
+    this._d = _d;
   }
+  _d;
   /**
    * 执行一组工具调用：parallelToolCalls 为 true 时并行，否则串行。
    * 返回 ToolExecutionOutcome：任一工具请求 terminate 即终止整个 run；
    * 串行模式下 terminate 后剩余工具生成 skipped 结果以保持配对完整。
    */
-  async runTools(toolCalls, signal, request, traceId) {
-    const execute = (tc) => this.executeTool(tc, signal, request, traceId);
-    if (this._parallelToolCalls && toolCalls.length > 1) {
+  async run(toolCalls, signal, request, traceId) {
+    const execute = (tc) => this.execute(tc, signal, request, traceId);
+    if (this._d.parallelToolCalls && toolCalls.length > 1) {
       const outcomes = await Promise.all(toolCalls.map(execute));
       const terminated = outcomes.find((o) => o.terminate);
       return {
@@ -1531,8 +1399,8 @@ var AgentRuntime = class _AgentRuntime {
     }
     return { results, terminate, terminateReason };
   }
-  async executeTool(toolCall, signal, request, traceId) {
-    const tool = this._globalTools.get(toolCall.name);
+  async execute(toolCall, signal, request, traceId) {
+    const tool = this._d.getTools().get(toolCall.name);
     if (!tool) {
       return {
         result: {
@@ -1546,27 +1414,43 @@ var AgentRuntime = class _AgentRuntime {
     if (tool.prepareArguments) {
       args = tool.prepareArguments(toolCall.arguments);
     }
-    if (this._permissionPolicy) {
+    if (!this._d.permissionPolicy) {
+      if (!this._d.permissionFailOpen) {
+        const reason = `no permissionPolicy configured (fail-closed by default). Configure RuntimeOptions.permissionPolicy (e.g. createAllowAllPolicy()) or explicitly set permissionFailOpen: true to allow unrestricted tool execution`;
+        await this._d.telemetry.emit("onPermissionDenied", {
+          traceId,
+          sessionKey: request.sessionKey ?? this._d.defaultSessionKey,
+          toolName: toolCall.name,
+          permissions: tool.permissions ?? [],
+          args,
+          reason: `permission denied for tool "${toolCall.name}": ${reason}`
+        });
+        return {
+          result: this.makeBlockedResult(`permission denied for tool "${toolCall.name}": ${reason}`),
+          terminate: false
+        };
+      }
+    } else {
       const permissionReq = {
         toolName: toolCall.name,
         permissions: tool.permissions ?? [],
         args,
-        sessionKey: request.sessionKey ?? this._sessionKey,
+        sessionKey: request.sessionKey ?? this._d.defaultSessionKey,
         request,
-        shared: this._extensionContext?.shared ?? /* @__PURE__ */ new Map()
+        shared: this._d.getShared() ?? /* @__PURE__ */ new Map()
       };
-      const decision = await this._permissionPolicy.check(permissionReq);
+      const decision = await this._d.permissionPolicy.check(permissionReq);
       let allowed = decision === "allow";
       if (decision === "confirm") {
-        allowed = this._permissionPolicy.confirm ? await this._permissionPolicy.confirm(permissionReq) : false;
+        allowed = this._d.permissionPolicy.confirm ? await this._d.permissionPolicy.confirm(permissionReq) : false;
       }
       if (decision === "pending") {
-        if (this._approvals) {
-          const approval = this._approvals.create(permissionReq, {
-            timeoutMs: this._approvalTimeoutMs,
+        if (this._d.approvals) {
+          const approval = this._d.approvals.create(permissionReq, {
+            timeoutMs: this._d.approvalTimeoutMs,
             signal
           });
-          await this.emitTelemetry("onApprovalPending", {
+          await this._d.telemetry.emit("onApprovalPending", {
             traceId,
             sessionKey: permissionReq.sessionKey,
             approvalId: approval.id,
@@ -1575,9 +1459,9 @@ var AgentRuntime = class _AgentRuntime {
             args,
             expiresAt: approval.expiresAt
           });
-          const outcome = await this._approvals.wait(approval);
+          const outcome = await this._d.approvals.wait(approval);
           allowed = outcome.status === "approved";
-          await this.emitTelemetry("onApprovalResolved", {
+          await this._d.telemetry.emit("onApprovalResolved", {
             traceId,
             sessionKey: permissionReq.sessionKey,
             approvalId: approval.id,
@@ -1591,7 +1475,7 @@ var AgentRuntime = class _AgentRuntime {
       }
       if (!allowed) {
         const reason = `permission denied by policy for tool "${toolCall.name}"`;
-        await this.emitTelemetry("onPermissionDenied", {
+        await this._d.telemetry.emit("onPermissionDenied", {
           traceId,
           sessionKey: permissionReq.sessionKey,
           toolName: toolCall.name,
@@ -1605,10 +1489,10 @@ var AgentRuntime = class _AgentRuntime {
         };
       }
     }
-    const { signal: timedSignal, clear } = withTimeoutSignal(signal, this._toolTimeoutMs);
+    const { signal: timedSignal, clear } = withTimeoutSignal(signal, this._d.toolTimeoutMs);
     try {
       const beforeCtx = this.buildToolCallContext(toolCall, tool, args, request, timedSignal);
-      const before = await this._hooks.beforeToolCall.promise(
+      const before = await this._d.hooks.beforeToolCall.promise(
         { block: false, terminate: false, args },
         beforeCtx
       );
@@ -1640,10 +1524,10 @@ var AgentRuntime = class _AgentRuntime {
         };
       }
       const status = toolResultStatus(result);
-      await this.emitTelemetry("onToolCall", {
+      await this._d.telemetry.emit("onToolCall", {
         traceId,
         spanId: newSpanId(),
-        sessionKey: request.sessionKey ?? this._sessionKey,
+        sessionKey: request.sessionKey ?? this._d.defaultSessionKey,
         toolName: toolCall.name,
         args,
         durationMs: Date.now() - toolStartedAt,
@@ -1653,7 +1537,7 @@ var AgentRuntime = class _AgentRuntime {
         errorClass: status === "error" ? errorClassFromMessage(String(result.details?.error ?? "")) ?? "tool_error" : void 0
       });
       const afterCtx = this.buildToolCallContext(toolCall, tool, args, request, timedSignal);
-      const after = await this._hooks.afterToolCall.promise(
+      const after = await this._d.hooks.afterToolCall.promise(
         { result, terminate: false },
         afterCtx
       );
@@ -1689,13 +1573,14 @@ var AgentRuntime = class _AgentRuntime {
       toolCall,
       tool,
       args,
-      sessionKey: request.sessionKey ?? this._sessionKey,
+      sessionKey: request.sessionKey ?? this._d.defaultSessionKey,
       request,
-      shared: this._extensionContext?.shared ?? /* @__PURE__ */ new Map(),
+      shared: this._d.getShared() ?? /* @__PURE__ */ new Map(),
       signal
     };
   }
-  buildToolResultMessage(toolCall, result) {
+  /** 工具结果 → toolResult 消息（写入会话历史） */
+  buildResultMessage(toolCall, result) {
     return {
       role: "toolResult",
       content: result.content,
@@ -1705,294 +1590,69 @@ var AgentRuntime = class _AgentRuntime {
       timestamp: Date.now()
     };
   }
-  buildUserMessage(request) {
-    if (request.media && request.media.length > 0) {
-      const blocks = [
-        createTextContent(request.message),
-        ...request.media.filter(Boolean).map(buildImageContent)
-      ];
-      return {
-        role: "user",
-        content: blocks,
-        timestamp: Date.now()
-      };
+};
+
+// ../agent/transformer/index.ts
+function ensureToolPairing(messages) {
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        for (const tc of extractToolCalls(content)) {
+          toolCallIds.add(tc.id);
+        }
+      }
     }
-    return {
-      role: "user",
-      content: request.message,
-      timestamp: Date.now()
-    };
-  }
-  // ─── 内部方法 ───────────────────────────────────────────────────
-  /**
-   * 获取同一会话的执行锁：返回 release 函数，调用后释放。
-   * 同一 sessionKey 的 run/stream 会串行执行，避免消息数组交错、
-   * abortController 互相覆盖、hydrate 竞态。
-   */
-  async acquire(session) {
-    let release;
-    const prev = session.queue;
-    session.queue = new Promise((resolve) => {
-      release = () => resolve();
-    });
-    await prev;
-    session.lockHeld = true;
-    return () => {
-      session.lockHeld = false;
-      release();
-    };
-  }
-  /** 标记会话空闲并唤醒所有 waitForIdle 等待者 */
-  markIdle(session) {
-    session.isStreaming = false;
-    session.abortController = null;
-    if (session.idleResolvers.length > 0) {
-      const resolvers = session.idleResolvers.splice(0);
-      for (const resolve of resolvers) resolve();
+    if (msg.role === "toolResult") {
+      toolResultIds.add(msg.toolCallId);
     }
   }
-  // ─── 会话持久化 ─────────────────────────────────────────────────
-  /** 从存储懒加载会话（串行化后无竞态，每个会话仅恢复一次） */
-  async hydrateSession(sessionKey, session) {
-    if (!this._sessionStorage) return;
-    if (session.hydrated) return;
-    session.hydrated = true;
-    const stored = await this._sessionStorage.load(sessionKey);
-    if (!stored) return;
-    session.messages = stored.messages;
-    session.createdAt = stored.createdAt;
+  const orphanedCalls = /* @__PURE__ */ new Set();
+  const orphanedResults = /* @__PURE__ */ new Set();
+  for (const id of toolCallIds) {
+    if (!toolResultIds.has(id)) orphanedCalls.add(id);
   }
-  /** 整体保存指定会话（ephemeral 跳过；失败不影响运行结果） */
-  async persistSession(sessionKey, session) {
-    if (!this._sessionStorage) return;
-    const stored = {
-      key: sessionKey,
-      version: SESSION_VERSION,
-      messages: session.messages,
-      model: this.deriveModel(session.messages),
-      usage: this.sumUsage(session.messages),
-      createdAt: session.createdAt,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await this._sessionStorage.save(sessionKey, stored);
+  for (const id of toolResultIds) {
+    if (!toolCallIds.has(id)) orphanedResults.add(id);
   }
-  /**
-   * 实时持久化指定会话：每轮 assistant 回复/工具结果完成后调用，
-   * 让运行中的会话随时可被持久化数据观测到。ephemeral 跳过；
-   * 存储失败仅告警，不影响对话循环继续。
-   */
-  async persistSessionSafe(request, sessionKey) {
-    if (request.ephemeral || !this._sessionStorage) return;
-    try {
-      const session = this._sessions.get(sessionKey);
-      if (!session) return;
-      await this.persistSession(sessionKey, session);
-    } catch (err) {
-      console.warn("[Runtime] \u4F1A\u8BDD\u6301\u4E45\u5316\u5931\u8D25:", err?.message);
-    }
-  }
-  /** 从消息中推导最后使用的模型 */
-  deriveModel(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const msg = messages[i];
-      if (msg.role === "assistant" && msg.model) {
-        return {
-          provider: msg.provider ?? this._model.provider,
-          modelId: msg.model
-        };
-      }
-    }
-    return null;
-  }
-  /** 汇总所有 assistant 消息的 token 用量（含 cache） */
-  sumUsage(messages) {
-    const usage = createEmptyUsage();
-    for (const msg of messages) {
-      if (msg.role === "assistant") {
-        const u = msg.usage;
-        if (u) {
-          usage.input += u.input;
-          usage.output += u.output;
-          usage.total += u.total;
-          usage.cacheRead = (usage.cacheRead ?? 0) + (u.cacheRead ?? 0);
-          usage.cacheWrite = (usage.cacheWrite ?? 0) + (u.cacheWrite ?? 0);
-          usage.reasoning = (usage.reasoning ?? 0) + (u.reasoning ?? 0);
-        }
-      }
-    }
-    return usage;
-  }
-  /** 链式执行上下文转换器（按数组顺序，上一个输出作为下一个输入） */
-  async transformMessages(compilation, sessionKey) {
-    if (this._transformers.length === 0) {
-      return;
-    }
-    let resources = messagesToResources(compilation.messages);
-    const context = {
-      graph: compilation.graph,
-      runtime: {
-        sessionKey,
-        turn: compilation.messages.length,
-        contextWindow: this._model.contextWindow,
-        maxTokens: this._model.maxTokens,
-        contextBudgetRatio: this._contextBudgetRatio
-      }
-    };
-    for (const transformer of this._transformers) {
-      try {
-        resources = await transformer.transform(resources, context);
-      } catch (err) {
-        console.warn(
-          `[Runtime] \u8F6C\u6362\u5668 "${transformer.name}" \u5931\u8D25\uFF0C\u5DF2\u8DF3\u8FC7:`,
-          err?.message ?? err
-        );
-      }
-    }
-    const messages = resourcesToMessages(resources);
-    compilation.messages.splice(0, compilation.messages.length, ...messages);
-  }
-  buildContext(messages) {
-    const tools = Array.from(this._globalTools.values());
-    return {
-      systemPrompt: this._systemPrompt,
-      // compactionSummary / stateSnapshot 为内部扩展 role，provider 适配层
-      // 仅支持 user/assistant/toolResult，发出前统一转为带标注的 user 消息
-      messages: messages.filter((m) => m.role !== "system").map((m) => {
-        const role = m.role;
-        if (role === "compactionSummary") return this.compactionSummaryToUser(m);
-        if (role === "stateSnapshot") return this.stateSnapshotToUser(m);
-        return m;
-      }),
-      tools: tools.length > 0 ? tools : void 0
-    };
-  }
-  /** compactionSummary 消息 → user 消息（所有 provider 均兼容 user role） */
-  compactionSummaryToUser(msg) {
-    const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
-    return {
-      role: "user",
-      content: `${COMPACTION_USER_PREFIX}
-${text}`,
-      timestamp: msg.timestamp
-    };
-  }
-  /** stateSnapshot 消息 → user 消息（所有 provider 均兼容 user role） */
-  stateSnapshotToUser(msg) {
-    const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
-    return {
-      role: "user",
-      content: `${STATE_SNAPSHOT_USER_PREFIX}
-${text}`,
-      timestamp: msg.timestamp
-    };
-  }
-  async streamModel(compilation, signal, sessionKey) {
-    const turn = this.modelTurnWithRecovery(compilation, signal, sessionKey, false);
-    let r = await turn.next();
-    while (!r.done) r = await turn.next();
-    return r.value ?? this.emptyAssistantMessage();
-  }
-  /** 空的 assistant 消息（流异常中断无 done/error 事件时的兜底，与旧 streamModel 行为一致） */
-  emptyAssistantMessage() {
-    return {
-      role: "assistant",
-      content: [],
-      stopReason: "stop",
-      usage: createEmptyUsage(),
-      model: this._model.id,
-      provider: this._model.provider,
-      timestamp: Date.now()
-    };
+  if (orphanedCalls.size === 0 && orphanedResults.size === 0) {
+    return messages;
   }
-  /**
-   * 单回合模型调用 + 上下文溢出自动恢复闭环。
-   *
-   * 检测（isContextOverflow，统一传入 model.contextWindow / content / maxTokens，
-   * 覆盖显式错误 / 静默溢出 / 输入截断溢出 / 输出 thinking 耗尽 / 输出打满 五模式）
-   * → 丢弃失败的 assistant 消息 → 截断会话历史 → 同回合重试（不消耗回合数，
-   * 上限 OVERFLOW_RECOVERY_LIMIT）：
-   *
-   * - 显式错误 / 零产出截断溢出 / thinking 耗尽溢出 / 输出打满溢出：丢弃失败
-   *   消息后重试；流式路径吞掉可恢复的 error chunk（消费者看不到瞬态错误），
-   *   不可恢复时补发。
-   * - 静默溢出（stop + 有完整产出）：保留回复，仅压缩旧上下文供后续轮次。
-   * - 恢复耗尽或单请求超窗（无可丢弃）：返回最后一次错误消息，维持旧行为。
-   *
-   * 流式路径 yield 模型事件 chunk；非流式路径由 streamModel 消费（chunk 丢弃）。
-   * 返回最终 assistant 消息；无 done/error 事件时返回 null。
-   */
-  async *modelTurnWithRecovery(compilation, signal, sessionKey, stream) {
-    const contextWindow = this._model.contextWindow;
-    const maxTokens = this._model.maxTokens;
-    let recoveries = 0;
-    const toProbe = (m) => ({
-      stopReason: m.stopReason,
-      errorMessage: m.errorMessage,
-      usage: m.usage,
-      content: m.content,
-      maxTokens
-    });
-    while (true) {
-      let assistant = null;
-      let suppressed = null;
-      for await (const event of this.streamModelEvents(compilation, signal, stream)) {
-        if (event.type === "error") {
-          const msg = event.message;
-          if (recoveries < OVERFLOW_RECOVERY_LIMIT && isContextOverflow(toProbe(msg), contextWindow)) {
-            suppressed = msg;
-            continue;
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        const filteredContent = content.filter((block) => {
+          if (block.type === "toolCall") {
+            return !orphanedCalls.has(block.id);
           }
-          const chunk = this.streamEventToChunk(event);
-          if (chunk) yield chunk;
-          assistant = msg;
-        } else {
-          const chunk = this.streamEventToChunk(event);
-          if (chunk) yield chunk;
-          if (event.type === "done") assistant = event.message;
-        }
+          return true;
+        });
+        if (filteredContent.length === 0 && content.length > 0) continue;
+        result.push({ ...msg, content: filteredContent });
+      } else {
+        result.push(msg);
       }
-      const final = assistant ?? suppressed;
-      if (!final) return null;
-      if (isContextOverflow(toProbe(final), contextWindow)) {
-        const output = final.usage?.output ?? 0;
-        const blocks = Array.isArray(final.content) ? final.content : null;
-        const hasMeaningfulText = blocks?.some(
-          (b) => b.type === "text" && "text" in b && typeof b.text === "string" && b.text.trim().length > 0
-        );
-        const hasToolCall = blocks?.some((b) => b.type === "toolCall");
-        const thinkingOnly = blocks ? !hasMeaningfulText && !hasToolCall && blocks.some((b) => b.type === "thinking") : false;
-        const outputFull = maxTokens > 0 && output >= Math.floor(maxTokens * 0.95);
-        const failed = final.stopReason === "error" || output === 0 || thinkingOnly || outputFull;
-        if (failed && recoveries < OVERFLOW_RECOVERY_LIMIT) {
-          recoveries += 1;
-          if (await this.recoverFromOverflow(compilation, recoveries, sessionKey, signal)) {
-            const reason = thinkingOnly ? "thinking \u8017\u5C3D" : outputFull ? "output \u6253\u6EE1" : final.stopReason;
-            console.warn(
-              `[Runtime] \u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF08${reason}\uFF09\uFF0C\u5DF2\u538B\u7F29\u5386\u53F2\u5E76\u540C\u56DE\u5408\u91CD\u8BD5\uFF08${recoveries}/${OVERFLOW_RECOVERY_LIMIT}\uFF09`
-            );
-            await this.emitTelemetry("onRetry", {
-              traceId: compilation.traceId,
-              provider: this._model.provider,
-              modelId: this._model.id,
-              attempt: recoveries,
-              errorClass: "context-overflow",
-              delayMs: 0,
-              willRetry: true
-            });
-            continue;
-          }
-          if (suppressed) {
-            yield { type: "error", content: final.errorMessage || "\u6A21\u578B\u8C03\u7528\u51FA\u9519" };
-          }
-          return final;
-        }
-        if (failed) return final;
-        await this.recoverFromOverflow(compilation, 1, sessionKey, signal);
-        console.warn("[Runtime] \u68C0\u6D4B\u5230\u9759\u9ED8\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF08usage \u8D85\u7A97\uFF09\uFF0C\u5DF2\u538B\u7F29\u5386\u53F2\u6D88\u606F");
+    } else if (msg.role === "toolResult") {
+      if (!orphanedResults.has(msg.toolCallId)) {
+        result.push(msg);
       }
-      return final;
+    } else {
+      result.push(msg);
     }
   }
+  return result;
+}
+
+// ../agent/runtime/compactor.ts
+var ContextCompactor = class {
+  constructor(_d) {
+    this._d = _d;
+  }
+  _d;
   /**
    * 计算溢出恢复的截断点：按 token 预算从最旧消息开始丢弃。
    *
@@ -2003,10 +1663,10 @@ ${text}`,
    * 最小集，单条请求即超窗，无法恢复。
    */
   computeOverflowSplit(messages, recovery) {
-    const contextWindow = this._model.contextWindow;
+    const contextWindow = this._d.getModel().contextWindow;
     if (!contextWindow || contextWindow <= 0) return 0;
     const target = Math.max(
-      Math.floor(contextWindow * this._contextBudgetRatio * 0.5 ** recovery),
+      Math.floor(contextWindow * this._d.contextBudgetRatio * 0.5 ** recovery),
       1
     );
     let total = 0;
@@ -2034,7 +1694,7 @@ ${text}`,
     const messages = compilation.messages;
     const split = this.computeOverflowSplit(messages, recovery);
     if (split <= 0) return false;
-    const useCompaction = !!this._compaction && this._compaction.enabled !== false && this._compaction.onOverflow !== false;
+    const useCompaction = !!this._d.compaction && this._d.compaction.enabled !== false && this._d.compaction.onOverflow !== false;
     if (useCompaction) {
       await this.compactOrTruncate(
         messages,
@@ -2057,30 +1717,17 @@ ${text}`,
    * 其余部分摘要替换；摘要失败降级硬截断。
    */
   async maybeCompactByThreshold(compilation, sessionKey, signal) {
-    if (!this._compaction || this._compaction.enabled === false) return;
-    const contextWindow = this._model.contextWindow;
+    if (!this._d.compaction || this._d.compaction.enabled === false) return;
+    const contextWindow = this._d.getModel().contextWindow;
     if (!contextWindow || contextWindow <= 0) return;
     const messages = compilation.messages;
     const triggerTokens = Math.floor(
-      contextWindow * (this._compaction?.triggerRatio ?? this._contextBudgetRatio)
+      contextWindow * (this._d.compaction?.triggerRatio ?? this._d.contextBudgetRatio)
     );
     let total = 0;
     for (const m of messages) total += estimateMessageTokens(m);
     if (total <= triggerTokens) return;
-    const targetTokens = Math.floor(
-      contextWindow * (this._compaction?.targetRatio ?? 0.5)
-    );
-    const keepTokens = Math.max(Math.floor(targetTokens / 2), 1);
-    let kept = 0;
-    let split = messages.length;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (kept >= keepTokens) {
-        split = i + 1;
-        break;
-      }
-      kept += estimateMessageTokens(messages[i]);
-      split = i;
-    }
+    const split = this.computeKeepSplit(messages, contextWindow);
     if (split <= 0 || split >= messages.length) return;
     const mode = await this.compactOrTruncate(
       messages,
@@ -2095,20 +1742,12 @@ ${text}`,
     );
   }
   /**
-   * 手动压缩指定会话（交互命令 /compact 等）：跳过阈值判断，
-   * 直接将历史压缩至 targetRatio 保留量（复用 maybeCompactByThreshold
-   * 的保留段计算与 compactOrTruncate 执行路径），压缩后持久化。
+   * 保留段计算：从尾部累计保留最新消息，保留量为压缩目标（contextWindow ×
+   * targetRatio）的一半。返回被压缩段的结束下标；messages[0..split) 为被压缩段。
    */
-  async compact(sessionKey) {
-    if (!this._compaction || this._compaction.enabled === false) return null;
-    const key = sessionKey ?? this._sessionKey;
-    const session = this.getSession(key);
-    const messages = session.messages;
-    if (messages.length === 0) return null;
-    const contextWindow = this._model.contextWindow;
-    if (!contextWindow || contextWindow <= 0) return null;
+  computeKeepSplit(messages, contextWindow) {
     const targetTokens = Math.floor(
-      contextWindow * (this._compaction.targetRatio ?? 0.5)
+      contextWindow * (this._d.compaction?.targetRatio ?? 0.5)
     );
     const keepTokens = Math.max(Math.floor(targetTokens / 2), 1);
     let kept = 0;
@@ -2121,21 +1760,7 @@ ${text}`,
       kept += estimateMessageTokens(messages[i]);
       split = i;
     }
-    if (split <= 0 || split >= messages.length) return null;
-    const mode = await this.compactOrTruncate(
-      messages,
-      split,
-      key,
-      `manual-${Date.now().toString(36)}`,
-      new AbortController().signal,
-      "threshold"
-    );
-    try {
-      await this.persistSession(key, session);
-    } catch (err) {
-      console.warn("[Runtime] \u624B\u52A8\u538B\u7F29\u540E\u6301\u4E45\u5316\u5931\u8D25:", err?.message);
-    }
-    return mode;
+    return split;
   }
   /**
    * 执行压缩：messages[0..split) 为被压缩段，原地替换。
@@ -2150,10 +1775,10 @@ ${text}`,
     const tokensBefore = messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
     let mode = "truncate";
     let summaryText = "";
-    const summaryEnabled = !!this._compaction && this._compaction.enabled !== false;
+    const summaryEnabled = !!this._d.compaction && this._d.compaction.enabled !== false;
     if (summaryEnabled && compacted.length > 0) {
       const summaryBudget = Math.floor(
-        this._model.contextWindow * COMPACTION_SUMMARY_BUDGET_RATIO
+        this._d.getModel().contextWindow * COMPACTION_SUMMARY_BUDGET_RATIO
       );
       const inputText = compacted.map((m) => messageToSummaryLine(m)).filter((line) => line.length > 0).join("\n");
       if (inputText && estimateTextTokens(inputText) <= summaryBudget) {
@@ -2180,7 +1805,7 @@ ${text}`,
       messages.splice(0, messages.length, ...kept);
       tokensAfter = kept.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
     }
-    await this.emitTelemetry("onCompaction", {
+    await this._d.telemetry.emit("onCompaction", {
       traceId,
       sessionKey,
       mode,
@@ -2197,7 +1822,7 @@ ${text}`,
    * 由调用方降级硬截断——摘要失败不影响主流程。
    */
   async summarizeMessages(inputText, sessionKey, traceId, signal) {
-    const prompt = this._compaction?.prompt ?? DEFAULT_COMPACTION_PROMPT;
+    const prompt = this._d.compaction?.prompt ?? DEFAULT_COMPACTION_PROMPT;
     const context = {
       systemPrompt: prompt,
       messages: [{ role: "user", content: inputText, timestamp: Date.now() }]
@@ -2207,7 +1832,7 @@ ${text}`,
     let usage;
     let failed = false;
     try {
-      for await (const event of this._streamFn(this._model, context, { signal })) {
+      for await (const event of this._d.getStreamFn()(this._d.getModel(), context, { signal })) {
         if (event.type === "text_delta") {
           text += event.delta;
         } else if (event.type === "error") {
@@ -2225,11 +1850,11 @@ ${text}`,
       return null;
     }
     if (failed || !text.trim()) return null;
-    await this.emitTelemetry("onModelCall", {
+    await this._d.telemetry.emit("onModelCall", {
       traceId,
       spanId: newSpanId(),
       sessionKey,
-      modelId: this._model.id,
+      modelId: this._d.getModel().id,
       attempts: 1,
       inputTokens: usage?.input ?? estimateTextTokens(inputText),
       outputTokens: usage?.output ?? estimateTextTokens(text),
@@ -2246,30 +1871,148 @@ ${text}`,
       timestamp: Date.now()
     };
   }
-  /**
-   * 统一模型调用埋点生成器：run()（streamModel）与 stream()（runLoopStream）两路径共用。
-   * 职责：模型调用计时、spanId、attempts 累计、onRetry 转发、onModelCall 上报
-   * （含 tokens / cost / errorClass / ttft）。
-   */
-  async *streamModelEvents(compilation, signal, stream) {
-    const sessionKey = this.resolveSessionKey(compilation.request);
-    const modelStartedAt = Date.now();
+};
+
+// ../agent/runtime/model-turn.ts
+var ModelTurnRunner = class {
+  constructor(_d) {
+    this._d = _d;
+  }
+  _d;
+  async streamModel(compilation, signal, sessionKey) {
+    const turn = this.modelTurnWithRecovery(compilation, signal, sessionKey, false);
+    let r = await turn.next();
+    while (!r.done) r = await turn.next();
+    return r.value ?? this.emptyAssistantMessage();
+  }
+  /** 空的 assistant 消息（流异常中断无 done/error 事件时的兜底） */
+  emptyAssistantMessage() {
+    const model = this._d.getModel();
+    return {
+      role: "assistant",
+      content: [],
+      stopReason: "stop",
+      usage: createEmptyUsage(),
+      model: model.id,
+      provider: model.provider,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * 单回合模型调用 + 上下文溢出自动恢复闭环。
+   *
+   * 检测（isContextOverflow，统一传入 model.contextWindow / content / maxTokens，
+   * 覆盖显式错误 / 静默溢出 / 输入截断溢出 / 输出 thinking 耗尽 / 输出打满 五模式）
+   * → 丢弃失败的 assistant 消息 → 截断会话历史 → 同回合重试（不消耗回合数，
+   * 上限 OVERFLOW_RECOVERY_LIMIT）：
+   *
+   * - 显式错误 / 零产出截断溢出 / thinking 耗尽溢出 / 输出打满溢出：丢弃失败
+   *   消息后重试；流式路径吞掉可恢复的 error chunk（消费者看不到瞬态错误），
+   *   不可恢复时补发。
+   * - 静默溢出（stop + 有完整产出）：保留回复，仅压缩旧上下文供后续轮次。
+   * - 恢复耗尽或单请求超窗（无可丢弃）：返回最后一次错误消息，维持旧行为。
+   *
+   * 流式路径 yield 模型事件 chunk；非流式路径由 streamModel 消费（chunk 丢弃）。
+   * 返回最终 assistant 消息；无 done/error 事件时返回 null。
+   */
+  async *modelTurnWithRecovery(compilation, signal, sessionKey, stream) {
+    const model = this._d.getModel();
+    const contextWindow = model.contextWindow;
+    const maxTokens = model.maxTokens;
+    let recoveries = 0;
+    const toProbe = (m) => ({
+      stopReason: m.stopReason,
+      errorMessage: m.errorMessage,
+      usage: m.usage,
+      content: m.content,
+      maxTokens
+    });
+    while (true) {
+      let assistant = null;
+      let suppressed = null;
+      for await (const event of this.streamModelEvents(compilation, signal, stream)) {
+        if (event.type === "error") {
+          const msg = event.message;
+          if (recoveries < OVERFLOW_RECOVERY_LIMIT && isContextOverflow(toProbe(msg), contextWindow)) {
+            suppressed = msg;
+            continue;
+          }
+          const chunk = streamEventToChunk(event);
+          if (chunk) yield chunk;
+          assistant = msg;
+        } else {
+          const chunk = streamEventToChunk(event);
+          if (chunk) yield chunk;
+          if (event.type === "done") assistant = event.message;
+        }
+      }
+      const final = assistant ?? suppressed;
+      if (!final) return null;
+      if (isContextOverflow(toProbe(final), contextWindow)) {
+        const output = final.usage?.output ?? 0;
+        const blocks = Array.isArray(final.content) ? final.content : null;
+        const hasMeaningfulText = blocks?.some(
+          (b) => b.type === "text" && "text" in b && typeof b.text === "string" && b.text.trim().length > 0
+        );
+        const hasToolCall = blocks?.some((b) => b.type === "toolCall");
+        const thinkingOnly = blocks ? !hasMeaningfulText && !hasToolCall && blocks.some((b) => b.type === "thinking") : false;
+        const outputFull = maxTokens > 0 && output >= Math.floor(maxTokens * 0.95);
+        const failed = final.stopReason === "error" || output === 0 || thinkingOnly || outputFull;
+        if (failed && recoveries < OVERFLOW_RECOVERY_LIMIT) {
+          recoveries += 1;
+          if (await this._d.compactor.recoverFromOverflow(compilation, recoveries, sessionKey, signal)) {
+            const reason = thinkingOnly ? "thinking \u8017\u5C3D" : outputFull ? "output \u6253\u6EE1" : final.stopReason;
+            console.warn(
+              `[Runtime] \u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF08${reason}\uFF09\uFF0C\u5DF2\u538B\u7F29\u5386\u53F2\u5E76\u540C\u56DE\u5408\u91CD\u8BD5\uFF08${recoveries}/${OVERFLOW_RECOVERY_LIMIT}\uFF09`
+            );
+            await this._d.telemetry.emit("onRetry", {
+              traceId: compilation.traceId,
+              provider: model.provider,
+              modelId: model.id,
+              attempt: recoveries,
+              errorClass: "context-overflow",
+              delayMs: 0,
+              willRetry: true
+            });
+            continue;
+          }
+          if (suppressed) {
+            yield { type: "error", content: final.errorMessage || "\u6A21\u578B\u8C03\u7528\u51FA\u9519" };
+          }
+          return final;
+        }
+        if (failed) return final;
+        await this._d.compactor.recoverFromOverflow(compilation, 1, sessionKey, signal);
+        console.warn("[Runtime] \u68C0\u6D4B\u5230\u9759\u9ED8\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF08usage \u8D85\u7A97\uFF09\uFF0C\u5DF2\u538B\u7F29\u5386\u53F2\u6D88\u606F");
+      }
+      return final;
+    }
+  }
+  /**
+   * 统一模型调用埋点生成器：run()（streamModel）与 stream()（runLoopStream）两路径共用。
+   * 职责：模型调用计时、spanId、attempts 累计、onRetry 转发、onModelCall 上报
+   * （含 tokens / cost / errorClass / ttft）。
+   */
+  async *streamModelEvents(compilation, signal, stream) {
+    const model = this._d.getModel();
+    const sessionKey = this._d.resolveSessionKey(compilation.request);
+    const modelStartedAt = Date.now();
     const spanId = newSpanId();
     let attempts = 1;
     let ttftAt;
     let lastAssistant;
     const options = { signal };
-    if (this._thinkingLevel !== "off" && this._model.reasoning) {
-      options.reasoning = this._thinkingLevel;
+    if (this._d.getThinkingLevel() !== "off" && model.reasoning) {
+      options.reasoning = this._d.getThinkingLevel();
     }
     options.onRetryAttempt = (info) => {
       attempts += 1;
-      void this.emitTelemetry("onRetry", {
+      void this._d.telemetry.emit("onRetry", {
         traceId: compilation.traceId,
         spanId,
         // P2：重试明细关联到本模型调用 span
-        provider: this._model.provider,
-        modelId: this._model.id,
+        provider: model.provider,
+        modelId: model.id,
         attempt: info.attempt,
         errorClass: classifyError(info.error),
         status: statusOfRetryError(info.error),
@@ -2278,10 +2021,10 @@ ${text}`,
       });
     };
     try {
-      const context = await this._hooks.beforeModelCall.promise(
+      const context = await this._d.hooks.beforeModelCall.promise(
         this.buildContext(compilation.messages)
       );
-      for await (const event of this._streamFn(this._model, context, options)) {
+      for await (const event of this._d.getStreamFn()(model, context, options)) {
         if (stream && event.type === "text_delta" && ttftAt === void 0) {
           ttftAt = Date.now();
         }
@@ -2293,11 +2036,11 @@ ${text}`,
     } finally {
       const assistant = lastAssistant;
       const errorClass = assistant?.errorMessage ? errorClassFromMessage(assistant.errorMessage) ?? "unknown" : void 0;
-      await this.emitTelemetry("onModelCall", {
+      await this._d.telemetry.emit("onModelCall", {
         traceId: compilation.traceId,
         spanId,
         sessionKey,
-        modelId: this._model.id,
+        modelId: model.id,
         attempts,
         inputTokens: assistant?.usage?.input ?? 0,
         outputTokens: assistant?.usage?.output ?? 0,
@@ -2312,164 +2055,718 @@ ${text}`,
       }
     }
   }
+  buildContext(messages) {
+    const tools = Array.from(this._d.getTools().values());
+    return {
+      systemPrompt: this._d.getSystemPrompt(),
+      // compactionSummary / stateSnapshot 为内部扩展 role，provider 适配层
+      // 仅支持 user/assistant/toolResult，发出前统一转为带标注的 user 消息
+      messages: messages.filter((m) => m.role !== "system").map((m) => {
+        const role = m.role;
+        if (role === "compactionSummary") return this.compactionSummaryToUser(m);
+        if (role === "stateSnapshot") return this.stateSnapshotToUser(m);
+        return m;
+      }),
+      tools: tools.length > 0 ? tools : void 0
+    };
+  }
+  /** compactionSummary 消息 → user 消息（所有 provider 均兼容 user role） */
+  compactionSummaryToUser(msg) {
+    const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
+    return {
+      role: "user",
+      content: `${COMPACTION_USER_PREFIX}
+${text}`,
+      timestamp: msg.timestamp
+    };
+  }
+  /** stateSnapshot 消息 → user 消息（所有 provider 均兼容 user role） */
+  stateSnapshotToUser(msg) {
+    const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
+    return {
+      role: "user",
+      content: `${STATE_SNAPSHOT_USER_PREFIX}
+${text}`,
+      timestamp: msg.timestamp
+    };
+  }
+};
+
+// ../agent/runtime/loops.ts
+var RunLoops = class {
+  constructor(_d) {
+    this._d = _d;
+  }
+  _d;
+  async run(request, sessionKey, session, traceId, queuedMs) {
+    const activeStartedAt = Date.now();
+    this._d.onSessionActivated(sessionKey);
+    await this._d.hooks.beforeInitialize.promise(request);
+    await this._d.hooks.afterInitialize.promise(request);
+    const finalRequest = await this._d.hooks.beforeRun.promise(request);
+    if (!finalRequest.ephemeral) {
+      await this._d.persistence.hydrate(sessionKey, session);
+    }
+    const compilation = this._d.createCompilation(finalRequest, sessionKey, session, traceId);
+    compilation.messages.push(this._d.buildUserMessage(finalRequest));
+    try {
+      await this.runLoop(compilation, finalRequest, session);
+      const result = this._d.buildResult(compilation);
+      await this._d.hooks.beforeEmit.promise(result);
+      await this._d.hooks.afterEmit.promise(result);
+      await this._d.hooks.done.promise(result, finalRequest);
+      compilation.completed = true;
+      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
+      return result;
+    } catch (err) {
+      const error = err;
+      const message = error?.message ?? String(err);
+      if (error?.name !== "AbortError") {
+        console.error("[Runtime] \u8FD0\u884C\u5931\u8D25:", error?.stack ?? message);
+      }
+      await this._d.hooks.failed.promise(error, finalRequest);
+      const result = new ResultBuilder().error(message).build();
+      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
+      return result;
+    } finally {
+      await this._d.persistence.persistSafe(finalRequest, sessionKey);
+    }
+  }
+  async *stream(request, sessionKey, session, traceId, queuedMs) {
+    const activeStartedAt = Date.now();
+    this._d.onSessionActivated(sessionKey);
+    await this._d.hooks.beforeInitialize.promise(request);
+    await this._d.hooks.afterInitialize.promise(request);
+    const finalRequest = await this._d.hooks.beforeRun.promise(request);
+    if (!finalRequest.ephemeral) {
+      await this._d.persistence.hydrate(sessionKey, session);
+    }
+    const compilation = this._d.createCompilation(finalRequest, sessionKey, session, traceId);
+    compilation.messages.push(this._d.buildUserMessage(finalRequest));
+    try {
+      for await (const chunk of this.runLoopStream(compilation, finalRequest, session)) {
+        yield chunk;
+      }
+      const result = this._d.buildResult(compilation);
+      await this._d.hooks.beforeEmit.promise(result);
+      await this._d.hooks.afterEmit.promise(result);
+      await this._d.hooks.done.promise(result, finalRequest);
+      yield { type: "done", result };
+      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
+    } catch (err) {
+      const error = err;
+      const message = error?.message ?? String(err);
+      if (error?.name !== "AbortError") {
+        console.error("[Runtime] \u6D41\u5F0F\u8FD0\u884C\u5931\u8D25:", error?.stack ?? message);
+      }
+      await this._d.hooks.failed.promise(error, finalRequest);
+      const result = new ResultBuilder().error(message).build();
+      yield { type: "error", content: message };
+      yield { type: "done", result };
+      await this.emitRunEnd(finalRequest, sessionKey, compilation, result, queuedMs, activeStartedAt);
+    } finally {
+      await this._d.persistence.persistSafe(finalRequest, sessionKey);
+    }
+  }
+  // ─── 对话循环（同步） ───────────────────────────────────────────
+  async runLoop(compilation, request, session) {
+    session.isStreaming = true;
+    session.abortController = new AbortController();
+    const sessionKey = this._d.resolveSessionKey(request);
+    try {
+      let maxTurns = this._d.getMaxTurns();
+      let turnCount = 0;
+      while (maxTurns-- > 0) {
+        turnCount += 1;
+        await this._d.transformMessages(compilation, sessionKey);
+        await this._d.compactor.maybeCompactByThreshold(
+          compilation,
+          sessionKey,
+          session.abortController.signal
+        );
+        const assistantMessage = await this._d.modelTurn.streamModel(
+          compilation,
+          session.abortController.signal,
+          sessionKey
+        );
+        compilation.messages.push(assistantMessage);
+        await this._d.persistence.persistSafe(request, sessionKey);
+        const toolCalls = extractToolCalls(assistantMessage.content);
+        if (toolCalls.length === 0) {
+          break;
+        }
+        const outcome = await this.executeToolCalls(
+          compilation,
+          toolCalls,
+          session.abortController.signal
+        );
+        await this._d.persistence.persistSafe(request, sessionKey);
+        if (outcome.terminate) {
+          compilation.terminateReason = outcome.terminateReason ?? "terminated";
+          break;
+        }
+      }
+      if (maxTurns < 0) compilation.maxTurnsExhausted = true;
+      compilation.turnCount = turnCount;
+    } finally {
+      this._d.store.markIdle(session);
+    }
+  }
+  // ─── 对话循环（流式） ───────────────────────────────────────────
+  async *runLoopStream(compilation, request, session) {
+    session.isStreaming = true;
+    session.abortController = new AbortController();
+    const sessionKey = this._d.resolveSessionKey(request);
+    try {
+      let maxTurns = this._d.getMaxTurns();
+      let turnCount = 0;
+      while (maxTurns-- > 0) {
+        turnCount += 1;
+        await this._d.transformMessages(compilation, sessionKey);
+        await this._d.compactor.maybeCompactByThreshold(
+          compilation,
+          sessionKey,
+          session.abortController.signal
+        );
+        const turn = this._d.modelTurn.modelTurnWithRecovery(
+          compilation,
+          session.abortController.signal,
+          sessionKey,
+          true
+          // stream 模式：同时统计首 token 延迟
+        );
+        let turnResult = await turn.next();
+        while (!turnResult.done) {
+          yield turnResult.value;
+          turnResult = await turn.next();
+        }
+        const assistantMessage = turnResult.value;
+        if (!assistantMessage) break;
+        compilation.messages.push(assistantMessage);
+        await this._d.persistence.persistSafe(request, sessionKey);
+        const toolCalls = extractToolCalls(assistantMessage.content);
+        if (toolCalls.length === 0) {
+          break;
+        }
+        for (const toolCall of toolCalls) {
+          yield {
+            type: "tool_start",
+            toolName: toolCall.name,
+            toolCallId: toolCall.id
+          };
+        }
+        const outcome = await this.executeToolCalls(
+          compilation,
+          toolCalls,
+          session.abortController.signal
+        );
+        await this._d.persistence.persistSafe(request, sessionKey);
+        for (let i = 0; i < toolCalls.length; i++) {
+          yield {
+            type: "tool_end",
+            toolName: toolCalls[i].name,
+            toolCallId: toolCalls[i].id,
+            isError: this._d.tools.isErrorResult(outcome.results[i])
+          };
+        }
+        if (outcome.terminate) {
+          compilation.terminateReason = outcome.terminateReason ?? "terminated";
+          break;
+        }
+      }
+      if (maxTurns < 0) compilation.maxTurnsExhausted = true;
+      compilation.turnCount = turnCount;
+    } finally {
+      this._d.store.markIdle(session);
+    }
+  }
+  /** 同步循环：执行工具调用并将结果消息按原顺序追加 */
+  async executeToolCalls(compilation, toolCalls, signal) {
+    const outcome = await this._d.tools.run(
+      toolCalls,
+      signal,
+      compilation.request,
+      compilation.traceId
+    );
+    for (let i = 0; i < toolCalls.length; i++) {
+      compilation.messages.push(
+        this._d.tools.buildResultMessage(toolCalls[i], outcome.results[i])
+      );
+    }
+    return outcome;
+  }
+  /** run 级完成事件上报（补充默认模型 id） */
+  async emitRunEnd(request, sessionKey, compilation, result, queuedMs, activeStartedAt) {
+    await this._d.telemetry.emitRunEnd(
+      request,
+      sessionKey,
+      compilation,
+      result,
+      queuedMs,
+      activeStartedAt,
+      this._d.getModel().id
+    );
+  }
+};
+
+// ../agent/runtime/index.ts
+var AgentRuntime = class _AgentRuntime {
+  _config;
+  _extensions;
+  _hooks;
+  /** 上下文转换器列表，按数组顺序链式执行（上一个输出作为下一个输入） */
+  _transformers;
+  _model;
+  _streamFn;
+  _systemPrompt;
+  _thinkingLevel;
+  _globalTools = /* @__PURE__ */ new Map();
+  /** 默认会话 key（常量 'default'；请求未指定 sessionKey 时路由到此会话） */
+  _sessionKey;
+  _sessionStorage;
+  /** Extension 应用时的上下文（shared Map 供 ToolCallContext 引用） */
+  _extensionContext;
+  _maxTurns;
+  _toolTimeoutMs;
+  _parallelToolCalls;
+  _contextBudgetRatio;
+  /** 内置摘要压缩配置（未配置 = 保持旧行为，仅硬截断兜底） */
+  _compaction;
+  _telemetry;
+  /** 框架级工具权限策略（未配置 → 默认 fail-closed，见 permissionFailOpen） */
+  _permissionPolicy;
+  /** 未配置策略时是否显式放行工具执行（默认 false = 拒绝，安全姿态） */
+  _permissionFailOpen;
+  /** 审批管理器（pending 决策挂起等待外部批准；未配置 → pending 视为 deny） */
+  _approvals;
+  /** 审批等待超时（毫秒） */
+  _approvalTimeoutMs;
+  /** traceId 生成器（测试可注入确定性 id） */
+  _traceIdGenerator;
+  // ─── 协作模块（构造时组装，职责见文件头注释） ───────────────────
+  _store;
+  _persistence;
+  _emitter;
+  _tools;
+  _compactor;
+  _modelTurn;
+  _loops;
+  constructor(options) {
+    this._config = options.config ?? {};
+    this._extensions = new ExtensionManager();
+    this._hooks = this._extensions.getHooks();
+    this._transformers = [...options.transformers ?? []];
+    this._model = options.model ?? {
+      id: "unknown",
+      name: "unknown",
+      provider: "unknown",
+      contextWindow: 128e3,
+      maxTokens: 8192,
+      reasoning: false
+    };
+    this._streamFn = options.streamFn ?? (async function* () {
+      throw new Error("streamFn \u672A\u8BBE\u7F6E\uFF0C\u8BF7\u901A\u8FC7 setStreamFn() \u6216 RuntimeOptions.streamFn \u63D0\u4F9B");
+    });
+    this._systemPrompt = options.systemPrompt ?? "";
+    this._thinkingLevel = options.thinkingLevel ?? "off";
+    this._sessionStorage = options.sessionStorage;
+    this._maxTurns = options.maxTurns ?? 50;
+    this._toolTimeoutMs = options.toolTimeoutMs ?? 12e4;
+    this._parallelToolCalls = options.parallelToolCalls ?? true;
+    this._contextBudgetRatio = options.contextBudgetRatio ?? 0.8;
+    this._compaction = options.compaction;
+    this._telemetry = options.telemetry;
+    this._permissionPolicy = options.permissionPolicy;
+    this._permissionFailOpen = options.permissionFailOpen ?? false;
+    this._approvals = options.approvals;
+    this._approvalTimeoutMs = options.approvalTimeoutMs ?? 3e5;
+    this._traceIdGenerator = options.traceIdGenerator;
+    if (options.tools) {
+      for (const tool of options.tools) {
+        this._globalTools.set(tool.name, tool);
+      }
+    }
+    this._sessionKey = "default";
+    this._emitter = new RuntimeTelemetry(options.telemetry, options.traceIdGenerator);
+    setTapErrorHandler((info) => {
+      void this._emitter.emit("onHookError", {
+        sessionKey: this._sessionKey,
+        hook: info.hook,
+        tap: info.tap,
+        error: info.error
+      });
+    });
+    this._store = new SessionStore(this._sessionKey, options.maxSessions);
+    this._persistence = new SessionPersistence(
+      this._sessionStorage,
+      () => this._model,
+      this._store
+    );
+    this._tools = new ToolExecutor({
+      hooks: this._hooks,
+      telemetry: this._emitter,
+      permissionPolicy: this._permissionPolicy,
+      permissionFailOpen: this._permissionFailOpen,
+      approvals: this._approvals,
+      approvalTimeoutMs: this._approvalTimeoutMs,
+      toolTimeoutMs: this._toolTimeoutMs,
+      parallelToolCalls: this._parallelToolCalls,
+      defaultSessionKey: this._sessionKey,
+      getTools: () => this._globalTools,
+      getShared: () => this._extensionContext?.shared
+    });
+    this._compactor = new ContextCompactor({
+      telemetry: this._emitter,
+      getModel: () => this._model,
+      getStreamFn: () => this._streamFn,
+      contextBudgetRatio: this._contextBudgetRatio,
+      compaction: this._compaction
+    });
+    this._modelTurn = new ModelTurnRunner({
+      telemetry: this._emitter,
+      compactor: this._compactor,
+      hooks: this._hooks,
+      getModel: () => this._model,
+      getStreamFn: () => this._streamFn,
+      getSystemPrompt: () => this._systemPrompt,
+      getThinkingLevel: () => this._thinkingLevel,
+      getTools: () => this._globalTools,
+      resolveSessionKey: (request) => this.resolveSessionKey(request)
+    });
+    this._loops = new RunLoops({
+      hooks: this._hooks,
+      telemetry: this._emitter,
+      store: this._store,
+      persistence: this._persistence,
+      tools: this._tools,
+      compactor: this._compactor,
+      modelTurn: this._modelTurn,
+      getModel: () => this._model,
+      getMaxTurns: () => this._maxTurns,
+      resolveSessionKey: (request) => this.resolveSessionKey(request),
+      onSessionActivated: (key) => this.syncExtensionSessionKey(key),
+      createCompilation: (request, sessionKey, session, traceId) => this.createCompilation(request, sessionKey, session, traceId),
+      buildUserMessage: (request) => buildUserMessage(request),
+      buildResult: (compilation) => buildResult(compilation),
+      transformMessages: (compilation, sessionKey) => this.transformMessages(compilation, sessionKey)
+    });
+  }
+  // ─── 静态工厂 ───────────────────────────────────────────────────
+  static create(options = {}) {
+    const runtime = new _AgentRuntime(options);
+    if (options.extensions) {
+      runtime._extensions.registerAll(options.extensions);
+    }
+    const ctx = {
+      config: runtime._config,
+      workspace: options.workspace ?? process.cwd(),
+      sessionKey: runtime._sessionKey,
+      shared: /* @__PURE__ */ new Map(),
+      runtime
+    };
+    runtime._extensionContext = ctx;
+    runtime._extensions.applyAll(ctx);
+    return runtime;
+  }
+  // ─── Runtime 接口实现 ───────────────────────────────────────────
+  get config() {
+    return this._config;
+  }
+  get extensions() {
+    return this._extensions;
+  }
+  get hooks() {
+    return this._hooks;
+  }
+  // ─── 工具/模型/流管理 ───────────────────────────────────────────
+  registerTool(tool) {
+    if (this._globalTools.has(tool.name)) {
+      console.warn(`[Runtime] \u5DE5\u5177 "${tool.name}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6`);
+    }
+    this._globalTools.set(tool.name, tool);
+    return this;
+  }
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.registerTool(tool);
+    }
+    return this;
+  }
+  unregisterTool(name) {
+    return this._globalTools.delete(name);
+  }
+  setModel(model) {
+    this._model = model;
+    return this;
+  }
+  setSystemPrompt(prompt) {
+    this._systemPrompt = prompt;
+    return this;
+  }
+  setThinkingLevel(level) {
+    this._thinkingLevel = level;
+    return this;
+  }
+  setStreamFn(fn) {
+    this._streamFn = fn;
+    return this;
+  }
+  registerExtension(extension) {
+    this._extensions.register(extension);
+    return this;
+  }
+  useTransformer(transformer) {
+    this._transformers.push(transformer);
+    return this;
+  }
+  /**
+   * 获取指定会话的消息列表（默认会话；会话不存在返回空数组）。
+   * 同步方法：会话被 LRU 淘汰且配置了存储时，后台异步恢复（下次调用可读到），
+   * 需确定性读取（如断言/导出）请用 loadMessages()。
+   */
+  getMessages(sessionKey) {
+    const key = sessionKey ?? this._sessionKey;
+    if (this._store.has(key)) {
+      return this._store.getMessagesCopy(key);
+    }
+    if (this._sessionStorage) {
+      const session = this._store.ensure(key);
+      void this._persistence.hydrate(key, session).catch(() => {
+      });
+    }
+    return [];
+  }
+  /** 异步读取指定会话的消息列表：内存未命中（LRU 淘汰）时等待存储恢复后返回 */
+  async loadMessages(sessionKey) {
+    const key = sessionKey ?? this._sessionKey;
+    const existing = this._store.peek(key);
+    if (existing && existing.hydrated) {
+      return this._store.getMessagesCopy(key);
+    }
+    const session = existing ?? this._store.ensure(key);
+    await this._persistence.hydrate(key, session);
+    return this._store.getMessagesCopy(key);
+  }
   /**
-   * 触发遥测回调。全可选、失败不阻断主流程。
+   * 指定会话消息的只读视图（高频轮询用）：浅拷贝数组、共享消息对象，
+   * 避免每次 structuredClone 深拷贝整个会话历史；调用方不得修改内容。
    */
-  async emitTelemetry(event, info) {
-    const fn = this._telemetry?.[event];
-    if (!fn) return;
+  peekMessages(sessionKey) {
+    return this._store.peekMessages(sessionKey ?? this._sessionKey);
+  }
+  /**
+   * 同步共享扩展上下文的会话键为本次 run/stream 的真实会话。
+   * 注意：ExtensionContext 为跨会话共享单例，多会话并发时该值为最近激活的
+   * 会话；需精确会话请用 ToolCallContext.sessionKey / Request.sessionKey。
+   */
+  syncExtensionSessionKey(sessionKey) {
+    if (this._extensionContext && this._extensionContext.sessionKey !== sessionKey) {
+      this._extensionContext.sessionKey = sessionKey;
+    }
+  }
+  // ─── 核心运行逻辑 ───────────────────────────────────────────────
+  /** 解析请求路由的会话 key：request.sessionKey ?? 默认会话 key */
+  resolveSessionKey(request) {
+    return request.sessionKey ?? this._sessionKey;
+  }
+  /** 当前活跃的会话 key 列表（含默认会话） */
+  getSessionKeys() {
+    return this._store.keys();
+  }
+  /** 某会话是否存在（内存中） */
+  hasSession(sessionKey) {
+    return this._store.has(sessionKey);
+  }
+  async run(request) {
+    const validation = validateRequest(request);
+    if (!validation.valid) {
+      const invalidResult = new ResultBuilder().error(`\u8BF7\u6C42\u6821\u9A8C\u5931\u8D25: ${validation.errors.join("; ")}`).build();
+      await this._emitter.emit("onRunEnd", {
+        traceId: this._emitter.newTraceId(),
+        sessionKey: this.resolveSessionKey(request),
+        request,
+        durationMs: 0,
+        activeMs: 0,
+        queuedMs: 0,
+        turnCount: 0,
+        result: invalidResult,
+        success: false,
+        errorClass: "validation",
+        tokens: { input: 0, output: 0 }
+      });
+      return invalidResult;
+    }
+    const finalRequest = normalizeRequest(request);
+    const sessionKey = this.resolveSessionKey(finalRequest);
+    const traceId = this._emitter.newTraceId();
+    const queuedAt = Date.now();
+    await this._emitter.emit("onRunStart", {
+      traceId,
+      sessionKey,
+      request: finalRequest,
+      queuedAt
+    });
+    const session = this._store.ensure(sessionKey);
+    const release = await this._store.acquire(session);
+    const queuedMs = Date.now() - queuedAt;
+    try {
+      return await this._persistence.withStorageLock(
+        finalRequest,
+        sessionKey,
+        () => this._loops.run(finalRequest, sessionKey, session, traceId, queuedMs)
+      );
+    } finally {
+      release();
+    }
+  }
+  async *stream(request) {
+    const validation = validateRequest(request);
+    if (!validation.valid) {
+      const message = `\u8BF7\u6C42\u6821\u9A8C\u5931\u8D25: ${validation.errors.join("; ")}`;
+      await this._emitter.emit("onRunEnd", {
+        traceId: this._emitter.newTraceId(),
+        sessionKey: this.resolveSessionKey(request),
+        request,
+        durationMs: 0,
+        activeMs: 0,
+        queuedMs: 0,
+        turnCount: 0,
+        result: new ResultBuilder().error(message).build(),
+        success: false,
+        errorClass: "validation",
+        tokens: { input: 0, output: 0 }
+      });
+      yield { type: "error", content: message };
+      yield { type: "done" };
+      return;
+    }
+    const finalRequest = normalizeRequest(request);
+    const sessionKey = this.resolveSessionKey(finalRequest);
+    const traceId = this._emitter.newTraceId();
+    const queuedAt = Date.now();
+    await this._emitter.emit("onRunStart", {
+      traceId,
+      sessionKey,
+      request: finalRequest,
+      queuedAt
+    });
+    const session = this._store.ensure(sessionKey);
+    const release = await this._store.acquire(session);
+    const queuedMs = Date.now() - queuedAt;
     try {
-      await Promise.resolve(fn(info));
-    } catch (err) {
-      console.warn(`[aipack] telemetry "${String(event)}" \u4E0A\u62A5\u5931\u8D25:`, err);
+      yield* this._persistence.streamWithStorageLock(
+        finalRequest,
+        sessionKey,
+        () => this._loops.stream(finalRequest, sessionKey, session, traceId, queuedMs)
+      );
+    } finally {
+      release();
     }
   }
-  /** traceId 生成：优先用注入的生成器（测试可确定性） */
-  newTraceId() {
-    return this._traceIdGenerator ? this._traceIdGenerator() : newTraceId();
+  createCompilation(request, sessionKey, session, traceId) {
+    return {
+      request,
+      graph: createTaskGraph(),
+      resources: [],
+      messages: (session ?? this._store.ensure(sessionKey ?? this._sessionKey)).messages,
+      completed: false,
+      traceId: traceId ?? this._emitter.newTraceId()
+    };
   }
-  /** 组装并上报 run 级完成事件（_run/_stream 内部统一调用） */
-  async emitRunEnd(request, sessionKey, compilation, result, queuedMs, activeStartedAt) {
-    const activeMs = Date.now() - activeStartedAt;
-    await this.emitTelemetry("onRunEnd", {
-      traceId: compilation.traceId,
-      sessionKey,
-      // 请求未显式指定 model 时补实际模型（模型排行按 run 级 requests 统计，缺省会落入 'unknown'）
-      request: request.model ? request : { ...request, model: this._model.id },
-      durationMs: activeMs + queuedMs,
-      activeMs,
-      queuedMs,
-      turnCount: compilation.turnCount ?? 0,
-      result,
-      success: result.success,
-      errorClass: this.runErrorClass(compilation),
-      tokens: {
-        input: result.usage.input ?? 0,
-        output: result.usage.output ?? 0,
-        cacheRead: result.usage.cacheRead,
-        cacheWrite: result.usage.cacheWrite
-      },
-      ttftMs: compilation.ttftMs
-    });
+  async close() {
+    await this._store.drainAndClear();
+    this._extensions.clear();
+    this._transformers = [];
   }
-  /** run 级错误分类：terminate → 'terminated'；否则只看最后一条 assistant 消息（与 buildResult 的 result.success 同口径） */
-  runErrorClass(compilation) {
-    if (compilation.terminateReason) return "terminated";
-    const messages = compilation.messages;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const m = messages[i];
-      if (m.role === "assistant") {
-        if (!m.errorMessage) return void 0;
-        const cls = errorClassFromMessage(m.errorMessage);
-        return cls ?? "unknown";
-      }
+  // ─── 上下文转换（链式执行，原地替换保持 session 引用） ──────────
+  /** 链式执行上下文转换器（按数组顺序，上一个输出作为下一个输入） */
+  async transformMessages(compilation, sessionKey) {
+    if (this._transformers.length === 0) {
+      return;
     }
-    return void 0;
-  }
-  buildResult(compilation) {
-    const messages = compilation.messages;
-    let content = "";
-    let stopReason = "completed";
-    let error;
-    const toolsUsed = [];
-    const usage = {};
-    for (const msg of messages) {
-      if (msg.role === "assistant") {
-        const assistant = msg;
-        content = extractText(assistant.content);
-        stopReason = assistant.stopReason ?? "completed";
-        error = assistant.errorMessage;
-        if (assistant.usage) {
-          usage.input = (usage.input ?? 0) + assistant.usage.input;
-          usage.output = (usage.output ?? 0) + assistant.usage.output;
-          usage.total = (usage.total ?? 0) + assistant.usage.total;
-          if (assistant.usage.cacheRead) usage.cacheRead = (usage.cacheRead ?? 0) + assistant.usage.cacheRead;
-          if (assistant.usage.cacheWrite) usage.cacheWrite = (usage.cacheWrite ?? 0) + assistant.usage.cacheWrite;
-        }
+    let resources = messagesToResources(compilation.messages);
+    const originalResources = resources;
+    const context = {
+      graph: compilation.graph,
+      runtime: {
+        sessionKey,
+        turn: compilation.messages.length,
+        contextWindow: this._model.contextWindow,
+        maxTokens: this._model.maxTokens,
+        contextBudgetRatio: this._contextBudgetRatio
       }
-      if (msg.role === "toolResult") {
-        const toolMsg = msg;
-        if (!toolsUsed.includes(toolMsg.toolName)) {
-          toolsUsed.push(toolMsg.toolName);
-        }
+    };
+    for (const transformer of this._transformers) {
+      try {
+        const next = await transformer.transform(resources, context);
+        if (next !== resources) resources = next;
+      } catch (err) {
+        console.warn(
+          `[Runtime] \u8F6C\u6362\u5668 "${transformer.name}" \u5931\u8D25\uFF0C\u5DF2\u8DF3\u8FC7:`,
+          err?.message ?? err
+        );
       }
     }
-    const resources = messagesToResources(messages);
-    const builder = new ResultBuilder().content(content).toolsUsed(toolsUsed).usage(usage).stopReason(stopReason).error(error).resources(resources).metadata("traceId", compilation.traceId);
-    if (compilation.terminateReason) {
-      builder.stopReason("terminated").metadata("terminateReason", compilation.terminateReason);
-    }
-    if (compilation.maxTurnsExhausted) {
-      builder.stopReason("max_turns").metadata("maxTurns", true);
+    if (resources === originalResources) {
+      return;
     }
-    return builder.build();
+    const messages = resourcesToMessages(resources);
+    compilation.messages.splice(0, compilation.messages.length, ...messages);
   }
-  streamEventToChunk(event) {
-    switch (event.type) {
-      case "text_delta":
-        return { type: "text", content: event.delta };
-      case "thinking_delta":
-        return { type: "thinking", content: event.delta };
-      case "error":
-        return {
-          type: "error",
-          content: event.message.errorMessage || "\u6A21\u578B\u8C03\u7528\u51FA\u9519"
-        };
-      default:
-        return null;
+  // ─── 手动压缩（交互命令 /compact 等） ───────────────────────────
+  /**
+   * 手动压缩指定会话：跳过阈值判断，直接将历史压缩至 targetRatio
+   * 保留量（复用 compactor 的保留段计算与 compactOrTruncate 执行路径），
+   * 压缩后持久化。返回压缩模式；compaction 未启用或无可压缩段时返回 null。
+   */
+  async compact(sessionKey) {
+    if (!this._compaction || this._compaction.enabled === false) return null;
+    const key = sessionKey ?? this._sessionKey;
+    const session = this._store.ensure(key);
+    const messages = session.messages;
+    if (messages.length === 0) return null;
+    const contextWindow = this._model.contextWindow;
+    if (!contextWindow || contextWindow <= 0) return null;
+    const split = this._compactor.computeKeepSplit(messages, contextWindow);
+    if (split <= 0 || split >= messages.length) return null;
+    const mode = await this._compactor.compactOrTruncate(
+      messages,
+      split,
+      key,
+      `manual-${Date.now().toString(36)}`,
+      new AbortController().signal,
+      "threshold"
+    );
+    try {
+      await this._persistence.persist(key, session);
+    } catch (err) {
+      console.warn("[Runtime] \u624B\u52A8\u538B\u7F29\u540E\u6301\u4E45\u5316\u5931\u8D25:", err?.message);
     }
+    return mode;
   }
   // ─── 便捷方法 ───────────────────────────────────────────────────
   /** 终止指定会话的运行（默认会话；会话不存在为 no-op） */
   abort(sessionKey) {
-    this._sessions.get(sessionKey ?? this._sessionKey)?.abortController?.abort();
+    this._store.peek(sessionKey ?? this._sessionKey)?.abortController?.abort();
   }
   /** 检查指定会话是否正在运行（默认会话；会话不存在返回 false） */
   isBusy(sessionKey) {
-    return this._sessions.get(sessionKey ?? this._sessionKey)?.isStreaming ?? false;
+    return this._store.peek(sessionKey ?? this._sessionKey)?.isStreaming ?? false;
   }
   /** 等待指定会话空闲（默认会话；基于 promise，无轮询） */
   async waitForIdle(sessionKey, timeoutMs) {
-    const session = this._sessions.get(sessionKey ?? this._sessionKey);
-    if (!session || !session.isStreaming) return;
-    if (timeoutMs === void 0) {
-      await new Promise((resolve) => {
-        session.idleResolvers.push(resolve);
-      });
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const resolver = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-      const timer = setTimeout(() => {
-        const i = session.idleResolvers.indexOf(resolver);
-        if (i >= 0) session.idleResolvers.splice(i, 1);
-        reject(new Error(
-          `[Runtime] waitForIdle \u8D85\u65F6\uFF08${timeoutMs}ms\uFF09: ${sessionKey ?? "default"}`
-        ));
-      }, timeoutMs);
-      session.idleResolvers.push(resolver);
-    });
+    await this._store.waitForIdle(sessionKey ?? this._sessionKey, timeoutMs);
   }
   /** 清除指定会话消息（仅内存；下次 run 会从存储恢复） */
   clearSession(sessionKey) {
-    const session = this._sessions.get(sessionKey ?? this._sessionKey);
-    if (!session) return;
-    session.messages = [];
-    session.hydrated = false;
+    this._store.clearMessages(sessionKey ?? this._sessionKey);
   }
   /** 删除指定会话（内存 + 存储），返回是否删除成功 */
   async deleteSession(sessionKey) {
     const key = sessionKey ?? this._sessionKey;
-    const session = this._sessions.get(key);
-    if (session) {
-      await session.queue;
-      this._sessions.delete(key);
-    }
-    if (!this._sessionStorage) return true;
+    await this._store.remove(key);
     const storage = this._sessionStorage;
+    if (!storage) return true;
     if (!storage.withLock) return storage.delete(key);
     return storage.withLock(key, () => storage.delete(key));
   }
@@ -2478,7 +2775,55 @@ function createRuntime(options) {
   return AgentRuntime.create(options);
 }
 
+// core/event-stream.ts
+function createEventStream(execute, sink) {
+  const eventQueue = [];
+  let resolveEvent = null;
+  let done = false;
+  const emit = (event) => {
+    eventQueue.push(event);
+    if (sink) {
+      try {
+        sink(event);
+      } catch {
+      }
+    }
+    resolveEvent?.();
+  };
+  const graphPromise = execute(emit).finally(() => {
+    done = true;
+    resolveEvent?.();
+  });
+  return (async function* () {
+    while (!done || eventQueue.length > 0) {
+      if (eventQueue.length > 0) {
+        yield eventQueue.shift();
+      } else {
+        await new Promise((resolve) => {
+          resolveEvent = resolve;
+        });
+      }
+    }
+    await graphPromise;
+  })();
+}
+
 // core/executor.ts
+var GraphAbortedError = class extends Error {
+  constructor() {
+    super("AgentGraph: \u6267\u884C\u5DF2\u88AB\u4E2D\u6B62");
+    this.name = "GraphAbortedError";
+  }
+};
+function toInputText(input) {
+  return typeof input === "string" ? input : input.message;
+}
+var NodeTimeoutError = class extends Error {
+  constructor(nodeId, timeoutMs) {
+    super(`AgentGraph: \u8282\u70B9 "${nodeId}" \u6267\u884C\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`);
+    this.name = "NodeTimeoutError";
+  }
+};
 var runtimeCache = /* @__PURE__ */ new WeakMap();
 function ensureRuntime(node) {
   let rt = runtimeCache.get(node);
@@ -2491,19 +2836,52 @@ function ensureRuntime(node) {
   runtimeCache.set(node, rt);
   return rt;
 }
-async function executeNode(node, input, ctx) {
+async function executeNodeOnce(node, req) {
   const runtime = ensureRuntime(node);
+  if (node.timeoutMs != null && node.timeoutMs > 0) {
+    let timer;
+    try {
+      return await Promise.race([
+        runtime.run(req),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new NodeTimeoutError(node.id, node.timeoutMs)), node.timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  return runtime.run(req);
+}
+async function executeNode(node, input, ctx) {
   let req;
   if (typeof input === "string") {
     req = createRequest(input, { sessionKey: `multi-agent:${node.id}` });
   } else {
     req = { ...input, sessionKey: input.sessionKey ?? `multi-agent:${node.id}` };
   }
-  const result = await runtime.run(req);
+  const maxAttempts = Math.max(1, node.retry?.maxAttempts ?? 1);
+  const backoffMs = node.retry?.backoffMs ?? 0;
+  let lastErr;
+  let succeeded;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt > 1 && backoffMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, backoffMs));
+    }
+    try {
+      succeeded = await executeNodeOnce(node, req);
+      break;
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  if (succeeded === void 0) {
+    throw lastErr;
+  }
   if (node.outputMapping) {
-    node.outputMapping(result, ctx);
+    node.outputMapping(succeeded, ctx);
   }
-  return result;
+  return succeeded;
 }
 function resolveInput(edge, prevResult, ctx, node, originalInput) {
   if (edge?.transform) {
@@ -2530,12 +2908,22 @@ var GraphExecutor = class {
   entryId;
   finishCondition;
   abortController = new AbortController();
+  /** 外部事件监听（on() API 的底层接线），事件会同步分发 */
+  eventSink;
+  /** 并行分支最大并发数（默认不限制） */
+  concurrency;
+  /** 单节点最大访问次数（环图防死循环） */
+  maxVisitsPerNode;
   state = {
     nodeStates: /* @__PURE__ */ new Map(),
     nodeResults: /* @__PURE__ */ new Map(),
     stepsCompleted: 0,
     finished: false
   };
+  constructor(opts) {
+    this.concurrency = opts?.concurrency ?? Infinity;
+    this.maxVisitsPerNode = opts?.maxVisitsPerNode ?? 10;
+  }
   addNode(node) {
     this.nodes.set(node.id, node);
     this.state.nodeStates.set(node.id, "pending");
@@ -2553,12 +2941,42 @@ var GraphExecutor = class {
     this.finishCondition = condition;
     return this;
   }
+  /** 注入外部事件监听（由 AgentGraph 实现的 on() 接线） */
+  setEventSink(sink) {
+    this.eventSink = sink;
+    return this;
+  }
   getState() {
-    return { ...this.state };
+    return {
+      ...this.state,
+      nodeStates: new Map(this.state.nodeStates),
+      nodeResults: new Map(this.state.nodeResults)
+    };
   }
   abort() {
     this.abortController.abort();
   }
+  /** 每次 run/stream 前重置中止信号，避免上一次的 abort 永久失效 */
+  resetAbortController() {
+    this.abortController = new AbortController();
+  }
+  /** 每次 run/stream 前重置执行状态，避免残留上一次的 nodeStates/结果 */
+  resetState() {
+    this.state = {
+      nodeStates: /* @__PURE__ */ new Map(),
+      nodeResults: /* @__PURE__ */ new Map(),
+      stepsCompleted: 0,
+      finished: false
+    };
+    for (const id of this.nodes.keys()) {
+      this.state.nodeStates.set(id, "pending");
+    }
+  }
+  throwIfAborted() {
+    if (this.abortController.signal.aborted) {
+      throw new GraphAbortedError();
+    }
+  }
   /** 同步执行图 */
   async run(input) {
     if (!this.entryId) {
@@ -2567,66 +2985,78 @@ var GraphExecutor = class {
     if (!this.nodes.has(this.entryId)) {
       throw new Error(`AgentGraph: \u5165\u53E3\u8282\u70B9 "${this.entryId}" \u4E0D\u5B58\u5728`);
     }
+    this.resetAbortController();
+    this.resetState();
     const ctx = createSharedContext({
       meta: { traceId: `ma-${Date.now()}`, startTime: Date.now() }
     });
-    const events = [];
+    storeOriginalInput(ctx, input);
+    const emit = this.eventSink ?? (() => {
+    });
     try {
-      const result = await this.executeGraph(input, ctx, (event) => events.push(event));
+      const result = await this.executeGraph(input, ctx, emit);
+      emit({ type: "graph_done", result });
       return result;
     } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.error = errorMsg;
+      if (err instanceof GraphAbortedError) {
+        const lastCompleted = [...this.state.nodeResults.values()].at(-1);
+        const abortedResult = {
+          content: lastCompleted?.content ?? "",
+          lastAgentId: this.state.currentAgentId ?? "",
+          agentResults: new Map(this.state.nodeResults),
+          totalUsage: {},
+          stepsCompleted: this.state.stepsCompleted,
+          stopReason: "aborted",
+          context: ctx,
+          success: false,
+          error: err.message
+        };
+        emit({ type: "graph_error", error: err.message });
+        return abortedResult;
+      }
+      emit({ type: "graph_error", error: errorMsg });
       return {
         content: "",
         lastAgentId: this.state.currentAgentId ?? "",
-        agentResults: this.state.nodeResults,
+        agentResults: new Map(this.state.nodeResults),
         totalUsage: {},
         stepsCompleted: this.state.stepsCompleted,
         stopReason: "error",
         context: ctx,
         success: false,
-        error: err instanceof Error ? err.message : String(err)
+        error: errorMsg
       };
     }
   }
   /** 流式执行图 */
-  async *stream(input) {
+  stream(input) {
     if (!this.entryId) {
       throw new Error("AgentGraph: \u5165\u53E3\u8282\u70B9\u672A\u8BBE\u7F6E\uFF0C\u8BF7\u8C03\u7528 setEntry()");
     }
     if (!this.nodes.has(this.entryId)) {
       throw new Error(`AgentGraph: \u5165\u53E3\u8282\u70B9 "${this.entryId}" \u4E0D\u5B58\u5728`);
     }
+    this.resetAbortController();
+    this.resetState();
     const ctx = createSharedContext({
       meta: { traceId: `ma-${Date.now()}`, startTime: Date.now() }
     });
-    const eventQueue = [];
-    let resolveEvent = null;
-    let done = false;
-    const emit = (event) => {
-      eventQueue.push(event);
-      resolveEvent?.();
-    };
-    const graphPromise = this.executeGraph(input, ctx, emit).then(
-      (result) => {
-        emit({ type: "graph_done", result });
-      },
-      (err) => {
-        emit({ type: "graph_error", error: err instanceof Error ? err.message : String(err) });
-      }
-    ).finally(() => {
-      done = true;
-      resolveEvent?.();
-    });
-    while (!done || eventQueue.length > 0) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift();
-      } else {
-        await new Promise((resolve) => {
-          resolveEvent = resolve;
-        });
-      }
-    }
-    await graphPromise;
+    storeOriginalInput(ctx, input);
+    return createEventStream(
+      (emit) => this.executeGraph(input, ctx, emit).then(
+        (result) => {
+          emit({ type: "graph_done", result });
+        },
+        (err) => {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          this.state.error = errorMsg;
+          emit({ type: "graph_error", error: errorMsg });
+        }
+      ),
+      this.eventSink
+    );
   }
   /** 核心执行逻辑 */
   async executeGraph(input, ctx, emit) {
@@ -2639,7 +3069,7 @@ var GraphExecutor = class {
     const totalUsage = {};
     this.state.currentAgentId = currentId;
     this.state.nodeStates.set(currentId, "running");
-    emit({ type: "agent_start", agentId: currentId, agentName: entryNode.name });
+    emit({ type: "agent_start", agentId: currentId, agentName: entryNode.name, input: toInputText(currentInput) });
     try {
       lastResult = await executeNode(entryNode, currentInput, ctx);
       this.state.nodeStates.set(currentId, "completed");
@@ -2658,50 +3088,134 @@ var GraphExecutor = class {
     if (this.finishCondition?.(ctx)) {
       return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "finish_condition");
     }
-    const visited = /* @__PURE__ */ new Set();
+    let frontier = [{ id: currentId, result: lastResult }];
     const visitCount = /* @__PURE__ */ new Map();
-    const MAX_VISITS_PER_NODE = 10;
-    while (lastResult) {
-      const nextEdges = findNextEdges(currentId, this.edges, lastResult, ctx);
-      if (nextEdges.length === 0) {
+    let stopReason = "completed";
+    while (frontier.length > 0) {
+      this.throwIfAborted();
+      const candidates = [];
+      const seenTargets = /* @__PURE__ */ new Set();
+      for (const from of frontier) {
+        const nextEdges = findNextEdges(from.id, this.edges, from.result, ctx);
+        for (const edge of nextEdges) {
+          if (seenTargets.has(edge.to)) continue;
+          seenTargets.add(edge.to);
+          const nextNode = this.nodes.get(edge.to);
+          if (!nextNode) {
+            throw new Error(`AgentGraph: \u76EE\u6807\u8282\u70B9 "${edge.to}" \u4E0D\u5B58\u5728`);
+          }
+          candidates.push({ edge, from, node: nextNode });
+        }
+      }
+      if (candidates.length === 0) {
         break;
       }
-      const edge = nextEdges[0];
-      const nextNode = this.nodes.get(edge.to);
-      if (!nextNode) {
-        throw new Error(`AgentGraph: \u76EE\u6807\u8282\u70B9 "${edge.to}" \u4E0D\u5B58\u5728`);
+      const allowed = [];
+      let truncated = false;
+      for (const c of candidates) {
+        const count = (visitCount.get(c.edge.to) ?? 0) + 1;
+        if (count > this.maxVisitsPerNode) {
+          truncated = true;
+          continue;
+        }
+        visitCount.set(c.edge.to, count);
+        allowed.push(c);
       }
-      const count = (visitCount.get(edge.to) ?? 0) + 1;
-      if (count > MAX_VISITS_PER_NODE) {
+      if (allowed.length === 0) {
+        if (truncated) stopReason = "max_visits_exceeded";
         break;
       }
-      visitCount.set(edge.to, count);
-      currentInput = resolveInput(edge, lastResult, ctx, nextNode, input);
-      currentId = edge.to;
-      this.state.currentAgentId = currentId;
-      this.state.nodeStates.set(currentId, "running");
-      emit({ type: "edge_traversed", from: edge.from, to: edge.to });
-      emit({ type: "agent_start", agentId: currentId, agentName: nextNode.name });
-      try {
-        lastResult = await executeNode(nextNode, currentInput, ctx);
-        this.state.nodeStates.set(currentId, "completed");
-        this.state.nodeResults.set(currentId, lastResult);
-        this.mergeUsage(totalUsage, lastResult.usage);
+      const tasks = allowed.map((c) => ({
+        node: c.node,
+        input: resolveInput(c.edge, c.from.result, ctx, c.node, input),
+        fromId: c.edge.from
+      }));
+      let waveResults;
+      if (tasks.length === 1) {
+        const t = tasks[0];
+        this.state.currentAgentId = t.node.id;
+        this.state.nodeStates.set(t.node.id, "running");
+        emit({ type: "edge_traversed", from: t.fromId, to: t.node.id });
+        emit({ type: "agent_start", agentId: t.node.id, agentName: t.node.name, input: toInputText(t.input) });
+        let result;
+        try {
+          result = await executeNode(t.node, t.input, ctx);
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          this.state.nodeStates.set(t.node.id, "failed");
+          emit({ type: "agent_error", agentId: t.node.id, agentName: t.node.name, error: errorMsg });
+          throw err;
+        }
+        this.state.nodeStates.set(t.node.id, "completed");
+        this.state.nodeResults.set(t.node.id, result);
+        this.mergeUsage(totalUsage, result.usage);
         stepsCompleted++;
         this.state.stepsCompleted = stepsCompleted;
-        emit({ type: "agent_result", agentId: currentId, agentName: nextNode.name, result: lastResult });
+        emit({ type: "agent_result", agentId: t.node.id, agentName: t.node.name, result });
+        waveResults = [{ id: t.node.id, result }];
+      } else {
+        waveResults = await this.executeWave(tasks, ctx, emit, totalUsage);
+        stepsCompleted += waveResults.length;
+        this.state.stepsCompleted = stepsCompleted;
+      }
+      lastResult = waveResults[waveResults.length - 1].result;
+      lastAgentId = waveResults[waveResults.length - 1].id;
+      frontier = waveResults;
+      if (this.finishCondition?.(ctx)) {
+        return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "finish_condition");
+      }
+    }
+    return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, stopReason);
+  }
+  /** 并行执行一个 wave 的节点（fail-fast + concurrency 限流） */
+  async executeWave(tasks, ctx, emit, totalUsage) {
+    const results = [];
+    emit({ type: "parallel_start", agentIds: tasks.map((t) => t.node.id) });
+    const runOne = async (t) => {
+      this.state.currentAgentId = t.node.id;
+      this.state.nodeStates.set(t.node.id, "running");
+      emit({ type: "edge_traversed", from: t.fromId, to: t.node.id });
+      emit({ type: "agent_start", agentId: t.node.id, agentName: t.node.name, input: toInputText(t.input) });
+      try {
+        const result = await executeNode(t.node, t.input, ctx);
+        this.state.nodeStates.set(t.node.id, "completed");
+        this.state.nodeResults.set(t.node.id, result);
+        this.mergeUsage(totalUsage, result.usage);
+        results.push({ id: t.node.id, result });
+        emit({ type: "agent_result", agentId: t.node.id, agentName: t.node.name, result });
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
-        this.state.nodeStates.set(currentId, "failed");
-        emit({ type: "agent_error", agentId: currentId, agentName: nextNode.name, error: errorMsg });
+        this.state.nodeStates.set(t.node.id, "failed");
+        emit({ type: "agent_error", agentId: t.node.id, agentName: t.node.name, error: errorMsg });
         throw err;
       }
-      lastAgentId = currentId;
-      if (this.finishCondition?.(ctx)) {
-        return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "finish_condition");
+    };
+    if (this.concurrency >= tasks.length) {
+      await Promise.all(tasks.map((t) => runOne(t)));
+    } else {
+      let index = 0;
+      const executing = /* @__PURE__ */ new Set();
+      const enqueue = () => {
+        if (index >= tasks.length) return null;
+        const i = index++;
+        const p = runOne(tasks[i]).finally(() => {
+          executing.delete(p);
+        });
+        executing.add(p);
+        p.catch(() => {
+        });
+        return p;
+      };
+      for (let i = 0; i < this.concurrency && index < tasks.length; i++) {
+        enqueue();
+      }
+      while (executing.size > 0) {
+        await Promise.race(executing);
+        enqueue();
       }
     }
-    return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "completed");
+    emit({ type: "parallel_done", results: new Map(results.map((r) => [r.id, r.result])) });
+    return results;
   }
   buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, stopReason) {
     this.state.finished = true;
@@ -2726,8 +3240,12 @@ var GraphExecutor = class {
 
 // core/graph.ts
 var AgentGraphImpl = class {
-  executor = new GraphExecutor();
-  eventListeners = /* @__PURE__ */ new Map();
+  executor;
+  /** on() 注册的监听器，按 MultiAgentEvent.type 分发 */
+  bus = new SimpleEventBus();
+  constructor(opts) {
+    this.executor = new GraphExecutor(opts);
+  }
   addNode(node) {
     this.executor.addNode(node);
     return this;
@@ -2745,9 +3263,11 @@ var AgentGraphImpl = class {
     return this;
   }
   async run(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     return this.executor.run(input);
   }
   async *stream(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     yield* this.executor.stream(input);
   }
   getState() {
@@ -2757,17 +3277,12 @@ var AgentGraphImpl = class {
     this.executor.abort();
   }
   on(event, listener) {
-    let set = this.eventListeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.eventListeners.set(event, set);
-    }
-    set.add(listener);
+    this.bus.on(event, listener);
     return this;
   }
 };
-function createAgentGraph() {
-  return new AgentGraphImpl();
+function createAgentGraph(opts) {
+  return new AgentGraphImpl(opts);
 }
 
 // patterns/pipeline.ts
@@ -2805,14 +3320,19 @@ function createRouter(router, targets, opts) {
   }
   graph.setEntry(router.id);
   const targetIds = new Set(targets.map((t) => t.id));
+  const defaultTarget = opts.defaultTarget && targetIds.has(opts.defaultTarget) ? opts.defaultTarget : void 0;
+  const resolveTarget = (routerResult) => {
+    const resolvedId = opts.resolve(routerResult);
+    if (targetIds.has(resolvedId)) return resolvedId;
+    return defaultTarget ?? resolvedId;
+  };
   for (const target of targets) {
     graph.addEdge({
       from: router.id,
       to: target.id,
-      // 条件：从路由器结果中解析目标ID，匹配当前目标
+      // 条件：从路由器结果中解析目标ID（含 defaultTarget 兜底），匹配当前目标
       condition: (routerResult, _ctx) => {
-        const resolvedId = opts.resolve(routerResult);
-        return resolvedId === target.id;
+        return resolveTarget(routerResult) === target.id;
       },
       // 转换：决定传给目标Agent的输入
       transform: (_routerResult, _ctx) => {
@@ -2824,8 +3344,6 @@ function createRouter(router, targets, opts) {
       }
     });
   }
-  if (opts.defaultTarget && targetIds.has(opts.defaultTarget)) {
-  }
   return graph;
 }
 
@@ -2834,6 +3352,11 @@ var SupervisorExecutor = class {
   supervisorNode;
   workerNodes;
   opts;
+  abortController = new AbortController();
+  /** 外部事件监听（on() API 的底层接线） */
+  eventSink;
+  /** 最近一次 run 中失败的 Worker ID（onWorkerError='skip' 时使用） */
+  failedAgents = [];
   state = {
     nodeStates: /* @__PURE__ */ new Map(),
     nodeResults: /* @__PURE__ */ new Map(),
@@ -2846,7 +3369,8 @@ var SupervisorExecutor = class {
     this.opts = {
       schedule: opts?.schedule ?? "parallel",
       concurrency: opts?.concurrency ?? Infinity,
-      passOriginalInput: opts?.passOriginalInput ?? true
+      passOriginalInput: opts?.passOriginalInput ?? true,
+      onWorkerError: opts?.onWorkerError ?? "fail-fast"
     };
     this.state.nodeStates.set(supervisor.id, "pending");
     for (const w of workers) {
@@ -2854,69 +3378,91 @@ var SupervisorExecutor = class {
     }
   }
   getState() {
-    return { ...this.state };
+    return {
+      ...this.state,
+      nodeStates: new Map(this.state.nodeStates),
+      nodeResults: new Map(this.state.nodeResults)
+    };
+  }
+  /** 注入外部事件监听（由 AgentGraph 实现的 on() 接线） */
+  setEventSink(sink) {
+    this.eventSink = sink;
+    return this;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  /** 每次 run/stream 前重置中止信号、失败记录与执行状态 */
+  resetRun() {
+    this.abortController = new AbortController();
+    this.failedAgents = [];
+    this.state = {
+      nodeStates: /* @__PURE__ */ new Map(),
+      nodeResults: /* @__PURE__ */ new Map(),
+      stepsCompleted: 0,
+      finished: false
+    };
+    this.state.nodeStates.set(this.supervisorNode.id, "pending");
+    for (const w of this.workerNodes) {
+      this.state.nodeStates.set(w.id, "pending");
+    }
+  }
+  throwIfAborted() {
+    if (this.abortController.signal.aborted) {
+      throw new GraphAbortedError();
+    }
   }
   /** 执行 Supervisor 模式 */
   async run(input) {
+    this.resetRun();
     const ctx = createSharedContext({
       meta: { traceId: `sv-${Date.now()}`, startTime: Date.now() }
     });
     if (this.opts.passOriginalInput) {
-      const inputText = typeof input === "string" ? input : input.message;
-      ctx.blackboard.set("__original_input__", inputText);
+      storeOriginalInput(ctx, input);
     }
+    const emit = this.eventSink ?? (() => {
+    });
     try {
-      return await this.executeSupervisor(input, ctx, () => {
-      });
+      const result = await this.executeSupervisor(input, ctx, emit);
+      emit({ type: "graph_done", result });
+      return result;
     } catch (err) {
-      return this.buildErrorResult(ctx, err);
+      const result = this.buildErrorResult(ctx, err);
+      emit({ type: "graph_error", error: result.error ?? "" });
+      return result;
     }
   }
   /** 流式执行 Supervisor 模式 */
-  async *stream(input) {
+  stream(input) {
+    this.resetRun();
     const ctx = createSharedContext({
       meta: { traceId: `sv-${Date.now()}`, startTime: Date.now() }
     });
     if (this.opts.passOriginalInput) {
-      const inputText = typeof input === "string" ? input : input.message;
-      ctx.blackboard.set("__original_input__", inputText);
-    }
-    const eventQueue = [];
-    let resolveEvent = null;
-    let done = false;
-    const emit = (event) => {
-      eventQueue.push(event);
-      resolveEvent?.();
-    };
-    const graphPromise = this.executeSupervisor(input, ctx, emit).then(
-      (result) => {
-        emit({ type: "graph_done", result });
-      },
-      (err) => {
-        emit({ type: "graph_error", error: err instanceof Error ? err.message : String(err) });
-      }
-    ).finally(() => {
-      done = true;
-      resolveEvent?.();
-    });
-    while (!done || eventQueue.length > 0) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift();
-      } else {
-        await new Promise((resolve) => {
-          resolveEvent = resolve;
-        });
-      }
+      storeOriginalInput(ctx, input);
     }
-    await graphPromise;
+    return createEventStream(
+      (emit) => this.executeSupervisor(input, ctx, emit).then(
+        (result) => {
+          emit({ type: "graph_done", result });
+        },
+        (err) => {
+          this.state.error = err instanceof Error ? err.message : String(err);
+          emit({ type: "graph_error", error: this.state.error });
+        }
+      ),
+      this.eventSink
+    );
   }
   /** 核心执行逻辑 */
   async executeSupervisor(input, ctx, emit) {
     let stepsCompleted = 0;
     const totalUsage = {};
+    this.throwIfAborted();
     this.state.currentAgentId = this.supervisorNode.id;
     this.state.nodeStates.set(this.supervisorNode.id, "running");
-    emit({ type: "agent_start", agentId: this.supervisorNode.id, agentName: this.supervisorNode.name });
+    emit({ type: "agent_start", agentId: this.supervisorNode.id, agentName: this.supervisorNode.name, input: toInputText(input) });
     let supervisorResult;
     try {
       supervisorResult = await executeNode(this.supervisorNode, input, ctx);
@@ -2943,18 +3489,21 @@ var SupervisorExecutor = class {
     }
     stepsCompleted += workerResults.size;
     this.state.stepsCompleted = stepsCompleted;
-    const lastWorkerId = this.workerNodes[this.workerNodes.length - 1].id;
-    const finalResult = workerResults.get(lastWorkerId) ?? supervisorResult;
+    const lastEntry = [...workerResults.entries()].at(-1);
+    const finalResult = lastEntry?.[1] ?? supervisorResult;
+    const finalAgentId = lastEntry?.[0] ?? this.supervisorNode.id;
+    const hasFailures = this.failedAgents.length > 0;
     this.state.finished = true;
     return {
       content: finalResult.content,
-      lastAgentId: lastWorkerId,
+      lastAgentId: finalAgentId,
       agentResults: new Map(this.state.nodeResults),
       totalUsage,
       stepsCompleted,
-      stopReason: "completed",
+      stopReason: hasFailures ? "partial_failure" : "completed",
       context: ctx,
-      success: true
+      success: true,
+      ...hasFailures ? { failedAgents: [...this.failedAgents] } : {}
     };
   }
   /** 并行执行所有 Worker */
@@ -2962,16 +3511,28 @@ var SupervisorExecutor = class {
     const results = /* @__PURE__ */ new Map();
     const workers = this.workerNodes;
     const concurrency = this.opts.concurrency;
+    const skip = this.opts.onWorkerError === "skip";
     emit({ type: "parallel_start", agentIds: workers.map((w) => w.id) });
     if (concurrency >= workers.length) {
-      const promises = workers.map(async (worker) => {
-        return this.executeWorker(worker, ctx, emit, totalUsage);
-      });
-      const settled = await Promise.allSettled(promises);
-      for (let i = 0; i < settled.length; i++) {
-        const s = settled[i];
-        if (s.status === "fulfilled") {
-          results.set(workers[i].id, s.value);
+      if (!skip) {
+        await Promise.all(
+          workers.map(async (worker) => {
+            const r = await this.executeWorker(worker, ctx, emit, totalUsage);
+            results.set(worker.id, r);
+            return r;
+          })
+        );
+      } else {
+        const settled = await Promise.allSettled(
+          workers.map((worker) => this.executeWorker(worker, ctx, emit, totalUsage))
+        );
+        for (let i = 0; i < settled.length; i++) {
+          const s = settled[i];
+          if (s.status === "fulfilled") {
+            results.set(workers[i].id, s.value);
+          } else {
+            this.failedAgents.push(workers[i].id);
+          }
         }
       }
     } else {
@@ -2980,12 +3541,20 @@ var SupervisorExecutor = class {
       const enqueue = () => {
         if (index >= workers.length) return null;
         const worker = workers[index++];
-        const p = this.executeWorker(worker, ctx, emit, totalUsage).then((r) => {
-          results.set(worker.id, r);
+        const p = this.executeWorker(worker, ctx, emit, totalUsage).then(
+          (r) => {
+            results.set(worker.id, r);
+          },
+          (err) => {
+            if (!skip) throw err;
+            this.failedAgents.push(worker.id);
+          }
+        ).finally(() => {
           executing.delete(p);
-          return r;
         });
         executing.add(p);
+        p.catch(() => {
+        });
         return p;
       };
       for (let i = 0; i < concurrency && index < workers.length; i++) {
@@ -3002,40 +3571,122 @@ var SupervisorExecutor = class {
   /** 顺序执行所有 Worker */
   async executeWorkersSequential(ctx, emit, totalUsage) {
     const results = /* @__PURE__ */ new Map();
+    const skip = this.opts.onWorkerError === "skip";
     for (const worker of this.workerNodes) {
-      const result = await this.executeWorker(worker, ctx, emit, totalUsage);
-      results.set(worker.id, result);
+      try {
+        const result = await this.executeWorker(worker, ctx, emit, totalUsage);
+        results.set(worker.id, result);
+      } catch (err) {
+        if (!skip) throw err;
+        this.failedAgents.push(worker.id);
+      }
     }
     return results;
   }
-  /** 自动调度：根据 inputMapping 依赖分层执行 */
+  /** 自动调度：按依赖分层执行
+   *
+   * 依赖推导规则：
+   * 1. 显式声明 dependsOn 的 worker：依赖指定的 worker（依赖必须都在 workers 列表中，否则报错）
+   * 2. 未声明 dependsOn 但有 inputMapping 的 worker：隐式依赖所有"第 0 层"worker（保持向后兼容）
+   * 3. 其余 worker（无 dependsOn 且无 inputMapping）：第 0 层，首批并行
+   *
+   * 按拓扑分层：同层并行执行（受 concurrency 限制），层间按序执行；依赖成环时报错。
+   */
   async executeWorkersAuto(ctx, emit, totalUsage) {
     const results = /* @__PURE__ */ new Map();
-    const noInputMapping = this.workerNodes.filter((w) => !w.inputMapping);
-    const withInputMapping = this.workerNodes.filter((w) => !!w.inputMapping);
-    if (noInputMapping.length > 0) {
-      emit({ type: "parallel_start", agentIds: noInputMapping.map((w) => w.id) });
-      const batchResults = await Promise.all(
-        noInputMapping.map((w) => this.executeWorker(w, ctx, emit, totalUsage))
-      );
-      for (let i = 0; i < noInputMapping.length; i++) {
-        results.set(noInputMapping[i].id, batchResults[i]);
+    const skip = this.opts.onWorkerError === "skip";
+    const workerIds = new Set(this.workerNodes.map((w) => w.id));
+    const layer0 = this.workerNodes.filter((w) => !w.inputMapping && !w.dependsOn);
+    const deps = /* @__PURE__ */ new Map();
+    for (const w of this.workerNodes) {
+      if (w.dependsOn) {
+        for (const dep of w.dependsOn) {
+          if (!workerIds.has(dep)) {
+            throw new Error(`Supervisor: Worker "${w.id}" \u7684 dependsOn \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684 Worker "${dep}"`);
+          }
+        }
+        deps.set(w.id, new Set(w.dependsOn));
+      } else if (w.inputMapping) {
+        deps.set(w.id, new Set(layer0.map((l) => l.id)));
+      } else {
+        deps.set(w.id, /* @__PURE__ */ new Set());
       }
-      emit({ type: "parallel_done", results: new Map(results) });
     }
-    for (const worker of withInputMapping) {
-      const result = await this.executeWorker(worker, ctx, emit, totalUsage);
-      results.set(worker.id, result);
+    const remaining = new Map(deps);
+    const layers = [];
+    const doneIds = /* @__PURE__ */ new Set();
+    while (remaining.size > 0) {
+      const layer = [];
+      for (const [id, depSet] of remaining) {
+        if ([...depSet].every((d) => doneIds.has(d))) {
+          layer.push(this.workerNodes.find((w) => w.id === id));
+        }
+      }
+      if (layer.length === 0) {
+        throw new Error(`Supervisor: auto \u8C03\u5EA6\u7684 Worker \u4F9D\u8D56\u5B58\u5728\u73AF\uFF08\u6D89\u53CA: ${[...remaining.keys()].join(", ")}\uFF09`);
+      }
+      for (const w of layer) {
+        remaining.delete(w.id);
+        doneIds.add(w.id);
+      }
+      layers.push(layer);
+    }
+    for (const layer of layers) {
+      if (layer.length === 1) {
+        try {
+          const r = await this.executeWorker(layer[0], ctx, emit, totalUsage);
+          results.set(layer[0].id, r);
+        } catch (err) {
+          if (!skip) throw err;
+          this.failedAgents.push(layer[0].id);
+        }
+        continue;
+      }
+      emit({ type: "parallel_start", agentIds: layer.map((w) => w.id) });
+      const runOne = async (worker) => {
+        try {
+          const r = await this.executeWorker(worker, ctx, emit, totalUsage);
+          results.set(worker.id, r);
+        } catch (err) {
+          if (!skip) throw err;
+          this.failedAgents.push(worker.id);
+        }
+      };
+      if (this.opts.concurrency >= layer.length) {
+        await Promise.all(layer.map((w) => runOne(w)));
+      } else {
+        let index = 0;
+        const executing = /* @__PURE__ */ new Set();
+        const enqueue = () => {
+          if (index >= layer.length) return null;
+          const i = index++;
+          const p = runOne(layer[i]).finally(() => {
+            executing.delete(p);
+          });
+          executing.add(p);
+          p.catch(() => {
+          });
+          return p;
+        };
+        for (let i = 0; i < this.opts.concurrency && index < layer.length; i++) {
+          enqueue();
+        }
+        while (executing.size > 0) {
+          await Promise.race(executing);
+          enqueue();
+        }
+      }
+      emit({ type: "parallel_done", results: new Map(results) });
     }
     return results;
   }
   /** 执行单个 Worker */
   async executeWorker(worker, ctx, emit, totalUsage) {
+    this.throwIfAborted();
     this.state.currentAgentId = worker.id;
     this.state.nodeStates.set(worker.id, "running");
-    emit({ type: "agent_start", agentId: worker.id, agentName: worker.name });
+    let workerInput;
     try {
-      let workerInput;
       if (worker.inputMapping) {
         workerInput = worker.inputMapping(ctx);
       } else {
@@ -3043,6 +3694,14 @@ var SupervisorExecutor = class {
         const myTask = tasks?.find((t) => t.assignee === worker.id);
         workerInput = myTask ? myTask.task : ctx.blackboard.get("__original_input__") ?? "";
       }
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.nodeStates.set(worker.id, "failed");
+      emit({ type: "agent_error", agentId: worker.id, agentName: worker.name, error: errorMsg });
+      throw err;
+    }
+    emit({ type: "agent_start", agentId: worker.id, agentName: worker.name, input: toInputText(workerInput) });
+    try {
       const result = await executeNode(worker, workerInput, ctx);
       this.state.nodeStates.set(worker.id, "completed");
       this.state.nodeResults.set(worker.id, result);
@@ -3059,16 +3718,21 @@ var SupervisorExecutor = class {
   }
   buildErrorResult(ctx, err) {
     this.state.finished = true;
+    const aborted = err instanceof GraphAbortedError;
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    this.state.error = errorMsg;
+    const lastCompleted = [...this.state.nodeResults.values()].at(-1);
     return {
-      content: "",
-      lastAgentId: this.supervisorNode.id,
+      content: aborted ? lastCompleted?.content ?? "" : "",
+      lastAgentId: this.state.currentAgentId ?? this.supervisorNode.id,
       agentResults: new Map(this.state.nodeResults),
       totalUsage: {},
       stepsCompleted: this.state.stepsCompleted,
-      stopReason: "error",
+      stopReason: aborted ? "aborted" : "error",
       context: ctx,
       success: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: errorMsg,
+      ...this.failedAgents.length > 0 ? { failedAgents: [...this.failedAgents] } : {}
     };
   }
   mergeUsage(total, usage) {
@@ -3081,7 +3745,8 @@ var SupervisorExecutor = class {
 // patterns/supervisor.ts
 var SupervisorGraphImpl = class {
   executor;
-  eventListeners = /* @__PURE__ */ new Map();
+  /** on() 注册的监听器，按 MultiAgentEvent.type 分发 */
+  bus = new SimpleEventBus();
   constructor(supervisor, workers, opts) {
     this.executor = new SupervisorExecutor(supervisor, workers, opts);
   }
@@ -3099,23 +3764,21 @@ var SupervisorGraphImpl = class {
     throw new Error("Supervisor \u6A21\u5F0F\u4E0D\u652F\u6301 setFinish\uFF0C\u7EC8\u6B62\u7531 Supervisor \u5224\u5B9A");
   }
   async run(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     return this.executor.run(input);
   }
   async *stream(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     yield* this.executor.stream(input);
   }
   getState() {
     return this.executor.getState();
   }
   abort() {
+    this.executor.abort();
   }
   on(event, listener) {
-    let set = this.eventListeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.eventListeners.set(event, set);
-    }
-    set.add(listener);
+    this.bus.on(event, listener);
     return this;
   }
 };
@@ -3133,6 +3796,9 @@ var DebateExecutor = class {
   maxRounds;
   convergeWhen;
   feedbackTransform;
+  abortController = new AbortController();
+  /** 外部事件监听（on() API 的底层接线） */
+  eventSink;
   state = {
     nodeStates: /* @__PURE__ */ new Map(),
     nodeResults: /* @__PURE__ */ new Map(),
@@ -3155,53 +3821,75 @@ ${proposerResult.content}`;
     this.state.nodeStates.set(reviewer.id, "pending");
   }
   getState() {
-    return { ...this.state };
+    return {
+      ...this.state,
+      nodeStates: new Map(this.state.nodeStates),
+      nodeResults: new Map(this.state.nodeResults)
+    };
+  }
+  /** 注入外部事件监听（由 AgentGraph 实现的 on() 接线） */
+  setEventSink(sink) {
+    this.eventSink = sink;
+    return this;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  /** 每次 run/stream 前重置中止信号与执行状态 */
+  resetAbortController() {
+    this.abortController = new AbortController();
+    this.state = {
+      nodeStates: /* @__PURE__ */ new Map(),
+      nodeResults: /* @__PURE__ */ new Map(),
+      stepsCompleted: 0,
+      finished: false
+    };
+    this.state.nodeStates.set(this.proposerNode.id, "pending");
+    this.state.nodeStates.set(this.reviewerNode.id, "pending");
+  }
+  throwIfAborted() {
+    if (this.abortController.signal.aborted) {
+      throw new GraphAbortedError();
+    }
   }
   /** 执行 Debate */
   async run(input) {
+    this.resetAbortController();
     const ctx = createSharedContext({
       meta: { traceId: `debate-${Date.now()}`, startTime: Date.now() }
     });
+    storeOriginalInput(ctx, input);
+    const emit = this.eventSink ?? (() => {
+    });
     try {
-      return await this.executeDebate(input, ctx, () => {
-      });
+      const result = await this.executeDebate(input, ctx, emit);
+      emit({ type: "graph_done", result });
+      return result;
     } catch (err) {
-      return this.buildErrorResult(ctx, err);
+      const result = this.buildErrorResult(ctx, err);
+      emit({ type: "graph_error", error: result.error ?? "" });
+      return result;
     }
   }
   /** 流式执行 Debate */
-  async *stream(input) {
+  stream(input) {
+    this.resetAbortController();
     const ctx = createSharedContext({
       meta: { traceId: `debate-${Date.now()}`, startTime: Date.now() }
     });
-    const eventQueue = [];
-    let resolveEvent = null;
-    let done = false;
-    const emit = (event) => {
-      eventQueue.push(event);
-      resolveEvent?.();
-    };
-    const graphPromise = this.executeDebate(input, ctx, emit).then(
-      (result) => {
-        emit({ type: "graph_done", result });
-      },
-      (err) => {
-        emit({ type: "graph_error", error: err instanceof Error ? err.message : String(err) });
-      }
-    ).finally(() => {
-      done = true;
-      resolveEvent?.();
-    });
-    while (!done || eventQueue.length > 0) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift();
-      } else {
-        await new Promise((resolve) => {
-          resolveEvent = resolve;
-        });
-      }
-    }
-    await graphPromise;
+    storeOriginalInput(ctx, input);
+    return createEventStream(
+      (emit) => this.executeDebate(input, ctx, emit).then(
+        (result) => {
+          emit({ type: "graph_done", result });
+        },
+        (err) => {
+          this.state.error = err instanceof Error ? err.message : String(err);
+          emit({ type: "graph_error", error: this.state.error });
+        }
+      ),
+      this.eventSink
+    );
   }
   /** 核心执行逻辑 */
   async executeDebate(input, ctx, emit) {
@@ -3213,10 +3901,11 @@ ${proposerResult.content}`;
     let convergeReason = "";
     let currentInput = input;
     for (let round = 1; round <= this.maxRounds; round++) {
+      this.throwIfAborted();
       emit({ type: "round_start", round });
       this.state.currentAgentId = this.proposerNode.id;
       this.state.nodeStates.set(this.proposerNode.id, "running");
-      emit({ type: "agent_start", agentId: this.proposerNode.id, agentName: this.proposerNode.name });
+      emit({ type: "agent_start", agentId: this.proposerNode.id, agentName: this.proposerNode.name, input: toInputText(currentInput) });
       try {
         lastProposerResult = await executeNode(this.proposerNode, currentInput, ctx);
         this.state.nodeStates.set(this.proposerNode.id, "completed");
@@ -3233,7 +3922,7 @@ ${proposerResult.content}`;
       }
       this.state.currentAgentId = this.reviewerNode.id;
       this.state.nodeStates.set(this.reviewerNode.id, "running");
-      emit({ type: "agent_start", agentId: this.reviewerNode.id, agentName: this.reviewerNode.name });
+      emit({ type: "agent_start", agentId: this.reviewerNode.id, agentName: this.reviewerNode.name, input: lastProposerResult.content });
       try {
         lastReviewerResult = await executeNode(this.reviewerNode, lastProposerResult.content, ctx);
         this.state.nodeStates.set(this.reviewerNode.id, "completed");
@@ -3272,16 +3961,20 @@ ${proposerResult.content}`;
   }
   buildErrorResult(ctx, err) {
     this.state.finished = true;
+    const aborted = err instanceof GraphAbortedError;
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    this.state.error = errorMsg;
+    const lastCompleted = [...this.state.nodeResults.values()].at(-1);
     return {
-      content: "",
+      content: aborted ? lastCompleted?.content ?? "" : "",
       lastAgentId: this.proposerNode.id,
       agentResults: new Map(this.state.nodeResults),
       totalUsage: {},
       stepsCompleted: this.state.stepsCompleted,
-      stopReason: "error",
+      stopReason: aborted ? "aborted" : "error",
       context: ctx,
       success: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: errorMsg
     };
   }
   mergeUsage(total, usage) {
@@ -3294,7 +3987,8 @@ ${proposerResult.content}`;
 // patterns/debate.ts
 var DebateGraphImpl = class {
   executor;
-  eventListeners = /* @__PURE__ */ new Map();
+  /** on() 注册的监听器，按 MultiAgentEvent.type 分发 */
+  bus = new SimpleEventBus();
   constructor(proposer, reviewer, opts) {
     this.executor = new DebateExecutor(proposer, reviewer, opts);
   }
@@ -3311,23 +4005,21 @@ var DebateGraphImpl = class {
     throw new Error("Debate \u6A21\u5F0F\u4E0D\u652F\u6301 setFinish");
   }
   async run(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     return this.executor.run(input);
   }
   async *stream(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     yield* this.executor.stream(input);
   }
   getState() {
     return this.executor.getState();
   }
   abort() {
+    this.executor.abort();
   }
   on(event, listener) {
-    let set = this.eventListeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.eventListeners.set(event, set);
-    }
-    set.add(listener);
+    this.bus.on(event, listener);
     return this;
   }
 };
@@ -3341,7 +4033,11 @@ var MapReduceExecutor = class {
   reducerNode;
   split;
   concurrency;
+  onMapperError;
   reduceInputFormat;
+  abortController = new AbortController();
+  /** 外部事件监听（on() API 的底层接线） */
+  eventSink;
   state = {
     nodeStates: /* @__PURE__ */ new Map(),
     nodeResults: /* @__PURE__ */ new Map(),
@@ -3353,6 +4049,7 @@ var MapReduceExecutor = class {
     this.reducerNode = reducer;
     this.split = opts.split;
     this.concurrency = opts.concurrency ?? Infinity;
+    this.onMapperError = opts.onMapperError ?? "fail-fast";
     this.reduceInputFormat = opts.reduceInputFormat ?? ((mapperResults) => {
       const parts = [];
       for (const [idx, result] of mapperResults) {
@@ -3365,132 +4062,98 @@ ${result.content}`);
     this.state.nodeStates.set(reducer.id, "pending");
   }
   getState() {
-    return { ...this.state };
+    return {
+      ...this.state,
+      nodeStates: new Map(this.state.nodeStates),
+      nodeResults: new Map(this.state.nodeResults)
+    };
   }
-  /** 执行 MapReduce */
-  async run(input) {
+  /** 注入外部事件监听（由 AgentGraph 实现的 on() 接线） */
+  setEventSink(sink) {
+    this.eventSink = sink;
+    return this;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  /** 每次 run/stream 前重置中止信号与执行状态 */
+  resetAbortController() {
+    this.abortController = new AbortController();
+    this.state = {
+      nodeStates: /* @__PURE__ */ new Map(),
+      nodeResults: /* @__PURE__ */ new Map(),
+      stepsCompleted: 0,
+      finished: false
+    };
+    this.state.nodeStates.set(this.mapperNode.id, "pending");
+    this.state.nodeStates.set(this.reducerNode.id, "pending");
+  }
+  throwIfAborted() {
+    if (this.abortController.signal.aborted) {
+      throw new GraphAbortedError();
+    }
+  }
+  /** 拆分输入并校验（每次 run/stream 只调用一次 split，避免副作用放大） */
+  splitInput(input) {
     const inputText = typeof input === "string" ? input : input.message;
     const chunks = this.split(inputText);
     if (chunks.length === 0) {
       throw new Error("MapReduce: split \u51FD\u6570\u8FD4\u56DE\u4E86\u7A7A\u6570\u7EC4\uFF0C\u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B50\u4EFB\u52A1");
     }
+    return chunks;
+  }
+  /** 执行 MapReduce */
+  async run(input) {
+    this.resetAbortController();
+    const chunks = this.splitInput(input);
     const ctx = createSharedContext({
       meta: { traceId: `mr-${Date.now()}`, startTime: Date.now() }
     });
+    storeOriginalInput(ctx, input);
+    const emit = this.eventSink ?? (() => {
+    });
     try {
-      return await this.executeMapReduce(input, ctx, () => {
-      });
+      const result = await this.executeMapReduce(chunks, ctx, emit);
+      emit({ type: "graph_done", result });
+      return result;
     } catch (err) {
-      return this.buildErrorResult(ctx, err);
+      const result = this.buildErrorResult(ctx, err);
+      emit({ type: "graph_error", error: result.error ?? "" });
+      return result;
     }
   }
   /** 流式执行 MapReduce */
-  async *stream(input) {
-    const inputText = typeof input === "string" ? input : input.message;
-    const chunks = this.split(inputText);
-    if (chunks.length === 0) {
-      throw new Error("MapReduce: split \u51FD\u6570\u8FD4\u56DE\u4E86\u7A7A\u6570\u7EC4\uFF0C\u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B50\u4EFB\u52A1");
-    }
+  stream(input) {
+    this.resetAbortController();
+    const chunks = this.splitInput(input);
     const ctx = createSharedContext({
       meta: { traceId: `mr-${Date.now()}`, startTime: Date.now() }
     });
-    const eventQueue = [];
-    let resolveEvent = null;
-    let done = false;
-    const emit = (event) => {
-      eventQueue.push(event);
-      resolveEvent?.();
-    };
-    const graphPromise = this.executeMapReduce(input, ctx, emit).then(
-      (result) => {
-        emit({ type: "graph_done", result });
-      },
-      (err) => {
-        emit({ type: "graph_error", error: err instanceof Error ? err.message : String(err) });
-      }
-    ).finally(() => {
-      done = true;
-      resolveEvent?.();
-    });
-    while (!done || eventQueue.length > 0) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift();
-      } else {
-        await new Promise((resolve) => {
-          resolveEvent = resolve;
-        });
-      }
-    }
-    await graphPromise;
+    storeOriginalInput(ctx, input);
+    return createEventStream(
+      (emit) => this.executeMapReduce(chunks, ctx, emit).then(
+        (result) => {
+          emit({ type: "graph_done", result });
+        },
+        (err) => {
+          this.state.error = err instanceof Error ? err.message : String(err);
+          emit({ type: "graph_error", error: this.state.error });
+        }
+      ),
+      this.eventSink
+    );
   }
   /** 核心执行逻辑 */
-  async executeMapReduce(input, ctx, emit) {
-    let stepsCompleted = 0;
+  async executeMapReduce(chunks, ctx, emit) {
     const totalUsage = {};
-    const inputText = typeof input === "string" ? input : input.message;
-    const chunks = this.split(inputText);
-    const mapperResults = /* @__PURE__ */ new Map();
+    this.throwIfAborted();
     this.state.nodeStates.set(this.mapperNode.id, "running");
-    const mapperAgentIds = chunks.map((_, i) => `${this.mapperNode.id}_${i}`);
-    emit({ type: "parallel_start", agentIds: mapperAgentIds });
-    if (this.concurrency >= chunks.length) {
-      const promises = chunks.map(async (chunk, index) => {
-        emit({ type: "agent_start", agentId: `${this.mapperNode.id}_${index}`, agentName: `${this.mapperNode.name}#${index + 1}` });
-        try {
-          const result = await executeNode(this.mapperNode, chunk, ctx);
-          this.state.nodeResults.set(`${this.mapperNode.id}_${index}`, result);
-          this.mergeUsage(totalUsage, result.usage);
-          stepsCompleted++;
-          this.state.stepsCompleted = stepsCompleted;
-          emit({ type: "agent_result", agentId: `${this.mapperNode.id}_${index}`, agentName: `${this.mapperNode.name}#${index + 1}`, result });
-          return { index, result };
-        } catch (err) {
-          const errorMsg = err instanceof Error ? err.message : String(err);
-          emit({ type: "agent_error", agentId: `${this.mapperNode.id}_${index}`, agentName: `${this.mapperNode.name}#${index + 1}`, error: errorMsg });
-          throw err;
-        }
-      });
-      const settled = await Promise.allSettled(promises);
-      for (const s of settled) {
-        if (s.status === "fulfilled") {
-          mapperResults.set(s.value.index, s.value.result);
-        }
-      }
-    } else {
-      let index = 0;
-      const executing = /* @__PURE__ */ new Set();
-      const enqueue = () => {
-        if (index >= chunks.length) return null;
-        const currentIndex = index++;
-        const chunk = chunks[currentIndex];
-        const p = (async () => {
-          emit({ type: "agent_start", agentId: `${this.mapperNode.id}_${currentIndex}`, agentName: `${this.mapperNode.name}#${currentIndex + 1}` });
-          try {
-            const result = await executeNode(this.mapperNode, chunk, ctx);
-            mapperResults.set(currentIndex, result);
-            this.state.nodeResults.set(`${this.mapperNode.id}_${currentIndex}`, result);
-            this.mergeUsage(totalUsage, result.usage);
-            stepsCompleted++;
-            this.state.stepsCompleted = stepsCompleted;
-            emit({ type: "agent_result", agentId: `${this.mapperNode.id}_${currentIndex}`, agentName: `${this.mapperNode.name}#${currentIndex + 1}`, result });
-          } catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            emit({ type: "agent_error", agentId: `${this.mapperNode.id}_${currentIndex}`, agentName: `${this.mapperNode.name}#${currentIndex + 1}`, error: errorMsg });
-            throw err;
-          }
-        })();
-        executing.add(p);
-        p.finally(() => executing.delete(p));
-        return p;
-      };
-      for (let i = 0; i < this.concurrency && index < chunks.length; i++) {
-        enqueue();
-      }
-      while (executing.size > 0) {
-        await Promise.race(executing);
-        enqueue();
-      }
-    }
+    chunks.forEach((_, i) => {
+      this.state.nodeStates.set(`${this.mapperNode.id}_${i}`, "pending");
+    });
+    const { results: mapperResults, failed } = await this.runMappers(chunks, ctx, emit, totalUsage);
+    let stepsCompleted = mapperResults.size + failed.length;
+    this.state.stepsCompleted = stepsCompleted;
     this.state.nodeStates.set(this.mapperNode.id, "completed");
     const mapperResultsForEmit = /* @__PURE__ */ new Map();
     for (const [idx, result] of mapperResults) {
@@ -3498,10 +4161,14 @@ ${result.content}`);
     }
     emit({ type: "parallel_done", results: mapperResultsForEmit });
     ctx.blackboard.set("mapper_results", mapperResults);
+    if (failed.length > 0 && mapperResults.size === 0) {
+      throw new Error(`MapReduce: \u6240\u6709 mapper \u5747\u5931\u8D25\uFF08${failed.length}/${chunks.length}\uFF09`);
+    }
     const reduceInput = this.reduceInputFormat(mapperResults);
+    this.throwIfAborted();
     this.state.currentAgentId = this.reducerNode.id;
     this.state.nodeStates.set(this.reducerNode.id, "running");
-    emit({ type: "agent_start", agentId: this.reducerNode.id, agentName: this.reducerNode.name });
+    emit({ type: "agent_start", agentId: this.reducerNode.id, agentName: this.reducerNode.name, input: reduceInput });
     let reducerResult;
     try {
       reducerResult = await executeNode(this.reducerNode, reduceInput, ctx);
@@ -3518,29 +4185,94 @@ ${result.content}`);
       throw err;
     }
     this.state.finished = true;
+    const hasFailures = failed.length > 0;
     return {
       content: reducerResult.content,
       lastAgentId: this.reducerNode.id,
       agentResults: new Map(this.state.nodeResults),
       totalUsage,
       stepsCompleted,
-      stopReason: "completed",
+      stopReason: hasFailures ? "partial_failure" : "completed",
       context: ctx,
-      success: true
+      success: true,
+      ...hasFailures ? { failedAgents: failed } : {}
+    };
+  }
+  /** 并行执行所有 mapper 子任务（统一处理并发限制与失败策略） */
+  async runMappers(chunks, ctx, emit, totalUsage) {
+    const results = /* @__PURE__ */ new Map();
+    const failed = [];
+    const skip = this.onMapperError === "skip";
+    const mapperId = this.mapperNode.id;
+    const mapperAgentIds = chunks.map((_, i) => `${mapperId}_${i}`);
+    emit({ type: "parallel_start", agentIds: mapperAgentIds });
+    const runOne = async (index) => {
+      const agentId = `${mapperId}_${index}`;
+      const agentName = `${this.mapperNode.name}#${index + 1}`;
+      emit({ type: "agent_start", agentId, agentName, input: chunks[index] });
+      this.state.nodeStates.set(agentId, "running");
+      try {
+        const result = await executeNode(this.mapperNode, chunks[index], ctx);
+        this.state.nodeResults.set(agentId, result);
+        this.state.nodeStates.set(agentId, "completed");
+        this.mergeUsage(totalUsage, result.usage);
+        results.set(index, result);
+        emit({ type: "agent_result", agentId, agentName, result });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        this.state.nodeStates.set(agentId, "failed");
+        emit({ type: "agent_error", agentId, agentName, error: errorMsg });
+        if (!skip) throw err;
+        failed.push(agentId);
+      }
     };
+    if (this.concurrency >= chunks.length) {
+      const promises = chunks.map((_, i) => runOne(i));
+      if (!skip) {
+        await Promise.all(promises);
+      } else {
+        await Promise.allSettled(promises);
+      }
+    } else {
+      let index = 0;
+      const executing = /* @__PURE__ */ new Set();
+      const enqueue = () => {
+        if (index >= chunks.length) return null;
+        const i = index++;
+        const p = runOne(i).finally(() => {
+          executing.delete(p);
+        });
+        executing.add(p);
+        p.catch(() => {
+        });
+        return p;
+      };
+      for (let i = 0; i < this.concurrency && index < chunks.length; i++) {
+        enqueue();
+      }
+      while (executing.size > 0) {
+        await Promise.race(executing);
+        enqueue();
+      }
+    }
+    return { results, failed };
   }
   buildErrorResult(ctx, err) {
     this.state.finished = true;
+    const aborted = err instanceof GraphAbortedError;
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    this.state.error = errorMsg;
+    const lastCompleted = [...this.state.nodeResults.values()].at(-1);
     return {
-      content: "",
+      content: aborted ? lastCompleted?.content ?? "" : "",
       lastAgentId: this.mapperNode.id,
       agentResults: new Map(this.state.nodeResults),
       totalUsage: {},
       stepsCompleted: this.state.stepsCompleted,
-      stopReason: "error",
+      stopReason: aborted ? "aborted" : "error",
       context: ctx,
       success: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: errorMsg
     };
   }
   mergeUsage(total, usage) {
@@ -3553,7 +4285,8 @@ ${result.content}`);
 // patterns/map-reduce.ts
 var MapReduceGraphImpl = class {
   executor;
-  eventListeners = /* @__PURE__ */ new Map();
+  /** on() 注册的监听器，按 MultiAgentEvent.type 分发 */
+  bus = new SimpleEventBus();
   constructor(mapper, reducer, opts) {
     this.executor = new MapReduceExecutor(mapper, reducer, opts);
   }
@@ -3570,23 +4303,21 @@ var MapReduceGraphImpl = class {
     throw new Error("MapReduce \u6A21\u5F0F\u4E0D\u652F\u6301 setFinish");
   }
   async run(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     return this.executor.run(input);
   }
   async *stream(input) {
+    this.executor.setEventSink((event) => this.bus.emit(event.type, event));
     yield* this.executor.stream(input);
   }
   getState() {
     return this.executor.getState();
   }
   abort() {
+    this.executor.abort();
   }
   on(event, listener) {
-    let set = this.eventListeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.eventListeners.set(event, set);
-    }
-    set.add(listener);
+    this.bus.on(event, listener);
     return this;
   }
 };
@@ -4225,6 +4956,7 @@ var GraphDebugger = class {
     const graphStartTime = Date.now();
     const steps = [];
     let stepIndex = 0;
+    let finalResult;
     for await (const event of this.graph.stream(input)) {
       if (event.type === "agent_start") {
         stepIndex++;
@@ -4234,7 +4966,7 @@ var GraphDebugger = class {
           agentName: event.agentName,
           startTime: Date.now(),
           duration: 0,
-          input: "",
+          input: event.input ?? "",
           output: "",
           state: "running"
         });
@@ -4259,6 +4991,8 @@ var GraphDebugger = class {
           step.error = event.error;
           step.state = "failed";
         }
+      } else if (event.type === "graph_done") {
+        finalResult = event.result;
       }
     }
     const state = this.graph.getState();
@@ -4269,10 +5003,10 @@ var GraphDebugger = class {
       duration: graphDuration,
       steps,
       result: {
-        success: !state.error,
-        content: state.error ?? "",
-        stopReason: state.error ? "error" : "completed",
-        stepsCompleted: state.stepsCompleted
+        success: finalResult ? finalResult.success : !state.error,
+        content: finalResult?.content ?? "",
+        stopReason: finalResult?.stopReason ?? (state.error ? "error" : "completed"),
+        stepsCompleted: finalResult?.stepsCompleted ?? state.stepsCompleted
       }
     };
   }
@@ -4324,13 +5058,16 @@ function createDebugger(graph) {
   return new GraphDebugger(graph);
 }
 export {
+  GraphAbortedError,
   GraphDebugger,
   MCPBridge,
+  NodeTimeoutError,
   SimpleEventBus,
   SimpleToolRegistry,
   createAgentGraph,
   createDebate,
   createDebugger,
+  createEventStream,
   createMCPBridge,
   createMapReduce,
   createMultiAgentMcpServerHost,