@aipack-ai/multi-agent 0.0.1

package/dist/index.js

@@ -0,0 +1,3813 @@
+// core/context.ts
+var SimpleEventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, data) {
+    const set = this.listeners.get(event);
+    if (set) {
+      for (const listener of set) {
+        try {
+          listener(data);
+        } catch {
+        }
+      }
+    }
+    return this;
+  }
+};
+var SimpleToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.name, tool);
+    return this;
+  }
+  registerAll(tools) {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool);
+    }
+    return this;
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+};
+function createSharedContext(init) {
+  return {
+    blackboard: init?.blackboard ?? /* @__PURE__ */ new Map(),
+    bus: init?.bus ?? new SimpleEventBus(),
+    toolRegistry: init?.toolRegistry ?? new SimpleToolRegistry(),
+    meta: init?.meta ?? {}
+  };
+}
+
+// ../agent/core/types.ts
+function extractText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((c) => c.type === "text").map((c) => c.text).join("");
+}
+function extractToolCalls(content) {
+  if (typeof content === "string") return [];
+  return content.filter((c) => c.type === "toolCall");
+}
+function createTextContent(text) {
+  return { type: "text", text };
+}
+function createEmptyUsage() {
+  return { input: 0, output: 0, total: 0 };
+}
+
+// ../agent/core/tapable.ts
+var AsyncSeriesHook = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+  taps = [];
+  tapPromise(name, fn, stage) {
+    this.taps.push({ name, type: "promise", fn, stage: stage ?? 0 });
+    this.taps.sort((a, b) => (a.stage ?? 0) - (b.stage ?? 0));
+  }
+  async promise(...args) {
+    for (const tap of this.taps) {
+      try {
+        await tap.fn(...args);
+      } catch (err) {
+      }
+    }
+  }
+  isUsed() {
+    return this.taps.length > 0;
+  }
+  clear() {
+    this.taps = [];
+  }
+};
+var AsyncSeriesWaterfallHook = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+  taps = [];
+  tapPromise(name, fn, stage) {
+    this.taps.push({ name, type: "promise", fn, stage: stage ?? 0 });
+    this.taps.sort((a, b) => (a.stage ?? 0) - (b.stage ?? 0));
+  }
+  async promise(value, ...rest) {
+    let current = value;
+    for (const tap of this.taps) {
+      try {
+        current = await tap.fn(current, ...rest);
+      } catch (err) {
+      }
+    }
+    return current;
+  }
+  isUsed() {
+    return this.taps.length > 0;
+  }
+  clear() {
+    this.taps = [];
+  }
+};
+
+// ../agent/core/request.ts
+function createRequest(message, options) {
+  return {
+    message,
+    type: "message",
+    ...options
+  };
+}
+
+// ../agent/core/context-resource.ts
+var ContextResourceBuilder = class {
+  _id;
+  _type = "custom";
+  _role = "user";
+  _content = "";
+  _timestamp = Date.now();
+  _dependencies = [];
+  _meta = {};
+  _pinned = false;
+  constructor(id) {
+    this._id = id || `res_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  }
+  id(id) {
+    this._id = id;
+    return this;
+  }
+  type(t) {
+    this._type = t;
+    return this;
+  }
+  role(r) {
+    this._role = r;
+    return this;
+  }
+  content(c) {
+    this._content = c;
+    return this;
+  }
+  timestamp(ts) {
+    this._timestamp = ts;
+    return this;
+  }
+  dependsOn(...ids) {
+    this._dependencies.push(...ids);
+    return this;
+  }
+  meta(key, value) {
+    this._meta[key] = value;
+    return this;
+  }
+  pinned(p = true) {
+    this._pinned = p;
+    return this;
+  }
+  build() {
+    return {
+      id: this._id,
+      type: this._type,
+      role: this._role,
+      content: this._content,
+      timestamp: this._timestamp,
+      dependencies: this._dependencies,
+      meta: this._meta,
+      pinned: this._pinned
+    };
+  }
+};
+function createToolResultResource(toolCallId, toolName, result, isError, dependsOn, options) {
+  return new ContextResourceBuilder().id(`${toolCallId}_result`).type("tool_result").role("toolResult").content(result).dependsOn(dependsOn).meta("toolName", toolName).meta("toolCallId", toolCallId).meta("isError", isError).timestamp(options?.timestamp ?? Date.now()).build();
+}
+
+// ../agent/core/task-graph.ts
+var TaskGraphImpl = class {
+  nodes = /* @__PURE__ */ new Map();
+  _size = 0;
+  get size() {
+    return this._size;
+  }
+  add(resource) {
+    if (this.nodes.has(resource.id)) {
+      this.remove(resource.id);
+    }
+    const node = {
+      resource,
+      dependents: /* @__PURE__ */ new Set(),
+      dependencies: /* @__PURE__ */ new Set()
+    };
+    for (const depId of resource.dependencies) {
+      node.dependencies.add(depId);
+      const depNode = this.nodes.get(depId);
+      if (depNode) {
+        depNode.dependents.add(resource.id);
+      }
+    }
+    this.nodes.set(resource.id, node);
+    this._size++;
+  }
+  addAll(resources) {
+    for (const res of resources) {
+      if (!this.nodes.has(res.id)) {
+        this.nodes.set(res.id, {
+          resource: res,
+          dependents: /* @__PURE__ */ new Set(),
+          dependencies: /* @__PURE__ */ new Set()
+        });
+        this._size++;
+      }
+    }
+    for (const res of resources) {
+      const node = this.nodes.get(res.id);
+      for (const depId of res.dependencies) {
+        node.dependencies.add(depId);
+        const depNode = this.nodes.get(depId);
+        if (depNode) {
+          depNode.dependents.add(res.id);
+        }
+      }
+    }
+  }
+  resolve(id) {
+    return this.nodes.get(id)?.resource;
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  remove(id) {
+    const node = this.nodes.get(id);
+    if (!node) return false;
+    for (const depId of node.dependencies) {
+      const depNode = this.nodes.get(depId);
+      depNode?.dependents.delete(id);
+    }
+    for (const dependentId of node.dependents) {
+      const dependentNode = this.nodes.get(dependentId);
+      dependentNode?.dependencies.delete(id);
+    }
+    this.nodes.delete(id);
+    this._size--;
+    return true;
+  }
+  getAll() {
+    return Array.from(this.nodes.values()).map((n) => n.resource);
+  }
+  getByType(type) {
+    return this.getAll().filter((r) => r.type === type);
+  }
+  topologicalSort() {
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (id) => {
+      if (visited.has(id)) return;
+      if (visiting.has(id)) return;
+      visiting.add(id);
+      const node = this.nodes.get(id);
+      if (node) {
+        for (const depId of node.dependencies) {
+          visit(depId);
+        }
+        result.push(node.resource);
+      }
+      visiting.delete(id);
+      visited.add(id);
+    };
+    for (const id of this.nodes.keys()) {
+      visit(id);
+    }
+    return result;
+  }
+  isReachable(from, to) {
+    if (from === to) return true;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [from];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const node = this.nodes.get(current);
+      if (!node) continue;
+      for (const depId of node.dependencies) {
+        if (depId === to) return true;
+        if (!visited.has(depId)) {
+          queue.push(depId);
+        }
+      }
+    }
+    return false;
+  }
+  getLeaves() {
+    return Array.from(this.nodes.values()).filter((n) => n.dependencies.size === 0).map((n) => n.resource);
+  }
+  getRoots() {
+    return Array.from(this.nodes.values()).filter((n) => n.dependents.size === 0).map((n) => n.resource);
+  }
+  clear() {
+    this.nodes.clear();
+    this._size = 0;
+  }
+};
+function createTaskGraph() {
+  return new TaskGraphImpl();
+}
+
+// ../agent/core/extension.ts
+var ExtensionManager = class {
+  extensions = [];
+  hooks;
+  constructor() {
+    this.hooks = this.createHooks();
+  }
+  createHooks() {
+    return {
+      beforeInitialize: new AsyncSeriesHook("beforeInitialize"),
+      afterInitialize: new AsyncSeriesHook("afterInitialize"),
+      beforeRun: new AsyncSeriesWaterfallHook("beforeRun"),
+      beforeTransform: new AsyncSeriesWaterfallHook("beforeTransform"),
+      afterTransform: new AsyncSeriesWaterfallHook("afterTransform"),
+      beforeEmit: new AsyncSeriesHook("beforeEmit"),
+      afterEmit: new AsyncSeriesHook("afterEmit"),
+      done: new AsyncSeriesHook("done"),
+      failed: new AsyncSeriesHook("failed"),
+      beforeToolCall: new AsyncSeriesWaterfallHook("beforeToolCall"),
+      afterToolCall: new AsyncSeriesWaterfallHook("afterToolCall")
+    };
+  }
+  /** 注册扩展 */
+  register(extension) {
+    this.extensions.push(extension);
+    return this;
+  }
+  /** 批量注册扩展 */
+  registerAll(extensions) {
+    for (const ext of extensions) {
+      this.register(ext);
+    }
+    return this;
+  }
+  /** 应用所有扩展到钩子 */
+  applyAll(context) {
+    for (const ext of this.extensions) {
+      try {
+        ext.apply(this.hooks, context);
+      } catch (err) {
+        console.warn(`[Extension] "${ext.name}" apply \u5931\u8D25:`, err?.message ?? err);
+      }
+    }
+  }
+  /** 获取钩子集合 */
+  getHooks() {
+    return this.hooks;
+  }
+  /** 移除扩展 */
+  unregister(name) {
+    const idx = this.extensions.findIndex((e) => e.name === name);
+    if (idx === -1) return false;
+    this.extensions.splice(idx, 1);
+    return true;
+  }
+  /** 获取所有已注册的扩展 */
+  getExtensions() {
+    return [...this.extensions];
+  }
+  /** 清空所有扩展 */
+  clear() {
+    this.extensions = [];
+  }
+};
+
+// ../agent/core/result.ts
+var ResultBuilder = class {
+  _content = "";
+  _toolsUsed = [];
+  _usage = {};
+  _stopReason = "completed";
+  _metadata = {};
+  _error;
+  _success = true;
+  _resources;
+  content(c) {
+    this._content = c;
+    return this;
+  }
+  toolsUsed(tools) {
+    this._toolsUsed = tools;
+    return this;
+  }
+  addTool(tool) {
+    if (!this._toolsUsed.includes(tool)) {
+      this._toolsUsed.push(tool);
+    }
+    return this;
+  }
+  usage(u) {
+    this._usage = u;
+    return this;
+  }
+  stopReason(r) {
+    this._stopReason = r;
+    return this;
+  }
+  metadata(keyOrMap, value) {
+    if (typeof keyOrMap === "string") {
+      this._metadata[keyOrMap] = value;
+    } else {
+      this._metadata = { ...this._metadata, ...keyOrMap };
+    }
+    return this;
+  }
+  error(e) {
+    if (e !== void 0) {
+      this._error = e;
+      this._success = false;
+      this._stopReason = "error";
+    }
+    return this;
+  }
+  resources(res) {
+    this._resources = res;
+    return this;
+  }
+  build() {
+    return {
+      content: this._content,
+      toolsUsed: this._toolsUsed,
+      usage: this._usage,
+      stopReason: this._stopReason,
+      metadata: this._metadata,
+      error: this._error,
+      success: this._success,
+      resources: this._resources
+    };
+  }
+};
+
+// ../agent/core/session.ts
+var SESSION_VERSION = 1;
+
+// ../agent/request/index.ts
+function validateRequest(request) {
+  const errors = [];
+  if (!request.message || request.message.trim().length === 0) {
+    errors.push("message \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (request.message.length > 1e5) {
+    errors.push("message \u957F\u5EA6\u8D85\u8FC7\u9650\u5236\uFF08100000 \u5B57\u7B26\uFF09");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function normalizeRequest(request) {
+  return createRequest(request.message, {
+    type: request.type,
+    channel: request.channel || "cli",
+    chatId: request.chatId || "direct",
+    senderId: request.senderId || "user",
+    sessionKey: request.sessionKey,
+    media: request.media?.filter(Boolean) || [],
+    ephemeral: request.ephemeral ?? false,
+    model: request.model || void 0,
+    modelPreset: request.modelPreset || void 0,
+    metadata: request.metadata || {}
+  });
+}
+
+// ../agent/context-resource/index.ts
+function messageToResource(msg, index) {
+  const id = `msg_${index}`;
+  const timestamp = msg.timestamp ?? Date.now();
+  switch (msg.role) {
+    case "user": {
+      return new ContextResourceBuilder().id(id).type("user_message").role("user").content(msg.content).timestamp(timestamp).build();
+    }
+    case "assistant": {
+      const assistant = msg;
+      const builder = new ContextResourceBuilder().id(id).type("assistant_message").role("assistant").content(assistant.content).timestamp(timestamp).meta("model", assistant.model).meta("provider", assistant.provider).meta("stopReason", assistant.stopReason);
+      if (assistant.usage) {
+        builder.meta("usage", assistant.usage);
+      }
+      const toolCalls = extractToolCalls(assistant.content);
+      for (const tc of toolCalls) {
+        builder.dependsOn(tc.id);
+      }
+      return builder.build();
+    }
+    case "toolResult": {
+      const toolMsg = msg;
+      return createToolResultResource(
+        toolMsg.toolCallId,
+        toolMsg.toolName,
+        toolMsg.content,
+        toolMsg.isError,
+        toolMsg.toolCallId,
+        { timestamp }
+      );
+    }
+    case "system": {
+      return new ContextResourceBuilder().id(id).type("system_message").role("system").content(msg.content).timestamp(timestamp).pinned().build();
+    }
+    default: {
+      const customMsg = msg;
+      const roleStr = customMsg.role;
+      const customType = roleStr === "compactionSummary" ? "compaction_summary" : roleStr === "stateSnapshot" ? "state_snapshot" : "custom";
+      const builder = new ContextResourceBuilder().id(id).type(customType).role(roleStr).content(customMsg).timestamp(timestamp);
+      if (customType === "compaction_summary" || customType === "state_snapshot") {
+        builder.pinned();
+      }
+      return builder.build();
+    }
+  }
+}
+function messagesToResources(messages) {
+  return messages.map((msg, index) => messageToResource(msg, index));
+}
+function resourceToMessage(resource) {
+  switch (resource.type) {
+    case "user_message":
+      return {
+        role: "user",
+        content: resource.content,
+        timestamp: resource.timestamp
+      };
+    case "assistant_message": {
+      const meta = resource.meta;
+      const content = resource.content;
+      if (Array.isArray(content)) {
+        return {
+          role: "assistant",
+          content,
+          stopReason: meta.stopReason,
+          usage: meta.usage,
+          model: meta.model,
+          provider: meta.provider,
+          timestamp: resource.timestamp
+        };
+      }
+      return content;
+    }
+    case "tool_result": {
+      const meta = resource.meta;
+      return {
+        role: "toolResult",
+        toolCallId: meta.toolCallId,
+        toolName: meta.toolName,
+        content: resource.content,
+        isError: meta.isError,
+        timestamp: resource.timestamp
+      };
+    }
+    case "system_message":
+      return {
+        role: "system",
+        content: resource.content,
+        timestamp: resource.timestamp
+      };
+    default:
+      return resource.content;
+  }
+}
+function resourcesToMessages(resources) {
+  return resources.map(resourceToMessage);
+}
+
+// ../agent/ai/index.ts
+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
+]);
+function isRetryableCategory(category) {
+  return RETRYABLE_CATEGORIES.has(category);
+}
+var AgentError = class extends Error {
+  category;
+  status;
+  retryable;
+  /** 原始错误（ES2022 cause，Node 18 起 Error 构造支持 options.cause） */
+  cause;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "AgentError";
+    this.category = options.category ?? AgentErrorCategory.UNKNOWN;
+    this.status = options.status;
+    this.retryable = options.retryable ?? isRetryableCategory(this.category);
+    this.cause = options.cause;
+  }
+};
+function isAgentError(error) {
+  if (error instanceof AgentError) return true;
+  return !!error && typeof error === "object" && error.name === "AgentError" && typeof error.category === "string";
+}
+function classifyHttpStatus(status) {
+  if (status === 401 || status === 403) return AgentErrorCategory.AUTH;
+  if (status === 429) return AgentErrorCategory.RATE_LIMIT;
+  if (status === 413) return AgentErrorCategory.CONTEXT_OVERFLOW;
+  if (status >= 500 && status < 600) return AgentErrorCategory.RETRYABLE;
+  if (status >= 400 && status < 500) return AgentErrorCategory.INVALID_REQUEST;
+  return AgentErrorCategory.UNKNOWN;
+}
+var CONTEXT_OVERFLOW_PATTERNS = [
+  "context length",
+  "context window",
+  "context overflow",
+  "context too long",
+  "maximum context",
+  "too many tokens",
+  "token limit",
+  "prompt is too long",
+  "input is too long",
+  "exceeds the model"
+];
+var RATE_LIMIT_PATTERNS = [
+  "rate limit",
+  "too many requests",
+  "ratelimit"
+];
+var AUTH_PATTERNS = [
+  "unauthorized",
+  "authentication",
+  "invalid api key",
+  "incorrect api key",
+  "api key invalid",
+  "permission denied",
+  "forbidden",
+  "401",
+  "403"
+];
+var TIMEOUT_PATTERNS = [
+  "timeout",
+  "timed out",
+  "etimedout"
+];
+function classifyErrorMessage(message) {
+  const lower = message.toLowerCase();
+  if (CONTEXT_OVERFLOW_PATTERNS.some((p) => lower.includes(p))) {
+    return AgentErrorCategory.CONTEXT_OVERFLOW;
+  }
+  if (RATE_LIMIT_PATTERNS.some((p) => lower.includes(p))) {
+    return AgentErrorCategory.RATE_LIMIT;
+  }
+  if (AUTH_PATTERNS.some((p) => lower.includes(p))) {
+    return AgentErrorCategory.AUTH;
+  }
+  if (TIMEOUT_PATTERNS.some((p) => lower.includes(p))) {
+    return AgentErrorCategory.TIMEOUT;
+  }
+  return AgentErrorCategory.UNKNOWN;
+}
+function classifyError(error) {
+  if (isAgentError(error)) return error.category;
+  const status = error?.status;
+  if (typeof status === "number") return classifyHttpStatus(status);
+  const msg = error?.message ?? String(error ?? "");
+  return classifyErrorMessage(msg);
+}
+
+// ../agent/ai/overflow.ts
+var OVERFLOW_PATTERNS = [
+  // 本框架 formatCategoryError 产出的分类前缀（errors.ts），
+  // 覆盖消息体不含已知关键词但已带分类前缀的场景
+  /^\[context-overflow\]/i,
+  // Anthropic
+  /prompt is too long/i,
+  /request_too_large/i,
+  // Amazon Bedrock
+  /input is too long for requested model/i,
+  // OpenAI & 兼容
+  /exceeds the context window/i,
+  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+  /input token count.*exceeds the maximum/i,
+  // xAI Grok
+  /maximum prompt length is \d+/i,
+  // Groq
+  /reduce the length of the messages/i,
+  // OpenRouter
+  /maximum context length is \d+ tokens/i,
+  /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+  // Together AI
+  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+  // GitHub Copilot
+  /exceeds the limit of \d+/i,
+  // llama.cpp
+  /exceeds the available context size/i,
+  // LM Studio
+  /greater than the context length/i,
+  // MiniMax
+  /context window exceeds limit/i,
+  // Kimi
+  /exceeded model token limit/i,
+  // Mistral
+  /too large for model with \d+ maximum context length/i,
+  // DS4
+  /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+  // z.ai
+  /model_context_window_exceeded/i,
+  // Ollama
+  /prompt too long; exceeded (?:max )?context length/i,
+  // DashScope / Qwen
+  /range of input length should be/i,
+  // 通用回退
+  /context[_ ]length[_ ]exceeded/i,
+  /too many tokens/i,
+  /token limit exceeded/i,
+  // Cerebras: 400/413 无 body
+  /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i
+];
+var NON_OVERFLOW_PATTERNS = [
+  /^(Throttling error|Service unavailable):/i,
+  /rate limit/i,
+  /too many requests/i
+];
+function isContextOverflow(message, contextWindow) {
+  if (message.stopReason === "error" && message.errorMessage) {
+    const errMsg = message.errorMessage;
+    const isNonOverflow = NON_OVERFLOW_PATTERNS.some((p) => p.test(errMsg));
+    if (!isNonOverflow && OVERFLOW_PATTERNS.some((p) => p.test(errMsg))) {
+      return true;
+    }
+  }
+  if (contextWindow && message.stopReason === "stop" && message.usage) {
+    const inputTokens = message.usage.input + (message.usage.cacheRead ?? 0);
+    if (inputTokens > contextWindow) {
+      return true;
+    }
+  }
+  if (contextWindow && message.stopReason === "length" && message.usage && message.usage.output === 0) {
+    const inputTokens = message.usage.input + (message.usage.cacheRead ?? 0);
+    if (inputTokens >= contextWindow * 0.99) {
+      return true;
+    }
+  }
+  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
+import { randomUUID } from "crypto";
+function newTraceId() {
+  return `${Date.now().toString(36)}-${randomUUID()}`;
+}
+function newSpanId() {
+  return randomUUID();
+}
+function errorClassFromMessage(message) {
+  const m = message.match(/^\[([^\]]+)\]/);
+  return m ? m[1] : void 0;
+}
+function toolResultStatus(result) {
+  if (result.details && typeof result.details === "object" && "error" in result.details) {
+    return "error";
+  }
+  const d = result.details;
+  if (d?.blocked) return "blocked";
+  if (d?.skipped) return "skipped";
+  return "ok";
+}
+function statusOfRetryError(error) {
+  if (isAgentError(error)) return error.status;
+  const s = error?.status;
+  return typeof s === "number" ? s : void 0;
+}
+var DEFAULT_MAX_SESSIONS = 256;
+function createSessionState() {
+  return {
+    messages: [],
+    isStreaming: false,
+    abortController: null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    hydrated: false,
+    queue: Promise.resolve(),
+    idleResolvers: [],
+    lockHeld: false
+  };
+}
+function withTimeoutSignal(parent, ms) {
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new Error(`Tool execution timeout after ${ms}ms`)),
+    ms
+  );
+  if (parent) {
+    if (parent.aborted) {
+      controller.abort(parent.reason);
+    } else {
+      parent.addEventListener(
+        "abort",
+        () => controller.abort(parent.reason),
+        { once: true }
+      );
+    }
+  }
+  return { signal: controller.signal, clear: () => clearTimeout(timer) };
+}
+function buildImageContent(media) {
+  const dataMatch = media.match(/^data:([^;]+);base64,(.*)$/s);
+  if (dataMatch) {
+    return { type: "image", mimeType: dataMatch[1], data: dataMatch[2] };
+  }
+  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 estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+var COMPACTION_SUMMARY_BUDGET_RATIO = 0.6;
+var COMPACTION_LINE_CLAMP = 4e3;
+var DEFAULT_COMPACTION_PROMPT = [
+  "\u4F60\u662F\u5BF9\u8BDD\u5386\u53F2\u538B\u7F29\u5668\u3002\u8BF7\u5C06\u4EE5\u4E0B\u5BF9\u8BDD\u5386\u53F2\u538B\u7F29\u4E3A\u4E00\u4EFD\u4FE1\u606F\u5BC6\u5EA6\u9AD8\u7684\u6458\u8981\uFF0C\u4F9B\u540E\u7EED\u5BF9\u8BDD\u4F5C\u4E3A\u4E0A\u4E0B\u6587\u53C2\u8003\u3002",
+  "\u8981\u6C42\uFF1A",
+  "1. \u4FDD\u7559\u5173\u952E\u4E8B\u5B9E\u3001\u51B3\u7B56\u3001\u7ED3\u8BBA\u4E0E\u672A\u5B8C\u6210\u4E8B\u9879\uFF1B",
+  "2. \u4FDD\u7559\u7528\u6237\u660E\u786E\u7684\u504F\u597D\u4E0E\u7EA6\u675F\uFF1B",
+  "3. \u4FDD\u7559\u91CD\u8981\u5DE5\u5177\u8C03\u7528\u7684\u76EE\u7684\u4E0E\u7ED3\u679C\u8981\u70B9\uFF08\u7EC6\u8282\u53EF\u7701\u7565\uFF09\uFF1B",
+  "4. \u4E22\u5F03\u5BD2\u6684\u3001\u91CD\u590D\u4E0E\u65E0\u5173\u7EC6\u8282\uFF1B",
+  "5. \u76F4\u63A5\u8F93\u51FA\u6458\u8981\u6B63\u6587\uFF0C\u4E0D\u8981\u4EFB\u4F55\u524D\u540E\u7F00\u8BF4\u660E\u3002"
+].join("\n");
+var COMPACTION_USER_PREFIX = "[\u4EE5\u4E0B\u4E3A\u6B64\u524D\u5BF9\u8BDD\u5386\u53F2\u7684\u538B\u7F29\u6458\u8981\uFF0C\u4F5C\u4E3A\u4E0A\u4E0B\u6587\u53C2\u8003]";
+function messageToSummaryLine(msg) {
+  const clamp = (text) => text.length > COMPACTION_LINE_CLAMP ? `${text.slice(0, COMPACTION_LINE_CLAMP)}\u2026(\u5DF2\u622A\u65AD)` : text;
+  switch (msg.role) {
+    case "user": {
+      const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
+      return `[\u7528\u6237] ${clamp(text)}`;
+    }
+    case "assistant": {
+      const parts = [];
+      const content = msg.content;
+      if (typeof content === "string") {
+        parts.push(content);
+      } else {
+        for (const block of content) {
+          if (block.type === "text") parts.push(block.text);
+          else if (block.type === "toolCall") {
+            parts.push(`\u8C03\u7528\u5DE5\u5177 ${block.name}(${JSON.stringify(block.arguments)})`);
+          }
+        }
+      }
+      return `[\u52A9\u624B] ${clamp(parts.join("\uFF1B"))}`;
+    }
+    case "toolResult": {
+      const m = msg;
+      const text = typeof m.content === "string" ? m.content : extractText(m.content);
+      return `[\u5DE5\u5177\u7ED3\u679C ${m.toolName}] ${clamp(text)}`;
+    }
+    default: {
+      const role = msg.role;
+      if (role === "compactionSummary" || role === "stateSnapshot") {
+        const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
+        return `[${role === "compactionSummary" ? "\u5386\u53F2\u6458\u8981" : "\u72B6\u6001\u5FEB\u7167"}] ${clamp(text)}`;
+      }
+      return "";
+    }
+  }
+}
+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);
+      }
+    }
+    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);
+    }
+    const ctx = {
+      config: runtime._config,
+      workspace: options.workspace ?? process.cwd(),
+      sessionKey: runtime._sessionKey,
+      shared: /* @__PURE__ */ new Map()
+    };
+    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;
+  }
+  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;
+  }
+  /** 获取指定会话的消息列表（默认会话；会话不存在返回空数组） */
+  getMessages(sessionKey) {
+    const session = this._sessions.get(sessionKey ?? this._sessionKey);
+    if (!session) return [];
+    const messages = session.messages;
+    try {
+      return structuredClone(messages);
+    } catch {
+      return JSON.parse(JSON.stringify(messages));
+    }
+  }
+  // ─── 核心运行逻辑 ───────────────────────────────────────────────
+  /** 解析请求路由的会话 key：request.sessionKey ?? 默认会话 key */
+  resolveSessionKey(request) {
+    return request.sessionKey ?? this._sessionKey;
+  }
+  /**
+   * 获取（懒创建）会话状态。同一 Runtime 下不同 sessionKey 的消息历史、
+   * 串行队列、abort 控制相互独立；共享模型/工具/扩展/转换器。
+   * 超过 _maxSessions 时淘汰最久未用的非活动会话（仅清内存态，不删存储）。
+   */
+  getSession(key) {
+    let session = this._sessions.get(key);
+    if (session) {
+      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);
+    }
+  }
+  /** 当前活跃的会话 key 列表（含默认会话） */
+  getSessionKeys() {
+    return Array.from(this._sessions.keys());
+  }
+  /** 某会话是否存在（内存中） */
+  hasSession(sessionKey) {
+    return this._sessions.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.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;
+    try {
+      return await this.runWithStorageLock(
+        finalRequest,
+        sessionKey,
+        () => this._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.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;
+    }
+    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();
+    }
+  }
+  /**
+   * 非 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);
+  }
+  /** 流式版本：无法用回调包住生成器，改用手动锁（acquire/release） */
+  async *streamWithStorageLock(request, sessionKey, gen) {
+    const storage = this._sessionStorage;
+    if (request.ephemeral || !storage?.acquireLock) {
+      yield* gen();
+      return;
+    }
+    const lock = await 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));
+    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;
+    } 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;
+    }
+    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);
+    }
+  }
+  // ─── 对话循环（流式） ───────────────────────────────────────────
+  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.executeToolCallsStreaming(
+          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;
+        }
+      }
+      if (maxTurns < 0) compilation.maxTurnsExhausted = true;
+      compilation.turnCount = turnCount;
+    } finally {
+      this.markIdle(session);
+    }
+  }
+  // ─── 工具执行 ───────────────────────────────────────────────────
+  /** 同步循环：执行工具调用并将结果消息按原顺序追加 */
+  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;
+  }
+  /** 流式循环：执行工具调用，返回结果（消息由调用方追加） */
+  async executeToolCallsStreaming(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;
+  }
+  /**
+   * 执行一组工具调用：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) {
+      const outcomes = await Promise.all(toolCalls.map(execute));
+      const terminated = outcomes.find((o) => o.terminate);
+      return {
+        results: outcomes.map((o) => o.result),
+        terminate: !!terminated,
+        terminateReason: terminated?.terminateReason
+      };
+    }
+    const results = [];
+    let terminate = false;
+    let terminateReason;
+    for (const tc of toolCalls) {
+      if (terminate) {
+        results.push(this.makeSkippedResult(tc));
+        continue;
+      }
+      const outcome = await execute(tc);
+      results.push(outcome.result);
+      if (outcome.terminate) {
+        terminate = true;
+        terminateReason = outcome.terminateReason;
+      }
+    }
+    return { results, terminate, terminateReason };
+  }
+  async executeTool(toolCall, signal, request, traceId) {
+    const tool = this._globalTools.get(toolCall.name);
+    if (!tool) {
+      return {
+        result: {
+          content: [createTextContent(`Tool "${toolCall.name}" not found`)],
+          details: { error: `Tool "${toolCall.name}" not found` }
+        },
+        terminate: false
+      };
+    }
+    let args = toolCall.arguments;
+    if (tool.prepareArguments) {
+      args = tool.prepareArguments(toolCall.arguments);
+    }
+    if (this._permissionPolicy) {
+      const permissionReq = {
+        toolName: toolCall.name,
+        permissions: tool.permissions ?? [],
+        args,
+        sessionKey: request.sessionKey ?? this._sessionKey,
+        request,
+        shared: this._extensionContext?.shared ?? /* @__PURE__ */ new Map()
+      };
+      const decision = await this._permissionPolicy.check(permissionReq);
+      let allowed = decision === "allow";
+      if (decision === "confirm") {
+        allowed = this._permissionPolicy.confirm ? await this._permissionPolicy.confirm(permissionReq) : false;
+      }
+      if (decision === "pending") {
+        if (this._approvals) {
+          const approval = this._approvals.create(permissionReq, {
+            timeoutMs: this._approvalTimeoutMs,
+            signal
+          });
+          await this.emitTelemetry("onApprovalPending", {
+            traceId,
+            sessionKey: permissionReq.sessionKey,
+            approvalId: approval.id,
+            toolName: toolCall.name,
+            permissions: permissionReq.permissions,
+            args,
+            expiresAt: approval.expiresAt
+          });
+          const outcome = await this._approvals.wait(approval);
+          allowed = outcome.status === "approved";
+          await this.emitTelemetry("onApprovalResolved", {
+            traceId,
+            sessionKey: permissionReq.sessionKey,
+            approvalId: approval.id,
+            toolName: toolCall.name,
+            outcome: outcome.status,
+            waitedMs: outcome.waitedMs
+          });
+        } else {
+          allowed = false;
+        }
+      }
+      if (!allowed) {
+        const reason = `permission denied by policy for tool "${toolCall.name}"`;
+        await this.emitTelemetry("onPermissionDenied", {
+          traceId,
+          sessionKey: permissionReq.sessionKey,
+          toolName: toolCall.name,
+          permissions: permissionReq.permissions,
+          args,
+          reason
+        });
+        return {
+          result: this.makeBlockedResult(reason),
+          terminate: false
+        };
+      }
+    }
+    const { signal: timedSignal, clear } = withTimeoutSignal(signal, this._toolTimeoutMs);
+    try {
+      const beforeCtx = this.buildToolCallContext(toolCall, tool, args, request, timedSignal);
+      const before = await this._hooks.beforeToolCall.promise(
+        { block: false, terminate: false, args },
+        beforeCtx
+      );
+      if (before.terminate) {
+        const reason = before.reason ?? "terminated by beforeToolCall";
+        return {
+          result: this.makeBlockedResult(reason),
+          terminate: true,
+          terminateReason: reason
+        };
+      }
+      if (before.block) {
+        const reason = before.reason ?? "blocked by beforeToolCall";
+        return {
+          result: this.makeBlockedResult(reason),
+          terminate: false
+        };
+      }
+      args = before.args;
+      const toolStartedAt = Date.now();
+      let result;
+      try {
+        result = await tool.execute(toolCall.id, args, timedSignal);
+      } catch (err) {
+        const message = err?.message ?? String(err);
+        result = {
+          content: [createTextContent(message)],
+          details: { error: message }
+        };
+      }
+      const status = toolResultStatus(result);
+      await this.emitTelemetry("onToolCall", {
+        traceId,
+        spanId: newSpanId(),
+        sessionKey: request.sessionKey ?? this._sessionKey,
+        toolName: toolCall.name,
+        args,
+        durationMs: Date.now() - toolStartedAt,
+        result,
+        success: status === "ok",
+        status,
+        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(
+        { result, terminate: false },
+        afterCtx
+      );
+      return {
+        result: after.result,
+        terminate: after.terminate,
+        terminateReason: after.terminate ? "terminated by afterToolCall" : void 0
+      };
+    } finally {
+      clear();
+    }
+  }
+  isErrorResult(result) {
+    return !!(result.details && typeof result.details === "object" && "error" in result.details);
+  }
+  /** beforeToolCall 阻断/终止时生成拒绝结果（非执行错误，isError=false） */
+  makeBlockedResult(reason) {
+    return {
+      content: [createTextContent(`[blocked] ${reason}`)],
+      details: { blocked: true, reason }
+    };
+  }
+  /** 串行模式下前序工具 terminate 后，剩余工具生成 skipped 结果保持配对 */
+  makeSkippedResult(toolCall) {
+    return {
+      content: [createTextContent(`[skipped] run terminated by prior tool: ${toolCall.name}`)],
+      details: { skipped: true, toolName: toolCall.name }
+    };
+  }
+  /** 构建 ToolCallContext：beforeToolCall/afterToolCall 的调用上下文 */
+  buildToolCallContext(toolCall, tool, args, request, signal) {
+    return {
+      toolCall,
+      tool,
+      args,
+      sessionKey: request.sessionKey ?? this._sessionKey,
+      request,
+      shared: this._extensionContext?.shared ?? /* @__PURE__ */ new Map(),
+      signal
+    };
+  }
+  buildToolResultMessage(toolCall, result) {
+    return {
+      role: "toolResult",
+      content: result.content,
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      isError: this.isErrorResult(result),
+      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()
+      };
+    }
+    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();
+    }
+  }
+  // ─── 会话持久化 ─────────────────────────────────────────────────
+  /** 从存储懒加载会话（串行化后无竞态，每个会话仅恢复一次） */
+  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;
+  }
+  /** 整体保存指定会话（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);
+  }
+  /**
+   * 实时持久化指定会话：每轮 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 为内部扩展 role，provider 适配层仅支持
+      // user/assistant/toolResult，发出前统一转为带标注的 user 消息
+      messages: messages.filter((m) => m.role !== "system").map((m) => m.role === "compactionSummary" ? this.compactionSummaryToUser(m) : 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
+    };
+  }
+  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()
+    };
+  }
+  /**
+   * 单回合模型调用 + 上下文溢出自动恢复闭环。
+   *
+   * 检测（isContextOverflow，统一传入 model.contextWindow，覆盖显式错误 /
+   * 静默溢出 / 截断溢出三模式）→ 丢弃失败的 assistant 消息 → 截断会话历史
+   * → 同回合重试（不消耗回合数，上限 OVERFLOW_RECOVERY_LIMIT）：
+   *
+   * - 显式错误 / 零产出截断溢出：丢弃错误消息后重试；流式路径吞掉可恢复的
+   *   error chunk（消费者看不到瞬态错误），不可恢复时补发。
+   * - 静默溢出（stop + 有完整产出）：保留回复，仅压缩旧上下文供后续轮次。
+   * - 恢复耗尽或单请求超窗（无可丢弃）：返回最后一次错误消息，维持旧行为。
+   *
+   * 流式路径 yield 模型事件 chunk；非流式路径由 streamModel 消费（chunk 丢弃）。
+   * 返回最终 assistant 消息；无 done/error 事件时返回 null。
+   */
+  async *modelTurnWithRecovery(compilation, signal, sessionKey, stream) {
+    const contextWindow = this._model.contextWindow;
+    let recoveries = 0;
+    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(msg, contextWindow)) {
+            suppressed = msg;
+            continue;
+          }
+          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;
+        }
+      }
+      const final = assistant ?? suppressed;
+      if (!final) return null;
+      if (isContextOverflow(final, contextWindow)) {
+        const failed = final.stopReason === "error" || (final.usage?.output ?? 0) === 0;
+        if (failed && recoveries < OVERFLOW_RECOVERY_LIMIT) {
+          recoveries += 1;
+          if (await this.recoverFromOverflow(compilation, recoveries, sessionKey, signal)) {
+            console.warn(
+              `[Runtime] \u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF0C\u5DF2\u538B\u7F29\u5386\u53F2\uFF08\u6458\u8981\u6216\u622A\u65AD\uFF09\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");
+      }
+      return final;
+    }
+  }
+  /**
+   * 计算溢出恢复的截断点：按 token 预算从最旧消息开始丢弃。
+   *
+   * 预算随恢复次数指数收紧（contextWindow × ratio × 0.5^recovery），且每次
+   * 至少丢弃可丢弃部分的一半，保证重试规模必然小于上次溢出（token 估算
+   * 偏小时也成立）。最后一条消息（当前请求/最新产出）始终保留。
+   * 返回被压缩段的结束下标（messages[0..split) 为被压缩段）；0 = 已到
+   * 最小集，单条请求即超窗，无法恢复。
+   */
+  computeOverflowSplit(messages, recovery) {
+    const contextWindow = this._model.contextWindow;
+    if (!contextWindow || contextWindow <= 0) return 0;
+    const target = Math.max(
+      Math.floor(contextWindow * this._contextBudgetRatio * 0.5 ** recovery),
+      1
+    );
+    let total = 0;
+    for (const m of messages) total += estimateMessageTokens(m);
+    const droppable = messages.length - 1;
+    if (droppable <= 0) return 0;
+    const mustDrop = Math.max(Math.floor(droppable / 2), 1);
+    let dropUntil = 0;
+    while (dropUntil < droppable && (dropUntil < mustDrop || total > target)) {
+      total -= estimateMessageTokens(messages[dropUntil]);
+      dropUntil += 1;
+    }
+    return dropUntil;
+  }
+  /**
+   * 溢出恢复：摘要优先、硬截断兜底（原地修改会话消息）。
+   *
+   * 开启 compaction（默认）时，被压缩段先尝试 LLM 摘要替换（compactionSummary
+   * 消息），摘要失败或序列化超摘要预算（请求本身会超窗）则降级纯丢弃；
+   * 关闭 compaction 时维持旧行为纯截断。截断/摘要后均经 ensureToolPairing
+   * 修复保留段的工具配对。返回是否执行了恢复动作（false = 无可压缩，单条
+   * 请求即超窗）。
+   */
+  async recoverFromOverflow(compilation, recovery, sessionKey, signal) {
+    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;
+    if (useCompaction) {
+      await this.compactOrTruncate(
+        messages,
+        split,
+        sessionKey,
+        compilation.traceId,
+        signal,
+        "overflow"
+      );
+      return true;
+    }
+    const kept = ensureToolPairing(messages.slice(split));
+    messages.splice(0, messages.length, ...kept);
+    return true;
+  }
+  /**
+   * 阈值触发内置摘要压缩（runLoop 每轮模型调用前检查，低频）：
+   * 估算 token 超过 contextWindow × triggerRatio（默认 contextBudgetRatio）
+   * 时，将历史压缩到 targetRatio（默认 0.5）——最新消息保留目标的一半，
+   * 其余部分摘要替换；摘要失败降级硬截断。
+   */
+  async maybeCompactByThreshold(compilation, sessionKey, signal) {
+    if (!this._compaction || this._compaction.enabled === false) return;
+    const contextWindow = this._model.contextWindow;
+    if (!contextWindow || contextWindow <= 0) return;
+    const messages = compilation.messages;
+    const triggerTokens = Math.floor(
+      contextWindow * (this._compaction?.triggerRatio ?? this._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;
+    }
+    if (split <= 0 || split >= messages.length) return;
+    const mode = await this.compactOrTruncate(
+      messages,
+      split,
+      sessionKey,
+      compilation.traceId,
+      signal,
+      "threshold"
+    );
+    console.warn(
+      `[Runtime] \u4E0A\u4E0B\u6587\u8FBE\u9608\u503C\uFF08\u7EA6 ${total} token > ${triggerTokens}\uFF09\uFF0C\u5DF2${mode === "summary" ? "\u6458\u8981\u538B\u7F29" : "\u622A\u65AD"}\u5386\u53F2`
+    );
+  }
+  /**
+   * 手动压缩指定会话（交互命令 /compact 等）：跳过阈值判断，
+   * 直接将历史压缩至 targetRatio 保留量（复用 maybeCompactByThreshold
+   * 的保留段计算与 compactOrTruncate 执行路径），压缩后持久化。
+   */
+  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;
+    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;
+    }
+    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;
+  }
+  /**
+   * 执行压缩：messages[0..split) 为被压缩段，原地替换。
+   *
+   * 摘要成功 → 被压缩段替换为单条 compactionSummary 消息（资源层 pinned）；
+   * 序列化超摘要预算或摘要调用失败 → 降级纯丢弃（旧行为）。两种路径均对
+   * 保留段执行 ensureToolPairing（被压缩段边界可能截断工具配对）。上报
+   * onCompaction 遥测。
+   */
+  async compactOrTruncate(messages, split, sessionKey, traceId, signal, trigger) {
+    const compacted = messages.slice(0, split);
+    const tokensBefore = messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
+    let mode = "truncate";
+    let summaryText = "";
+    const summaryEnabled = !!this._compaction && this._compaction.enabled !== false;
+    if (summaryEnabled && compacted.length > 0) {
+      const summaryBudget = Math.floor(
+        this._model.contextWindow * COMPACTION_SUMMARY_BUDGET_RATIO
+      );
+      const inputText = compacted.map((m) => messageToSummaryLine(m)).filter((line) => line.length > 0).join("\n");
+      if (inputText && estimateTextTokens(inputText) <= summaryBudget) {
+        const summary = await this.summarizeMessages(
+          inputText,
+          sessionKey,
+          traceId,
+          signal
+        );
+        if (summary && summary.trim()) {
+          summaryText = summary.trim();
+          mode = "summary";
+        }
+      }
+    }
+    let tokensAfter;
+    if (mode === "summary") {
+      const summaryMsg = this.createCompactionSummaryMessage(summaryText);
+      const kept = ensureToolPairing(messages.slice(split));
+      messages.splice(0, messages.length, summaryMsg, ...kept);
+      tokensAfter = estimateMessageTokens(summaryMsg) + kept.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
+    } else {
+      const kept = ensureToolPairing(messages.slice(split));
+      messages.splice(0, messages.length, ...kept);
+      tokensAfter = kept.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
+    }
+    await this.emitTelemetry("onCompaction", {
+      traceId,
+      sessionKey,
+      mode,
+      trigger,
+      tokensBefore,
+      tokensAfter,
+      droppedMessages: split,
+      summary: mode === "summary" ? summaryText : void 0
+    });
+    return mode;
+  }
+  /**
+   * 调用模型生成摘要文本。失败（模型错误/中止/空产出）返回 null，
+   * 由调用方降级硬截断——摘要失败不影响主流程。
+   */
+  async summarizeMessages(inputText, sessionKey, traceId, signal) {
+    const prompt = this._compaction?.prompt ?? DEFAULT_COMPACTION_PROMPT;
+    const context = {
+      systemPrompt: prompt,
+      messages: [{ role: "user", content: inputText, timestamp: Date.now() }]
+    };
+    const startedAt = Date.now();
+    let text = "";
+    let usage;
+    let failed = false;
+    try {
+      for await (const event of this._streamFn(this._model, context, { signal })) {
+        if (event.type === "text_delta") {
+          text += event.delta;
+        } else if (event.type === "error") {
+          failed = true;
+          usage = event.message.usage;
+          break;
+        } else if (event.type === "done") {
+          usage = event.message.usage;
+          if (event.message.stopReason === "error") failed = true;
+          if (!text) text = extractText(event.message.content);
+          break;
+        }
+      }
+    } catch {
+      return null;
+    }
+    if (failed || !text.trim()) return null;
+    await this.emitTelemetry("onModelCall", {
+      traceId,
+      spanId: newSpanId(),
+      sessionKey,
+      modelId: this._model.id,
+      attempts: 1,
+      inputTokens: usage?.input ?? estimateTextTokens(inputText),
+      outputTokens: usage?.output ?? estimateTextTokens(text),
+      durationMs: Date.now() - startedAt,
+      stream: false
+    });
+    return text;
+  }
+  /** 构造 compactionSummary 消息（内部扩展 role，发出前经 buildContext 转 user） */
+  createCompactionSummaryMessage(text) {
+    return {
+      role: "compactionSummary",
+      content: 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();
+    const spanId = newSpanId();
+    let attempts = 1;
+    let ttftAt;
+    let lastAssistant;
+    const options = { signal };
+    if (this._thinkingLevel !== "off" && this._model.reasoning) {
+      options.reasoning = this._thinkingLevel;
+    }
+    options.onRetryAttempt = (info) => {
+      attempts += 1;
+      void this.emitTelemetry("onRetry", {
+        traceId: compilation.traceId,
+        spanId,
+        // P2：重试明细关联到本模型调用 span
+        provider: this._model.provider,
+        modelId: this._model.id,
+        attempt: info.attempt,
+        errorClass: classifyError(info.error),
+        status: statusOfRetryError(info.error),
+        delayMs: info.delayMs,
+        willRetry: true
+      });
+    };
+    try {
+      for await (const event of this._streamFn(this._model, this.buildContext(compilation.messages), options)) {
+        if (stream && event.type === "text_delta" && ttftAt === void 0) {
+          ttftAt = Date.now();
+        }
+        if (event.type === "done" || event.type === "error") {
+          lastAssistant = event.message;
+        }
+        yield event;
+      }
+    } finally {
+      const assistant = lastAssistant;
+      const errorClass = assistant?.errorMessage ? errorClassFromMessage(assistant.errorMessage) ?? "unknown" : void 0;
+      await this.emitTelemetry("onModelCall", {
+        traceId: compilation.traceId,
+        spanId,
+        sessionKey,
+        modelId: this._model.id,
+        attempts,
+        inputTokens: assistant?.usage?.input ?? 0,
+        outputTokens: assistant?.usage?.output ?? 0,
+        cacheRead: assistant?.usage?.cacheRead,
+        cacheWrite: assistant?.usage?.cacheWrite,
+        durationMs: Date.now() - modelStartedAt,
+        stream,
+        errorClass
+      });
+      if (stream && ttftAt !== void 0 && compilation.ttftMs === void 0) {
+        compilation.ttftMs = ttftAt - modelStartedAt;
+      }
+    }
+  }
+  /**
+   * 触发遥测回调。全可选、失败不阻断主流程。
+   */
+  async emitTelemetry(event, info) {
+    const fn = this._telemetry?.[event];
+    if (!fn) return;
+    try {
+      await Promise.resolve(fn(info));
+    } catch (err) {
+      console.warn(`[aipack] telemetry "${String(event)}" \u4E0A\u62A5\u5931\u8D25:`, err);
+    }
+  }
+  /** traceId 生成：优先用注入的生成器（测试可确定性） */
+  newTraceId() {
+    return this._traceIdGenerator ? this._traceIdGenerator() : 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
+    });
+  }
+  /** 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";
+      }
+    }
+    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;
+        }
+      }
+      if (msg.role === "toolResult") {
+        const toolMsg = msg;
+        if (!toolsUsed.includes(toolMsg.toolName)) {
+          toolsUsed.push(toolMsg.toolName);
+        }
+      }
+    }
+    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);
+    }
+    return builder.build();
+  }
+  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;
+    }
+  }
+  // ─── 便捷方法 ───────────────────────────────────────────────────
+  /** 终止指定会话的运行（默认会话；会话不存在为 no-op） */
+  abort(sessionKey) {
+    this._sessions.get(sessionKey ?? this._sessionKey)?.abortController?.abort();
+  }
+  /** 检查指定会话是否正在运行（默认会话；会话不存在返回 false） */
+  isBusy(sessionKey) {
+    return this._sessions.get(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);
+    });
+  }
+  /** 清除指定会话消息（仅内存；下次 run 会从存储恢复） */
+  clearSession(sessionKey) {
+    const session = this._sessions.get(sessionKey ?? this._sessionKey);
+    if (!session) return;
+    session.messages = [];
+    session.hydrated = false;
+  }
+  /** 删除指定会话（内存 + 存储），返回是否删除成功 */
+  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;
+    const storage = this._sessionStorage;
+    if (!storage.withLock) return storage.delete(key);
+    return storage.withLock(key, () => storage.delete(key));
+  }
+};
+function createRuntime(options) {
+  return AgentRuntime.create(options);
+}
+
+// core/executor.ts
+var runtimeCache = /* @__PURE__ */ new WeakMap();
+function ensureRuntime(node) {
+  let rt = runtimeCache.get(node);
+  if (rt) return rt;
+  if (typeof node.runtime.run === "function") {
+    rt = node.runtime;
+  } else {
+    rt = createRuntime(node.runtime);
+  }
+  runtimeCache.set(node, rt);
+  return rt;
+}
+async function executeNode(node, input, ctx) {
+  const runtime = ensureRuntime(node);
+  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);
+  if (node.outputMapping) {
+    node.outputMapping(result, ctx);
+  }
+  return result;
+}
+function resolveInput(edge, prevResult, ctx, node, originalInput) {
+  if (edge?.transform) {
+    return edge.transform(prevResult, ctx);
+  }
+  if (node.inputMapping) {
+    return node.inputMapping(ctx);
+  }
+  return prevResult.content;
+}
+function findNextEdges(fromId, edges, result, ctx) {
+  const outEdges = edges.filter((e) => e.from === fromId);
+  const matched = [];
+  for (const edge of outEdges) {
+    if (!edge.condition || edge.condition(result, ctx)) {
+      matched.push(edge);
+    }
+  }
+  return matched;
+}
+var GraphExecutor = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  entryId;
+  finishCondition;
+  abortController = new AbortController();
+  state = {
+    nodeStates: /* @__PURE__ */ new Map(),
+    nodeResults: /* @__PURE__ */ new Map(),
+    stepsCompleted: 0,
+    finished: false
+  };
+  addNode(node) {
+    this.nodes.set(node.id, node);
+    this.state.nodeStates.set(node.id, "pending");
+    return this;
+  }
+  addEdge(edge) {
+    this.edges.push(edge);
+    return this;
+  }
+  setEntry(agentId) {
+    this.entryId = agentId;
+    return this;
+  }
+  setFinish(condition) {
+    this.finishCondition = condition;
+    return this;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  /** 同步执行图 */
+  async run(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`);
+    }
+    const ctx = createSharedContext({
+      meta: { traceId: `ma-${Date.now()}`, startTime: Date.now() }
+    });
+    const events = [];
+    try {
+      const result = await this.executeGraph(input, ctx, (event) => events.push(event));
+      return result;
+    } catch (err) {
+      return {
+        content: "",
+        lastAgentId: this.state.currentAgentId ?? "",
+        agentResults: this.state.nodeResults,
+        totalUsage: {},
+        stepsCompleted: this.state.stepsCompleted,
+        stopReason: "error",
+        context: ctx,
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** 流式执行图 */
+  async *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`);
+    }
+    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;
+  }
+  /** 核心执行逻辑 */
+  async executeGraph(input, ctx, emit) {
+    const entryNode = this.nodes.get(this.entryId);
+    let currentId = this.entryId;
+    let currentInput = input;
+    let lastResult;
+    let lastAgentId = currentId;
+    let stepsCompleted = 0;
+    const totalUsage = {};
+    this.state.currentAgentId = currentId;
+    this.state.nodeStates.set(currentId, "running");
+    emit({ type: "agent_start", agentId: currentId, agentName: entryNode.name });
+    try {
+      lastResult = await executeNode(entryNode, currentInput, ctx);
+      this.state.nodeStates.set(currentId, "completed");
+      this.state.nodeResults.set(currentId, lastResult);
+      this.mergeUsage(totalUsage, lastResult.usage);
+      stepsCompleted++;
+      this.state.stepsCompleted = stepsCompleted;
+      emit({ type: "agent_result", agentId: currentId, agentName: entryNode.name, result: lastResult });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.nodeStates.set(currentId, "failed");
+      emit({ type: "agent_error", agentId: currentId, agentName: entryNode.name, error: errorMsg });
+      throw err;
+    }
+    lastAgentId = currentId;
+    if (this.finishCondition?.(ctx)) {
+      return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "finish_condition");
+    }
+    const visited = /* @__PURE__ */ new Set();
+    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) {
+        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 count = (visitCount.get(edge.to) ?? 0) + 1;
+      if (count > MAX_VISITS_PER_NODE) {
+        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);
+        stepsCompleted++;
+        this.state.stepsCompleted = stepsCompleted;
+        emit({ type: "agent_result", agentId: currentId, agentName: nextNode.name, result: lastResult });
+      } 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 });
+        throw err;
+      }
+      lastAgentId = currentId;
+      if (this.finishCondition?.(ctx)) {
+        return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "finish_condition");
+      }
+    }
+    return this.buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, "completed");
+  }
+  buildResult(lastResult, lastAgentId, ctx, totalUsage, stepsCompleted, stopReason) {
+    this.state.finished = true;
+    return {
+      content: lastResult.content,
+      lastAgentId,
+      agentResults: new Map(this.state.nodeResults),
+      totalUsage,
+      stepsCompleted,
+      stopReason,
+      context: ctx,
+      success: lastResult.success,
+      error: lastResult.error
+    };
+  }
+  mergeUsage(total, usage) {
+    for (const [key, value] of Object.entries(usage)) {
+      total[key] = (total[key] ?? 0) + value;
+    }
+  }
+};
+
+// core/graph.ts
+var AgentGraphImpl = class {
+  executor = new GraphExecutor();
+  eventListeners = /* @__PURE__ */ new Map();
+  addNode(node) {
+    this.executor.addNode(node);
+    return this;
+  }
+  addEdge(edge) {
+    this.executor.addEdge(edge);
+    return this;
+  }
+  setEntry(agentId) {
+    this.executor.setEntry(agentId);
+    return this;
+  }
+  setFinish(condition) {
+    this.executor.setFinish(condition);
+    return this;
+  }
+  async run(input) {
+    return this.executor.run(input);
+  }
+  async *stream(input) {
+    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);
+    return this;
+  }
+};
+function createAgentGraph() {
+  return new AgentGraphImpl();
+}
+
+// patterns/pipeline.ts
+function createPipeline(agents, opts) {
+  if (agents.length === 0) {
+    throw new Error("Pipeline: \u81F3\u5C11\u9700\u8981\u4E00\u4E2A Agent \u8282\u70B9");
+  }
+  const graph = createAgentGraph();
+  for (const agent of agents) {
+    graph.addNode(agent);
+  }
+  graph.setEntry(agents[0].id);
+  for (let i = 0; i < agents.length - 1; i++) {
+    const from = agents[i];
+    const to = agents[i + 1];
+    graph.addEdge({
+      from: from.id,
+      to: to.id,
+      // 边上的转换：将前一个Agent的输出传递给下一个Agent
+      transform: opts?.outputTransform ? (result, ctx) => opts.outputTransform(result, ctx) : void 0
+    });
+  }
+  return graph;
+}
+
+// patterns/router.ts
+function createRouter(router, targets, opts) {
+  if (targets.length === 0) {
+    throw new Error("Router: \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u76EE\u6807 Agent");
+  }
+  const graph = createAgentGraph();
+  graph.addNode(router);
+  for (const target of targets) {
+    graph.addNode(target);
+  }
+  graph.setEntry(router.id);
+  const targetIds = new Set(targets.map((t) => t.id));
+  for (const target of targets) {
+    graph.addEdge({
+      from: router.id,
+      to: target.id,
+      // 条件：从路由器结果中解析目标ID，匹配当前目标
+      condition: (routerResult, _ctx) => {
+        const resolvedId = opts.resolve(routerResult);
+        return resolvedId === target.id;
+      },
+      // 转换：决定传给目标Agent的输入
+      transform: (_routerResult, _ctx) => {
+        const originalInput = _ctx.blackboard.get("__original_input__");
+        if (opts.passOriginalInput === false) {
+          return _routerResult.content;
+        }
+        return originalInput ?? _routerResult.content;
+      }
+    });
+  }
+  if (opts.defaultTarget && targetIds.has(opts.defaultTarget)) {
+  }
+  return graph;
+}
+
+// core/supervisor-executor.ts
+var SupervisorExecutor = class {
+  supervisorNode;
+  workerNodes;
+  opts;
+  state = {
+    nodeStates: /* @__PURE__ */ new Map(),
+    nodeResults: /* @__PURE__ */ new Map(),
+    stepsCompleted: 0,
+    finished: false
+  };
+  constructor(supervisor, workers, opts) {
+    this.supervisorNode = supervisor;
+    this.workerNodes = workers;
+    this.opts = {
+      schedule: opts?.schedule ?? "parallel",
+      concurrency: opts?.concurrency ?? Infinity,
+      passOriginalInput: opts?.passOriginalInput ?? true
+    };
+    this.state.nodeStates.set(supervisor.id, "pending");
+    for (const w of workers) {
+      this.state.nodeStates.set(w.id, "pending");
+    }
+  }
+  getState() {
+    return { ...this.state };
+  }
+  /** 执行 Supervisor 模式 */
+  async run(input) {
+    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);
+    }
+    try {
+      return await this.executeSupervisor(input, ctx, () => {
+      });
+    } catch (err) {
+      return this.buildErrorResult(ctx, err);
+    }
+  }
+  /** 流式执行 Supervisor 模式 */
+  async *stream(input) {
+    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;
+        });
+      }
+    }
+    await graphPromise;
+  }
+  /** 核心执行逻辑 */
+  async executeSupervisor(input, ctx, emit) {
+    let stepsCompleted = 0;
+    const totalUsage = {};
+    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 });
+    let supervisorResult;
+    try {
+      supervisorResult = await executeNode(this.supervisorNode, input, ctx);
+      this.state.nodeStates.set(this.supervisorNode.id, "completed");
+      this.state.nodeResults.set(this.supervisorNode.id, supervisorResult);
+      this.mergeUsage(totalUsage, supervisorResult.usage);
+      stepsCompleted++;
+      this.state.stepsCompleted = stepsCompleted;
+      emit({ type: "agent_result", agentId: this.supervisorNode.id, agentName: this.supervisorNode.name, result: supervisorResult });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.nodeStates.set(this.supervisorNode.id, "failed");
+      emit({ type: "agent_error", agentId: this.supervisorNode.id, agentName: this.supervisorNode.name, error: errorMsg });
+      throw err;
+    }
+    const schedule = this.opts.schedule;
+    let workerResults;
+    if (schedule === "parallel") {
+      workerResults = await this.executeWorkersParallel(ctx, emit, totalUsage);
+    } else if (schedule === "sequential") {
+      workerResults = await this.executeWorkersSequential(ctx, emit, totalUsage);
+    } else {
+      workerResults = await this.executeWorkersAuto(ctx, emit, totalUsage);
+    }
+    stepsCompleted += workerResults.size;
+    this.state.stepsCompleted = stepsCompleted;
+    const lastWorkerId = this.workerNodes[this.workerNodes.length - 1].id;
+    const finalResult = workerResults.get(lastWorkerId) ?? supervisorResult;
+    this.state.finished = true;
+    return {
+      content: finalResult.content,
+      lastAgentId: lastWorkerId,
+      agentResults: new Map(this.state.nodeResults),
+      totalUsage,
+      stepsCompleted,
+      stopReason: "completed",
+      context: ctx,
+      success: true
+    };
+  }
+  /** 并行执行所有 Worker */
+  async executeWorkersParallel(ctx, emit, totalUsage) {
+    const results = /* @__PURE__ */ new Map();
+    const workers = this.workerNodes;
+    const concurrency = this.opts.concurrency;
+    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);
+        }
+      }
+    } else {
+      let index = 0;
+      const executing = /* @__PURE__ */ new Set();
+      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);
+          executing.delete(p);
+          return r;
+        });
+        executing.add(p);
+        return p;
+      };
+      for (let i = 0; i < concurrency && index < workers.length; i++) {
+        enqueue();
+      }
+      while (executing.size > 0) {
+        await Promise.race(executing);
+        enqueue();
+      }
+    }
+    emit({ type: "parallel_done", results });
+    return results;
+  }
+  /** 顺序执行所有 Worker */
+  async executeWorkersSequential(ctx, emit, totalUsage) {
+    const results = /* @__PURE__ */ new Map();
+    for (const worker of this.workerNodes) {
+      const result = await this.executeWorker(worker, ctx, emit, totalUsage);
+      results.set(worker.id, result);
+    }
+    return results;
+  }
+  /** 自动调度：根据 inputMapping 依赖分层执行 */
+  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]);
+      }
+      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);
+    }
+    return results;
+  }
+  /** 执行单个 Worker */
+  async executeWorker(worker, ctx, emit, totalUsage) {
+    this.state.currentAgentId = worker.id;
+    this.state.nodeStates.set(worker.id, "running");
+    emit({ type: "agent_start", agentId: worker.id, agentName: worker.name });
+    try {
+      let workerInput;
+      if (worker.inputMapping) {
+        workerInput = worker.inputMapping(ctx);
+      } else {
+        const tasks = ctx.blackboard.get("tasks");
+        const myTask = tasks?.find((t) => t.assignee === worker.id);
+        workerInput = myTask ? myTask.task : ctx.blackboard.get("__original_input__") ?? "";
+      }
+      const result = await executeNode(worker, workerInput, ctx);
+      this.state.nodeStates.set(worker.id, "completed");
+      this.state.nodeResults.set(worker.id, result);
+      this.mergeUsage(totalUsage, result.usage);
+      ctx.blackboard.set(`${worker.id}_result`, result.content);
+      emit({ type: "agent_result", agentId: worker.id, agentName: worker.name, result });
+      return result;
+    } 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;
+    }
+  }
+  buildErrorResult(ctx, err) {
+    this.state.finished = true;
+    return {
+      content: "",
+      lastAgentId: this.supervisorNode.id,
+      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)
+    };
+  }
+  mergeUsage(total, usage) {
+    for (const [key, value] of Object.entries(usage)) {
+      total[key] = (total[key] ?? 0) + value;
+    }
+  }
+};
+
+// patterns/supervisor.ts
+var SupervisorGraphImpl = class {
+  executor;
+  eventListeners = /* @__PURE__ */ new Map();
+  constructor(supervisor, workers, opts) {
+    this.executor = new SupervisorExecutor(supervisor, workers, opts);
+  }
+  // AgentGraph 接口方法（Supervisor 不使用 addNode/addEdge/setEntry/setFinish）
+  addNode() {
+    throw new Error("Supervisor \u6A21\u5F0F\u4E0D\u652F\u6301\u624B\u52A8 addNode\uFF0C\u8BF7\u5728 createSupervisor() \u4E2D\u914D\u7F6E");
+  }
+  addEdge() {
+    throw new Error("Supervisor \u6A21\u5F0F\u4E0D\u652F\u6301\u624B\u52A8 addEdge\uFF0C\u8C03\u5EA6\u7531 Supervisor \u81EA\u52A8\u7BA1\u7406");
+  }
+  setEntry() {
+    throw new Error("Supervisor \u6A21\u5F0F\u4E0D\u652F\u6301 setEntry\uFF0C\u5165\u53E3\u56FA\u5B9A\u4E3A Supervisor");
+  }
+  setFinish() {
+    throw new Error("Supervisor \u6A21\u5F0F\u4E0D\u652F\u6301 setFinish\uFF0C\u7EC8\u6B62\u7531 Supervisor \u5224\u5B9A");
+  }
+  async run(input) {
+    return this.executor.run(input);
+  }
+  async *stream(input) {
+    yield* this.executor.stream(input);
+  }
+  getState() {
+    return this.executor.getState();
+  }
+  abort() {
+  }
+  on(event, listener) {
+    let set = this.eventListeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventListeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+};
+function createSupervisor(supervisor, workers, opts) {
+  if (workers.length === 0) {
+    throw new Error("Supervisor: \u81F3\u5C11\u9700\u8981\u4E00\u4E2A Worker Agent");
+  }
+  return new SupervisorGraphImpl(supervisor, workers, opts);
+}
+
+// core/debate-executor.ts
+var DebateExecutor = class {
+  proposerNode;
+  reviewerNode;
+  maxRounds;
+  convergeWhen;
+  feedbackTransform;
+  state = {
+    nodeStates: /* @__PURE__ */ new Map(),
+    nodeResults: /* @__PURE__ */ new Map(),
+    stepsCompleted: 0,
+    finished: false
+  };
+  constructor(proposer, reviewer, opts) {
+    this.proposerNode = proposer;
+    this.reviewerNode = reviewer;
+    this.maxRounds = opts.maxRounds ?? 3;
+    this.convergeWhen = opts.convergeWhen;
+    this.feedbackTransform = opts.feedbackTransform ?? ((reviewerResult, proposerResult) => {
+      return `\u4EE5\u4E0B\u662F\u5BA1\u67E5\u610F\u89C1:
+${reviewerResult.content}
+
+\u8BF7\u4FEE\u590D\u4EE5\u4E0A\u95EE\u9898\u5E76\u91CD\u65B0\u63D0\u4EA4\u3002\u539F\u59CB\u8F93\u51FA:
+${proposerResult.content}`;
+    });
+    this.state.nodeStates.set(proposer.id, "pending");
+    this.state.nodeStates.set(reviewer.id, "pending");
+  }
+  getState() {
+    return { ...this.state };
+  }
+  /** 执行 Debate */
+  async run(input) {
+    const ctx = createSharedContext({
+      meta: { traceId: `debate-${Date.now()}`, startTime: Date.now() }
+    });
+    try {
+      return await this.executeDebate(input, ctx, () => {
+      });
+    } catch (err) {
+      return this.buildErrorResult(ctx, err);
+    }
+  }
+  /** 流式执行 Debate */
+  async *stream(input) {
+    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;
+  }
+  /** 核心执行逻辑 */
+  async executeDebate(input, ctx, emit) {
+    let stepsCompleted = 0;
+    const totalUsage = {};
+    let lastProposerResult;
+    let lastReviewerResult;
+    let convergedRound = 0;
+    let convergeReason = "";
+    let currentInput = input;
+    for (let round = 1; round <= this.maxRounds; round++) {
+      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 });
+      try {
+        lastProposerResult = await executeNode(this.proposerNode, currentInput, ctx);
+        this.state.nodeStates.set(this.proposerNode.id, "completed");
+        this.state.nodeResults.set(`${this.proposerNode.id}_r${round}`, lastProposerResult);
+        this.mergeUsage(totalUsage, lastProposerResult.usage);
+        stepsCompleted++;
+        this.state.stepsCompleted = stepsCompleted;
+        emit({ type: "agent_result", agentId: this.proposerNode.id, agentName: this.proposerNode.name, result: lastProposerResult });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        this.state.nodeStates.set(this.proposerNode.id, "failed");
+        emit({ type: "agent_error", agentId: this.proposerNode.id, agentName: this.proposerNode.name, error: errorMsg });
+        throw err;
+      }
+      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 });
+      try {
+        lastReviewerResult = await executeNode(this.reviewerNode, lastProposerResult.content, ctx);
+        this.state.nodeStates.set(this.reviewerNode.id, "completed");
+        this.state.nodeResults.set(`${this.reviewerNode.id}_r${round}`, lastReviewerResult);
+        this.mergeUsage(totalUsage, lastReviewerResult.usage);
+        stepsCompleted++;
+        this.state.stepsCompleted = stepsCompleted;
+        emit({ type: "agent_result", agentId: this.reviewerNode.id, agentName: this.reviewerNode.name, result: lastReviewerResult });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        this.state.nodeStates.set(this.reviewerNode.id, "failed");
+        emit({ type: "agent_error", agentId: this.reviewerNode.id, agentName: this.reviewerNode.name, error: errorMsg });
+        throw err;
+      }
+      if (this.convergeWhen(lastReviewerResult)) {
+        convergedRound = round;
+        convergeReason = `\u6536\u655B\u4E8E\u7B2C ${round} \u8F6E\uFF1Areviewer \u8F93\u51FA\u6EE1\u8DB3\u6536\u655B\u6761\u4EF6`;
+        emit({ type: "converged", round, reason: convergeReason });
+        break;
+      }
+      currentInput = this.feedbackTransform(lastReviewerResult, lastProposerResult);
+    }
+    const finalResult = lastProposerResult;
+    const stopReason = convergedRound > 0 ? `converged_at_round_${convergedRound}` : `max_rounds_reached`;
+    this.state.finished = true;
+    return {
+      content: finalResult.content,
+      lastAgentId: this.reviewerNode.id,
+      agentResults: new Map(this.state.nodeResults),
+      totalUsage,
+      stepsCompleted,
+      stopReason,
+      context: ctx,
+      success: true
+    };
+  }
+  buildErrorResult(ctx, err) {
+    this.state.finished = true;
+    return {
+      content: "",
+      lastAgentId: this.proposerNode.id,
+      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)
+    };
+  }
+  mergeUsage(total, usage) {
+    for (const [key, value] of Object.entries(usage)) {
+      total[key] = (total[key] ?? 0) + value;
+    }
+  }
+};
+
+// patterns/debate.ts
+var DebateGraphImpl = class {
+  executor;
+  eventListeners = /* @__PURE__ */ new Map();
+  constructor(proposer, reviewer, opts) {
+    this.executor = new DebateExecutor(proposer, reviewer, opts);
+  }
+  addNode() {
+    throw new Error("Debate \u6A21\u5F0F\u4E0D\u652F\u6301\u624B\u52A8 addNode");
+  }
+  addEdge() {
+    throw new Error("Debate \u6A21\u5F0F\u4E0D\u652F\u6301\u624B\u52A8 addEdge");
+  }
+  setEntry() {
+    throw new Error("Debate \u6A21\u5F0F\u4E0D\u652F\u6301 setEntry");
+  }
+  setFinish() {
+    throw new Error("Debate \u6A21\u5F0F\u4E0D\u652F\u6301 setFinish");
+  }
+  async run(input) {
+    return this.executor.run(input);
+  }
+  async *stream(input) {
+    yield* this.executor.stream(input);
+  }
+  getState() {
+    return this.executor.getState();
+  }
+  abort() {
+  }
+  on(event, listener) {
+    let set = this.eventListeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventListeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+};
+function createDebate(proposer, reviewer, opts) {
+  return new DebateGraphImpl(proposer, reviewer, opts);
+}
+
+// core/map-reduce-executor.ts
+var MapReduceExecutor = class {
+  mapperNode;
+  reducerNode;
+  split;
+  concurrency;
+  reduceInputFormat;
+  state = {
+    nodeStates: /* @__PURE__ */ new Map(),
+    nodeResults: /* @__PURE__ */ new Map(),
+    stepsCompleted: 0,
+    finished: false
+  };
+  constructor(mapper, reducer, opts) {
+    this.mapperNode = mapper;
+    this.reducerNode = reducer;
+    this.split = opts.split;
+    this.concurrency = opts.concurrency ?? Infinity;
+    this.reduceInputFormat = opts.reduceInputFormat ?? ((mapperResults) => {
+      const parts = [];
+      for (const [idx, result] of mapperResults) {
+        parts.push(`--- \u5B50\u4EFB\u52A1 ${idx + 1} ---
+${result.content}`);
+      }
+      return parts.join("\n\n");
+    });
+    this.state.nodeStates.set(mapper.id, "pending");
+    this.state.nodeStates.set(reducer.id, "pending");
+  }
+  getState() {
+    return { ...this.state };
+  }
+  /** 执行 MapReduce */
+  async run(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");
+    }
+    const ctx = createSharedContext({
+      meta: { traceId: `mr-${Date.now()}`, startTime: Date.now() }
+    });
+    try {
+      return await this.executeMapReduce(input, ctx, () => {
+      });
+    } catch (err) {
+      return this.buildErrorResult(ctx, err);
+    }
+  }
+  /** 流式执行 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");
+    }
+    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;
+  }
+  /** 核心执行逻辑 */
+  async executeMapReduce(input, ctx, emit) {
+    let stepsCompleted = 0;
+    const totalUsage = {};
+    const inputText = typeof input === "string" ? input : input.message;
+    const chunks = this.split(inputText);
+    const mapperResults = /* @__PURE__ */ new Map();
+    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();
+      }
+    }
+    this.state.nodeStates.set(this.mapperNode.id, "completed");
+    const mapperResultsForEmit = /* @__PURE__ */ new Map();
+    for (const [idx, result] of mapperResults) {
+      mapperResultsForEmit.set(`${this.mapperNode.id}_${idx}`, result);
+    }
+    emit({ type: "parallel_done", results: mapperResultsForEmit });
+    ctx.blackboard.set("mapper_results", mapperResults);
+    const reduceInput = this.reduceInputFormat(mapperResults);
+    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 });
+    let reducerResult;
+    try {
+      reducerResult = await executeNode(this.reducerNode, reduceInput, ctx);
+      this.state.nodeStates.set(this.reducerNode.id, "completed");
+      this.state.nodeResults.set(this.reducerNode.id, reducerResult);
+      this.mergeUsage(totalUsage, reducerResult.usage);
+      stepsCompleted++;
+      this.state.stepsCompleted = stepsCompleted;
+      emit({ type: "agent_result", agentId: this.reducerNode.id, agentName: this.reducerNode.name, result: reducerResult });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.nodeStates.set(this.reducerNode.id, "failed");
+      emit({ type: "agent_error", agentId: this.reducerNode.id, agentName: this.reducerNode.name, error: errorMsg });
+      throw err;
+    }
+    this.state.finished = true;
+    return {
+      content: reducerResult.content,
+      lastAgentId: this.reducerNode.id,
+      agentResults: new Map(this.state.nodeResults),
+      totalUsage,
+      stepsCompleted,
+      stopReason: "completed",
+      context: ctx,
+      success: true
+    };
+  }
+  buildErrorResult(ctx, err) {
+    this.state.finished = true;
+    return {
+      content: "",
+      lastAgentId: this.mapperNode.id,
+      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)
+    };
+  }
+  mergeUsage(total, usage) {
+    for (const [key, value] of Object.entries(usage)) {
+      total[key] = (total[key] ?? 0) + value;
+    }
+  }
+};
+
+// patterns/map-reduce.ts
+var MapReduceGraphImpl = class {
+  executor;
+  eventListeners = /* @__PURE__ */ new Map();
+  constructor(mapper, reducer, opts) {
+    this.executor = new MapReduceExecutor(mapper, reducer, opts);
+  }
+  addNode() {
+    throw new Error("MapReduce \u6A21\u5F0F\u4E0D\u652F\u6301\u624B\u52A8 addNode");
+  }
+  addEdge() {
+    throw new Error("MapReduce \u6A21\u5F0F\u4E0D\u652F\u6301\u624B\u52A8 addEdge");
+  }
+  setEntry() {
+    throw new Error("MapReduce \u6A21\u5F0F\u4E0D\u652F\u6301 setEntry");
+  }
+  setFinish() {
+    throw new Error("MapReduce \u6A21\u5F0F\u4E0D\u652F\u6301 setFinish");
+  }
+  async run(input) {
+    return this.executor.run(input);
+  }
+  async *stream(input) {
+    yield* this.executor.stream(input);
+  }
+  getState() {
+    return this.executor.getState();
+  }
+  abort() {
+  }
+  on(event, listener) {
+    let set = this.eventListeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventListeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+};
+function createMapReduce(mapper, reducer, opts) {
+  return new MapReduceGraphImpl(mapper, reducer, opts);
+}
+
+// extensions/mcp-bridge.ts
+var MCPBridge = class {
+  graph;
+  opts;
+  constructor(graph, opts) {
+    this.graph = graph;
+    this.opts = {
+      serverName: opts?.serverName ?? "aipack-multi-agent",
+      serverVersion: opts?.serverVersion ?? "1.0.0",
+      toolPrefix: opts?.toolPrefix ?? ""
+    };
+  }
+  /** 获取 MCP Server 信息 */
+  getServerInfo() {
+    return {
+      name: this.opts.serverName,
+      version: this.opts.serverVersion
+    };
+  }
+  /** 列出所有可用 MCP 工具 */
+  listTools() {
+    const prefix = this.opts.toolPrefix;
+    return [
+      {
+        name: `${prefix}run`,
+        description: "\u8FD0\u884C\u591AAgent\u7F16\u6392\u56FE\uFF0C\u4F20\u5165\u7528\u6237\u8F93\u5165\uFF0C\u8FD4\u56DE\u6267\u884C\u7ED3\u679C",
+        parameters: [
+          {
+            name: "input",
+            description: "\u7528\u6237\u8F93\u5165\u6587\u672C",
+            type: "string",
+            required: true
+          }
+        ]
+      },
+      {
+        name: `${prefix}status`,
+        description: "\u83B7\u53D6\u5F53\u524D\u56FE\u6267\u884C\u72B6\u6001",
+        parameters: []
+      }
+    ];
+  }
+  /** 处理 MCP 工具调用 */
+  async handleCall(request) {
+    const prefix = this.opts.toolPrefix;
+    const runTool = `${prefix}run`;
+    const statusTool = `${prefix}status`;
+    try {
+      if (request.name === runTool) {
+        const input = request.arguments.input;
+        if (!input) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: input" }]
+          };
+        }
+        const result = await this.graph.run(input);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: result.success,
+                content: result.content,
+                lastAgentId: result.lastAgentId,
+                stepsCompleted: result.stepsCompleted,
+                stopReason: result.stopReason,
+                totalUsage: result.totalUsage
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      if (request.name === statusTool) {
+        const state = this.graph.getState();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                currentAgentId: state.currentAgentId,
+                stepsCompleted: state.stepsCompleted,
+                finished: state.finished,
+                error: state.error,
+                nodeStates: Object.fromEntries(state.nodeStates)
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      return {
+        isError: true,
+        content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${request.name}` }]
+      };
+    } catch (err) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `\u6267\u884C\u9519\u8BEF: ${err instanceof Error ? err.message : String(err)}`
+          }
+        ]
+      };
+    }
+  }
+};
+function createMCPBridge(graph, opts) {
+  return new MCPBridge(graph, opts);
+}
+
+// extensions/debug.ts
+var GraphDebugger = class {
+  graph;
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  entryId;
+  constructor(graph, nodes, edges, entryId) {
+    this.graph = graph;
+    if (nodes) {
+      for (const node of nodes) {
+        this.nodes.set(node.id, node);
+      }
+    }
+    if (edges) {
+      this.edges = edges;
+    }
+    this.entryId = entryId;
+  }
+  /** 设置图元数据（供无法直接访问内部结构的场景使用） */
+  setGraphMeta(nodes, edges, entryId) {
+    this.nodes.clear();
+    for (const node of nodes) {
+      this.nodes.set(node.id, node);
+    }
+    this.edges = edges;
+    this.entryId = entryId;
+  }
+  /** 导出为 DOT 格式 */
+  toDOT() {
+    const lines = [];
+    lines.push("digraph AgentGraph {");
+    lines.push("  rankdir=LR;");
+    lines.push('  node [shape=box, style=filled, fillcolor="#e8f4fd", fontname="Arial"];');
+    lines.push('  edge [fontname="Arial", fontsize=10];');
+    lines.push("");
+    for (const [id, node] of this.nodes) {
+      const isEntry = id === this.entryId;
+      const fillColor = isEntry ? "#4CAF50" : "#e8f4fd";
+      const fontColor = isEntry ? "white" : "black";
+      const label = `${node.name}\\n(${id})`;
+      lines.push(`  "${id}" [label="${label}", fillcolor="${fillColor}", fontcolor="${fontColor}"];`);
+    }
+    lines.push("");
+    for (const edge of this.edges) {
+      const hasCondition = !!edge.condition;
+      const style = hasCondition ? "dashed" : "solid";
+      const label = hasCondition ? "\u6761\u4EF6" : "";
+      lines.push(`  "${edge.from}" -> "${edge.to}" [style=${style}, label="${label}"];`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  /** 执行图并记录 Trace */
+  async trace(input) {
+    const traceId = `trace-${Date.now()}`;
+    const graphStartTime = Date.now();
+    const steps = [];
+    let stepIndex = 0;
+    for await (const event of this.graph.stream(input)) {
+      if (event.type === "agent_start") {
+        stepIndex++;
+        steps.push({
+          step: stepIndex,
+          agentId: event.agentId,
+          agentName: event.agentName,
+          startTime: Date.now(),
+          duration: 0,
+          input: "",
+          output: "",
+          state: "running"
+        });
+      } else if (event.type === "agent_result") {
+        const step = this.findLastRunning(steps, event.agentId);
+        if (step) {
+          step.duration = Date.now() - step.startTime;
+          step.output = this.truncate(event.result.content, 200);
+          step.state = "completed";
+        } else {
+          const fallback = this.findLastById(steps, event.agentId);
+          if (fallback) {
+            fallback.duration = Date.now() - fallback.startTime;
+            fallback.output = this.truncate(event.result.content, 200);
+            fallback.state = "completed";
+          }
+        }
+      } else if (event.type === "agent_error") {
+        const step = this.findLastRunning(steps, event.agentId);
+        if (step) {
+          step.duration = Date.now() - step.startTime;
+          step.error = event.error;
+          step.state = "failed";
+        }
+      }
+    }
+    const state = this.graph.getState();
+    const graphDuration = Date.now() - graphStartTime;
+    return {
+      traceId,
+      startTime: graphStartTime,
+      duration: graphDuration,
+      steps,
+      result: {
+        success: !state.error,
+        content: state.error ?? "",
+        stopReason: state.error ? "error" : "completed",
+        stepsCompleted: state.stepsCompleted
+      }
+    };
+  }
+  /** 将 Trace 转为 JSON 字符串 */
+  traceToJSON(trace) {
+    return JSON.stringify(trace, null, 2);
+  }
+  /** 将 Trace 转为可读的执行日志 */
+  traceToLog(trace) {
+    const lines = [];
+    lines.push(`=== Graph Trace: ${trace.traceId} ===`);
+    lines.push(`Duration: ${trace.duration}ms`);
+    lines.push("");
+    for (const step of trace.steps) {
+      const status = step.state === "completed" ? "OK" : step.state === "failed" ? "FAIL" : step.state;
+      lines.push(`[${step.step}] ${step.agentName} (${step.agentId}) - ${status} (${step.duration}ms)`);
+      if (step.input) lines.push(`  Input:  ${this.truncate(step.input, 100)}`);
+      if (step.output) lines.push(`  Output: ${this.truncate(step.output, 100)}`);
+      if (step.error) lines.push(`  Error:  ${step.error}`);
+      lines.push("");
+    }
+    lines.push(`Result: ${trace.result.success ? "SUCCESS" : "FAILED"} (${trace.result.stopReason})`);
+    return lines.join("\n");
+  }
+  truncate(text, maxLength) {
+    if (text.length <= maxLength) return text;
+    return text.slice(0, maxLength) + "...";
+  }
+  /** 找最后一个匹配 agentId 且状态为 running 的 step */
+  findLastRunning(steps, agentId) {
+    for (let i = steps.length - 1; i >= 0; i--) {
+      if (steps[i].agentId === agentId && steps[i].state === "running") {
+        return steps[i];
+      }
+    }
+    return void 0;
+  }
+  /** 找最后一个匹配 agentId 的 step（不管状态） */
+  findLastById(steps, agentId) {
+    for (let i = steps.length - 1; i >= 0; i--) {
+      if (steps[i].agentId === agentId) {
+        return steps[i];
+      }
+    }
+    return void 0;
+  }
+};
+function createDebugger(graph) {
+  return new GraphDebugger(graph);
+}
+export {
+  GraphDebugger,
+  MCPBridge,
+  SimpleEventBus,
+  SimpleToolRegistry,
+  createAgentGraph,
+  createDebate,
+  createDebugger,
+  createMCPBridge,
+  createMapReduce,
+  createPipeline,
+  createRouter,
+  createSharedContext,
+  createSupervisor
+};
+//# sourceMappingURL=index.js.map