@aipack-ai/multi-agent 1.1.6 → 1.1.7

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) {
@@ -2478,7 +2482,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 +2543,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 +2615,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 +2648,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 +2692,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 +2776,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 +2795,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 +2947,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 +2970,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 +2984,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 +3027,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 +3051,6 @@ function createRouter(router, targets, opts) {
       }
     });
   }
-  if (opts.defaultTarget && targetIds.has(opts.defaultTarget)) {
-  }
   return graph;
 }
 
@@ -2834,6 +3059,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 +3076,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 +3085,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 +3196,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 +3218,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 +3248,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 +3278,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 +3401,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 +3425,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 +3452,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 +3471,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 +3503,9 @@ var DebateExecutor = class {
   maxRounds;
   convergeWhen;
   feedbackTransform;
+  abortController = new AbortController();
+  /** 外部事件监听（on() API 的底层接线） */
+  eventSink;
   state = {
     nodeStates: /* @__PURE__ */ new Map(),
     nodeResults: /* @__PURE__ */ new Map(),
@@ -3155,53 +3528,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 +3608,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 +3629,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 +3668,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 +3694,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 +3712,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 +3740,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 +3756,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 +3769,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 +3868,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 +3892,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 +3992,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 +4010,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 +4663,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 +4673,7 @@ var GraphDebugger = class {
           agentName: event.agentName,
           startTime: Date.now(),
           duration: 0,
-          input: "",
+          input: event.input ?? "",
           output: "",
           state: "running"
         });
@@ -4259,6 +4698,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 +4710,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 +4765,16 @@ function createDebugger(graph) {
   return new GraphDebugger(graph);
 }
 export {
+  GraphAbortedError,
   GraphDebugger,
   MCPBridge,
+  NodeTimeoutError,
   SimpleEventBus,
   SimpleToolRegistry,
   createAgentGraph,
   createDebate,
   createDebugger,
+  createEventStream,
   createMCPBridge,
   createMapReduce,
   createMultiAgentMcpServerHost,