@ai-setting/roy-agent-core 1.4.13 → 1.4.15

package/dist/shared/@ai-setting/roy-agent-core-jj79gszx.js

@@ -0,0 +1,1130 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+import {
+  ContextError
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-rbetrphj.js";
+import {
+  SessionMessageConverter
+} from "./roy-agent-core-e62e2a5a.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-35x0wrtt.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-j3wc4465.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/agent/agent-component.ts
+init_logger();
+import { z } from "zod";
+
+// src/env/agent/agent-config-registration.ts
+var AGENT_DEFAULTS = {
+  "agent.defaultAgent.maxIterations": 200,
+  "agent.defaultAgent.temperature": 0,
+  "agent.defaultAgent.timeout": 300000,
+  "agent.defaultAgent.streaming": false,
+  "agent.defaultAgent.filterHistory": false
+};
+var AGENT_CONFIG_REGISTRATION = {
+  name: "agent",
+  sources: [
+    { type: "env", envPrefix: "AGENT", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "agent.defaultAgent.model", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.maxIterations", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.temperature", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.timeout", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.systemPrompt", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.streaming", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.tools", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.maxErrorRetries", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.filterHistory", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/agent/agent-component.ts
+init_decorator();
+init_workflow_hil();
+var logger = createLogger("agent:component");
+function toLLMMessage(msg) {
+  let content;
+  let toolCallId;
+  let toolName;
+  let toolCalls;
+  if (typeof msg.content === "string") {
+    content = msg.content;
+    if (msg.role === "tool") {
+      toolCallId = msg.toolCallId;
+      toolName = msg.toolName;
+    }
+    if (msg.role === "assistant" && msg.toolCalls) {
+      toolCalls = msg.toolCalls;
+    }
+  } else if (Array.isArray(msg.content)) {
+    if (msg.role === "tool") {
+      const toolResult = msg.content.find((part) => part.type === "tool-result");
+      const output = toolResult?.output;
+      if (typeof output === "string") {
+        content = output;
+      } else if (output && typeof output === "object" && "value" in output) {
+        content = output.value?.toString() || "";
+      } else {
+        content = JSON.stringify(output) || "";
+      }
+      toolCallId = toolResult?.toolCallId;
+      toolName = toolResult?.toolName;
+    } else {
+      const textParts = msg.content.filter((part) => part.type === "text");
+      const toolCallParts = msg.content.filter((part) => part.type === "tool-call");
+      content = textParts.map((part) => part.text || "").join("");
+      if (msg.role === "assistant" && toolCallParts.length > 0) {
+        toolCalls = toolCallParts.map((part) => {
+          const argsString = typeof part.input === "string" ? part.input : JSON.stringify(part.input || {});
+          const toolName2 = part.toolName || "unknown";
+          return {
+            id: part.toolCallId,
+            name: toolName2,
+            arguments: argsString,
+            function: {
+              name: toolName2,
+              arguments: argsString
+            }
+          };
+        });
+      }
+    }
+  } else {
+    content = "";
+  }
+  return {
+    role: msg.role,
+    content,
+    ...toolCallId ? { toolCallId } : {},
+    ...toolName ? { name: toolName } : {},
+    ...toolCalls && toolCalls.length > 0 ? { toolCalls } : {}
+  };
+}
+var DEFAULT_AGENT_CONFIG = {
+  type: "primary",
+  maxIterations: 200,
+  maxErrorRetries: 3,
+  doomLoopThreshold: 5,
+  toolTimeout: 60000,
+  toolRetries: 3,
+  filterHistory: false
+};
+var AgentInstanceSchema = z.object({
+  type: z.enum(["primary", "sub"]).default("primary"),
+  systemPrompt: z.string().optional(),
+  behaviorSpecId: z.string().optional(),
+  model: z.string().optional(),
+  maxIterations: z.number().default(200),
+  maxErrorRetries: z.number().default(3),
+  doomLoopThreshold: z.number().default(5),
+  allowedTools: z.array(z.string()).optional(),
+  deniedTools: z.array(z.string()).optional(),
+  toolTimeout: z.number().default(60000),
+  toolRetries: z.number().default(3),
+  filterHistory: z.boolean().default(false)
+});
+var AgentComponentConfigSchema = z.object({
+  defaultAgent: AgentInstanceSchema
+});
+
+class AgentComponent extends BaseComponent {
+  name = "agent";
+  version = "1.0.0";
+  agents = new Map;
+  config;
+  llmComponent = null;
+  toolComponent = null;
+  aborted = new Map;
+  abortControllers = new Map;
+  defaultTools = [];
+  doomLoopCaches = new Map;
+  configComponent;
+  configWatcher;
+  messageConverter = new SessionMessageConverter;
+  _constructorConfig;
+  runCounter = 0;
+  constructor(options = {}) {
+    super();
+    this._constructorConfig = options.config;
+    this.config = {
+      defaultAgent: {
+        ...DEFAULT_AGENT_CONFIG,
+        ...options.config?.defaultAgent
+      }
+    };
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for AgentComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.setStatus("running");
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix ?? "AGENT";
+    configComponent.registerComponent(AGENT_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("agent");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "agent");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(AGENT_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    const constructorDefaultAgent = this._constructorConfig?.defaultAgent;
+    this.config.defaultAgent = {
+      maxIterations: constructorDefaultAgent?.maxIterations ?? configComponent.get("agent.defaultAgent.maxIterations") ?? 200,
+      maxErrorRetries: constructorDefaultAgent?.maxErrorRetries ?? configComponent.get("agent.defaultAgent.maxErrorRetries") ?? 3,
+      doomLoopThreshold: constructorDefaultAgent?.doomLoopThreshold ?? configComponent.get("agent.defaultAgent.doomLoopThreshold") ?? 5,
+      toolTimeout: constructorDefaultAgent?.toolTimeout ?? configComponent.get("agent.defaultAgent.toolTimeout") ?? 60000,
+      toolRetries: constructorDefaultAgent?.toolRetries ?? configComponent.get("agent.defaultAgent.toolRetries") ?? 3,
+      filterHistory: constructorDefaultAgent?.filterHistory ?? configComponent.get("agent.defaultAgent.filterHistory") ?? false,
+      type: constructorDefaultAgent?.type ?? configComponent.get("agent.defaultAgent.type") ?? "primary",
+      systemPrompt: constructorDefaultAgent?.systemPrompt ?? configComponent.get("agent.defaultAgent.systemPrompt"),
+      model: constructorDefaultAgent?.model ?? configComponent.get("agent.defaultAgent.model"),
+      behaviorSpecId: constructorDefaultAgent?.behaviorSpecId ?? configComponent.get("agent.defaultAgent.behaviorSpecId")
+    };
+    logger.info(`[registerConfig] Synced config from ConfigComponent: maxIterations=${this.config.defaultAgent.maxIterations}`);
+    this.registerConfigWatcher(configComponent);
+  }
+  flattenConfig(obj, prefix = "agent") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("agent.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger.info(`Agent config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+  }
+  async onStop() {
+    logger.info("[AgentComponent] Stopping and cleaning up resources...");
+    for (const [name, agent] of this.agents) {
+      if (agent.status === "running" || agent.status === "idle") {
+        this.abort(name);
+        logger.debug(`[AgentComponent] Aborted agent: ${name}`);
+      }
+    }
+    this.abortControllers.clear();
+    this.doomLoopCaches.clear();
+    if (this.configWatcher) {
+      this.configWatcher();
+      this.configWatcher = undefined;
+    }
+    this.agents.clear();
+    this.setStatus("stopped");
+    logger.info("[AgentComponent] Cleanup completed");
+  }
+  refreshDependencies() {
+    if (this.env) {
+      const llm = this.env.getComponent("llm");
+      const tool = this.env.getComponent("tool");
+      this.llmComponent = llm ? llm : null;
+      this.toolComponent = tool ? tool : null;
+      logger.debug("[refreshDependencies] AgentComponent refreshed", {
+        hasLLM: !!this.llmComponent,
+        hasTool: !!this.toolComponent
+      });
+    }
+  }
+  getAgent(agentName) {
+    return this.agents.get(agentName);
+  }
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  addRemainingToolResults(ctx, allToolCalls, processedCount, reason) {
+    const remainingToolCalls = allToolCalls.slice(processedCount);
+    for (const tc of remainingToolCalls) {
+      const tcName = tc.function?.name || tc.name || "unknown";
+      this.pushMessage(ctx, {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: tc.id,
+          toolName: tcName,
+          output: JSON.stringify({ error: reason })
+        }]
+      });
+    }
+  }
+  registerAgent(name, config) {
+    const mergedConfig = {
+      type: config.type ?? this.config.defaultAgent.type,
+      name,
+      maxIterations: config.maxIterations ?? this.config.defaultAgent.maxIterations,
+      maxErrorRetries: config.maxErrorRetries ?? this.config.defaultAgent.maxErrorRetries,
+      doomLoopThreshold: config.doomLoopThreshold ?? this.config.defaultAgent.doomLoopThreshold,
+      toolTimeout: config.toolTimeout ?? this.config.defaultAgent.toolTimeout,
+      toolRetries: config.toolRetries ?? this.config.defaultAgent.toolRetries,
+      systemPrompt: config.systemPrompt ?? this.config.defaultAgent.systemPrompt,
+      model: config.model ?? this.config.defaultAgent.model,
+      behaviorSpecId: config.behaviorSpecId ?? this.config.defaultAgent.behaviorSpecId,
+      allowedTools: config.allowedTools ?? this.config.defaultAgent.allowedTools,
+      deniedTools: config.deniedTools ?? this.config.defaultAgent.deniedTools,
+      filterHistory: config.filterHistory ?? this.config.defaultAgent.filterHistory
+    };
+    const instance = {
+      name,
+      config: mergedConfig,
+      status: "idle",
+      plugins: new Map
+    };
+    this.agents.set(name, instance);
+    logger.info(`Agent registered: ${name}`, { type: instance.config.type });
+    return instance;
+  }
+  unregisterAgent(name) {
+    const deleted = this.agents.delete(name);
+    if (deleted) {
+      logger.info(`Agent unregistered: ${name}`);
+    }
+    return deleted;
+  }
+  registerPlugin(agentName, plugin) {
+    const agent = this.agents.get(agentName);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentName}`);
+    }
+    agent.plugins.set(plugin.name, plugin);
+    logger.info(`Plugin registered: ${plugin.name} to ${agentName}`, {
+      hooks: plugin.hooks.map((h) => h.point)
+    });
+  }
+  unregisterPlugin(agentName, pluginName) {
+    const agent = this.agents.get(agentName);
+    if (!agent) {
+      return false;
+    }
+    const deleted = agent.plugins.delete(pluginName);
+    if (deleted) {
+      logger.info(`Plugin unregistered: ${pluginName} from ${agentName}`);
+    }
+    return deleted;
+  }
+  setDefaultTools(tools) {
+    this.defaultTools = tools;
+  }
+  getAvailableTools(agent, context) {
+    let tools = [...this.defaultTools];
+    logger.debug(`[getAvailableTools] After defaultTools: ${tools.length} tools`, {
+      toolNames: tools.map((t) => t.name)
+    });
+    if (this.toolComponent?.listTools) {
+      const componentTools = this.toolComponent.listTools();
+      tools = [...tools, ...componentTools];
+      logger.debug(`[getAvailableTools] After adding componentTools: ${tools.length} tools`, {
+        componentToolNames: componentTools.map((t) => t.name)
+      });
+    }
+    const allowedTools = context?.allowedTools ?? agent.config.allowedTools;
+    const deniedTools = context?.deniedTools ?? agent.config.deniedTools;
+    logger.debug(`[getAvailableTools] Filtering: allowed=${allowedTools}, denied=${deniedTools}`);
+    if (allowedTools?.length) {
+      tools = tools.filter((t) => allowedTools.includes(t.name));
+      logger.debug(`[getAvailableTools] After allowedTools filter: ${tools.length} tools`, {
+        toolNames: tools.map((t) => t.name)
+      });
+    }
+    if (deniedTools?.length) {
+      tools = tools.filter((t) => !deniedTools.includes(t.name));
+      logger.debug(`[getAvailableTools] After deniedTools filter: ${tools.length} tools`, {
+        toolNames: tools.map((t) => t.name)
+      });
+    }
+    logger.debug(`[getAvailableTools] Final tools: ${tools.length}`, {
+      toolNames: tools.map((t) => t.name)
+    });
+    return tools;
+  }
+  async run(agentName, query, context) {
+    return this._run(agentName, query, context);
+  }
+  pushMessage(hookCtx, message) {
+    hookCtx.messages.push(message);
+    this.notifyMessageAdded(message);
+  }
+  async _run(agentName, query, context) {
+    this.refreshDependencies();
+    const agent = this.getAgent(agentName);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentName}`);
+    }
+    const runId = `${agentName}:${++this.runCounter}`;
+    logger.info(`Starting agent run: ${agentName} (runId=${runId})`, { query: query.substring(0, 100) });
+    agent.status = "running";
+    this.aborted.set(runId, false);
+    const abortController = new AbortController;
+    this.abortControllers.set(runId, abortController);
+    if (!this.doomLoopCaches.has(runId)) {
+      this.doomLoopCaches.set(runId, new Map);
+    }
+    const effectiveContext = {
+      ...context,
+      agentType: agent.config.type,
+      model: agent.config.model,
+      abort: abortController.signal
+    };
+    const result = {
+      iterations: 0,
+      toolCalls: []
+    };
+    const hookCtx = {
+      agent,
+      iteration: 0,
+      maxIterations: agent.config.maxIterations,
+      messages: [],
+      tools: this.getAvailableTools(agent, effectiveContext),
+      systemPrompt: agent.config.systemPrompt || "You are a helpful assistant.",
+      context: effectiveContext
+    };
+    let historyMessageCount = 0;
+    if (effectiveContext.sessionId) {
+      try {
+        const sessionComponent = this.env.getComponent("session");
+        if (sessionComponent) {
+          const filterHistory = effectiveContext.filterHistory ?? agent.config.filterHistory ?? false;
+          const messages = await this.getConversationHistory(sessionComponent, effectiveContext.sessionId, { minUserMessages: 100, filterHistory });
+          hookCtx.messages = messages.map((msg) => this.messageConverter.toModelMessage(msg));
+          historyMessageCount = hookCtx.messages.length;
+        }
+      } catch (err) {
+        logger.warn(`Failed to load session history: ${err}`);
+      }
+    }
+    this.pushEnvEvent({
+      type: "agent.start",
+      payload: {
+        sessionId: effectiveContext.sessionId,
+        model: effectiveContext.model
+      }
+    });
+    this.pushMessage(hookCtx, {
+      role: "user",
+      content: query
+    });
+    await this.executePluginHooks(agent, "agent:before.start", hookCtx);
+    if (hookCtx._stopped) {
+      return this.finalizeResult(result, hookCtx);
+    }
+    let iteration = 0;
+    let finalText;
+    while (iteration < agent.config.maxIterations) {
+      if (hookCtx._stopped) {
+        break;
+      }
+      if (this.aborted.get(runId)) {
+        hookCtx._stopped = true;
+        hookCtx._stopReason = "aborted";
+        break;
+      }
+      if (effectiveContext.abort?.aborted) {
+        hookCtx._stopped = true;
+        hookCtx._stopReason = "abort_signal";
+        break;
+      }
+      iteration++;
+      hookCtx.iteration = iteration;
+      result.iterations = iteration;
+      logger.debug(`Iteration ${iteration} started`);
+      this.doomLoopCaches.set(runId, new Map);
+      hookCtx.maxIterations = agent.config.maxIterations;
+      try {
+        logger.debug(`[ReAct] Iteration ${iteration} buildMessages result: ${hookCtx.messages.length} messages`);
+        await this.executePluginHooks(agent, "agent:before.llm", hookCtx);
+        if (hookCtx._stopped)
+          break;
+        const llmOutput = await this.invokeLLM(hookCtx);
+        hookCtx.llmOutput = llmOutput;
+        if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+          hookCtx._stopped = true;
+          hookCtx._stopReason = "aborted";
+          break;
+        }
+        await this.executePluginHooks(agent, "agent:after.llm", hookCtx);
+        if (hookCtx._stopped)
+          break;
+        if (llmOutput.content && !llmOutput.toolCalls?.length) {
+          if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+            hookCtx._stopped = true;
+            hookCtx._stopReason = "aborted";
+            break;
+          }
+          finalText = llmOutput.content;
+          this.pushMessage(hookCtx, {
+            role: "assistant",
+            content: llmOutput.content
+          });
+          break;
+        }
+        if (llmOutput.toolCalls?.length) {
+          const assistantParts = [];
+          if (llmOutput.content) {
+            assistantParts.push({
+              type: "text",
+              text: llmOutput.content
+            });
+          }
+          if (llmOutput.reasoning) {
+            assistantParts.push({
+              type: "reasoning",
+              text: llmOutput.reasoning,
+              reasoningType: "core"
+            });
+          }
+          for (const tc of llmOutput.toolCalls) {
+            let argsStr = "";
+            let argsObj = {};
+            if (tc.function?.arguments) {
+              if (typeof tc.function.arguments === "string") {
+                argsStr = tc.function.arguments;
+                try {
+                  argsObj = JSON.parse(argsStr);
+                } catch {
+                  argsObj = { _raw: argsStr };
+                }
+              } else {
+                argsObj = tc.function.arguments;
+                argsStr = JSON.stringify(argsObj);
+              }
+            } else if (tc.arguments) {
+              if (typeof tc.arguments === "string") {
+                argsStr = tc.arguments;
+                try {
+                  argsObj = JSON.parse(argsStr);
+                } catch {
+                  argsObj = { _raw: argsStr };
+                }
+              } else {
+                argsObj = tc.arguments;
+                argsStr = JSON.stringify(argsObj);
+              }
+            }
+            assistantParts.push({
+              type: "tool-call",
+              toolCallId: tc.id,
+              toolName: tc.function?.name || tc.name || "unknown",
+              input: argsObj,
+              toolCall: {
+                name: tc.function?.name || tc.name || "unknown",
+                arguments: argsStr
+              }
+            });
+          }
+          const assistantContent = llmOutput.content?.substring(0, 80) || "(no text)";
+          const toolCallNames = llmOutput.toolCalls?.map((tc) => tc.function?.name || tc.name).join(", ") || "none";
+          logger.debug(`[ReAct] Iteration ${iteration} Adding assistant message: text="${assistantContent}" toolCalls=[${toolCallNames}]`);
+          this.pushMessage(hookCtx, {
+            role: "assistant",
+            content: assistantParts
+          });
+          const allToolCalls = llmOutput.toolCalls;
+          let processedCount = 0;
+          for (const toolCall of allToolCalls) {
+            if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+              hookCtx._stopped = true;
+              hookCtx._stopReason = "aborted";
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted");
+              break;
+            }
+            const func = toolCall.function;
+            const tcName = func?.name || toolCall.name || "unknown";
+            const tcArgs = func?.arguments ? typeof func.arguments === "string" ? JSON.parse(func.arguments) : func.arguments : toolCall.arguments;
+            hookCtx.currentToolCall = {
+              id: toolCall.id,
+              name: tcName,
+              arguments: tcArgs
+            };
+            const doomKey = `${tcName}:${JSON.stringify(tcArgs)}`;
+            const agentCache = this.doomLoopCaches.get(runId) || new Map;
+            const doomCount = agentCache.get(doomKey) || 0;
+            if (doomCount >= agent.config.doomLoopThreshold) {
+              hookCtx.error = new Error(`Doom loop detected: ${tcName}`);
+              await this.executePluginHooks(agent, "on.error", hookCtx);
+              result.error = hookCtx.error.message;
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted: Doom loop detected");
+              break;
+            }
+            agentCache.set(doomKey, doomCount + 1);
+            this.doomLoopCaches.set(runId, agentCache);
+            await this.executePluginHooks(agent, "agent:before.tool", hookCtx);
+            if (hookCtx._stopped) {
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted by plugin hook");
+              break;
+            }
+            const toolResult = await this.executeTool(hookCtx);
+            hookCtx.toolResult = toolResult;
+            await this.executePluginHooks(agent, "agent:after.tool", hookCtx);
+            if (hookCtx._stopped) {
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount + 1, "Execution aborted by plugin hook");
+              break;
+            }
+            const toolOutput = toolResult.success ? toolResult.result.output || "" : toolResult.result.error || "Unknown error";
+            const toolOutputPreview = typeof toolOutput === "string" ? toolOutput.substring(0, 50) : JSON.stringify(toolOutput).substring(0, 50);
+            logger.debug(`[ReAct] Iteration ${iteration} Adding tool message: tool=${toolResult.name} output="${toolOutputPreview}..."`);
+            this.pushMessage(hookCtx, {
+              role: "tool",
+              content: [{
+                type: "tool-result",
+                toolCallId: hookCtx.currentToolCall.id,
+                toolName: toolResult.name,
+                output: toolOutput
+              }]
+            });
+            result.toolCalls.push(hookCtx.currentToolCall);
+            processedCount++;
+          }
+          await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
+        }
+      } catch (error) {
+        logger.error(`Iteration ${iteration} error`, { error });
+        hookCtx.error = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof Error && error instanceof ContextError && error.llmOutput) {
+          const llmOutput = error.llmOutput;
+          if (llmOutput.toolCalls?.length) {
+            const assistantParts = [];
+            if (llmOutput.content) {
+              assistantParts.push({
+                type: "text",
+                text: llmOutput.content
+              });
+            }
+            if (llmOutput.reasoning) {
+              assistantParts.push({
+                type: "reasoning",
+                text: llmOutput.reasoning,
+                reasoningType: "core"
+              });
+            }
+            for (const tc of llmOutput.toolCalls) {
+              assistantParts.push({
+                type: "tool-call",
+                toolCallId: tc.id,
+                toolName: tc.function?.name || tc.name || "unknown",
+                input: typeof tc.function?.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.arguments || {}
+              });
+            }
+            this.pushMessage(hookCtx, {
+              role: "assistant",
+              content: assistantParts
+            });
+          } else if (llmOutput.content) {
+            const assistantParts = [];
+            if (llmOutput.content) {
+              assistantParts.push({
+                type: "text",
+                text: llmOutput.content
+              });
+            }
+            if (llmOutput.reasoning) {
+              assistantParts.push({
+                type: "reasoning",
+                text: llmOutput.reasoning,
+                reasoningType: "core"
+              });
+            }
+            this.pushMessage(hookCtx, {
+              role: "assistant",
+              content: assistantParts.length > 0 ? assistantParts : llmOutput.content
+            });
+          }
+        }
+        await this.executePluginHooks(agent, "agent:on.error", hookCtx);
+        if (!hookCtx._stopped) {
+          hookCtx._stopped = true;
+          if (error instanceof AskUserError) {
+            hookCtx._stopReason = "ask-user";
+            if (hookCtx.currentToolCall) {
+              this.pushMessage(hookCtx, {
+                role: "tool",
+                content: [{
+                  type: "tool-result",
+                  toolCallId: hookCtx.currentToolCall.id,
+                  toolName: "ask_user",
+                  output: JSON.stringify({
+                    error: "AskUserError",
+                    query: error.query,
+                    message: error.message
+                  })
+                }]
+              });
+            }
+            const errorInfo = {
+              query: error.query,
+              sessionId: error.sessionId,
+              nodeId: error.nodeId,
+              nodeType: error.nodeType
+            };
+            result.error = `__ASK_USER_ERROR__:${JSON.stringify(errorInfo)}`;
+          } else {
+            result.error = hookCtx.error.message;
+            if (error?.name === "AbortError") {
+              hookCtx._stopReason = hookCtx._stopReason || "aborted";
+            } else {
+              hookCtx._stopReason = "error";
+            }
+            if (hookCtx.currentToolCall) {
+              this.pushMessage(hookCtx, {
+                role: "tool",
+                content: [{
+                  type: "tool-result",
+                  toolCallId: hookCtx.currentToolCall.id,
+                  toolName: hookCtx.currentToolCall.name,
+                  output: JSON.stringify({ error: hookCtx.error.message })
+                }]
+              });
+            }
+          }
+        } else {
+          result.error = hookCtx.error.message;
+          if (hookCtx.currentToolCall) {
+            const errorMsg = hookCtx.error?.message || "Execution interrupted";
+            this.pushMessage(hookCtx, {
+              role: "tool",
+              content: [{
+                type: "tool-result",
+                toolCallId: hookCtx.currentToolCall.id,
+                toolName: hookCtx.currentToolCall.name,
+                output: JSON.stringify({ error: errorMsg })
+              }]
+            });
+          }
+        }
+        break;
+      }
+    }
+    result.finalText = finalText;
+    if (iteration >= agent.config.maxIterations && !result.finalText) {
+      result.finalText = "Maximum iterations reached.";
+    }
+    const reactContext = {
+      messages: hookCtx.messages,
+      sessionId: effectiveContext.sessionId,
+      summary: result.finalText
+    };
+    await this.executePluginHooks(agent, "agent:after.react", {
+      ...hookCtx,
+      ...reactContext
+    });
+    await this.executePluginHooks(agent, "agent:after.complete", hookCtx);
+    if (this.aborted.get(runId) === true || hookCtx._stopped) {
+      agent.status = "stopped";
+    } else {
+      agent.status = "idle";
+    }
+    this.aborted.delete(runId);
+    this.abortControllers.delete(runId);
+    if (result.error) {
+      this.pushEnvEvent({
+        type: "agent.error",
+        payload: {
+          error: result.error,
+          iterations: result.iterations,
+          stopReason: result.stopReason
+        }
+      });
+    } else {
+      this.pushEnvEvent({
+        type: "agent.completed",
+        payload: {
+          finalText: result.finalText,
+          iterations: result.iterations,
+          stopReason: result.stopReason
+        }
+      });
+    }
+    let newMessages = hookCtx.messages.slice(historyMessageCount);
+    logger.info(`Agent run completed: ${agentName}`, {
+      iterations: result.iterations,
+      hasError: !!result.error,
+      hookCtxMessages: hookCtx.messages.length,
+      historyMessageCount,
+      sessionId: effectiveContext.sessionId
+    });
+    await this.recordSessionMessages(effectiveContext.sessionId, newMessages);
+    return this.finalizeResult(result, hookCtx);
+  }
+  abort(agentName) {
+    for (const key of this.aborted.keys()) {
+      if (key.startsWith(agentName + ":")) {
+        this.aborted.set(key, true);
+      }
+    }
+    for (const [key, controller] of this.abortControllers) {
+      if (key.startsWith(agentName + ":")) {
+        controller.abort();
+        logger.debug(`[abort] AbortController.abort() called for run: ${key}`);
+      }
+    }
+    logger.info(`Agent aborted: ${agentName}`);
+  }
+  async buildMessages(ctx) {
+    const messages = [];
+    if (ctx.systemPrompt) {
+      messages.push({
+        role: "system",
+        content: ctx.systemPrompt
+      });
+    }
+    if (ctx.additionInfo) {
+      messages.push({
+        role: "user",
+        content: `额外信息：
+${ctx.additionInfo}`
+      });
+    }
+    messages.push(...ctx.messages);
+    return messages;
+  }
+  async invokeLLM(ctx) {
+    logger.debug("[invokeLLM] Starting LLM invocation");
+    if (this.llmComponent?.invoke) {
+      const messages = await this.buildMessages(ctx);
+      const convertedMessages = messages.map(toLLMMessage);
+      logger.debug(`[invokeLLM] Calling LLMComponent.invoke with ${convertedMessages.length} messages`);
+      try {
+        const result = await this.llmComponent.invoke({
+          messages: convertedMessages,
+          tools: ctx.tools.map((t) => ({
+            name: t.name,
+            description: t.description || "",
+            parameters: t.parameters ?? {}
+          })),
+          model: ctx.context.model,
+          context: {
+            sessionId: ctx.context.sessionId,
+            messageId: ctx.context.messageId
+          },
+          abortSignal: ctx.context.abort
+        });
+        logger.debug("[invokeLLM] LLMComponent.invoke returned successfully");
+        return {
+          content: result.output?.content || "",
+          reasoning: result.output?.reasoning,
+          toolCalls: result.output?.toolCalls?.map((tc) => ({
+            id: tc.id,
+            function: tc.function ? {
+              name: tc.function.name,
+              arguments: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+            } : undefined,
+            name: tc.name,
+            arguments: tc.arguments
+          })),
+          finishReason: result.output?.finishReason
+        };
+      } catch (error) {
+        logger.error("[invokeLLM] LLMComponent.invoke threw an error:", error);
+        throw error;
+      }
+    }
+    logger.warn("[invokeLLM] No LLMComponent available, using mock");
+    return {
+      content: "Mock response: Hello!",
+      finishReason: "stop"
+    };
+  }
+  async executeTool(ctx) {
+    const toolCall = ctx.currentToolCall;
+    const toolName = toolCall.function?.name || toolCall.name || "unknown";
+    logger.debug(`[executeTool] Looking for tool: "${toolName}"`);
+    logger.debug(`[executeTool] Available tools: [${ctx.tools.map((t) => t.name).join(", ")}]`);
+    const tool = ctx.tools.find((t) => t.name === toolName);
+    if (!tool) {
+      this.pushEnvEvent({
+        type: "tool.error",
+        payload: {
+          error: `Tool not found: ${toolName}`,
+          toolName
+        }
+      });
+      return {
+        id: toolCall.id,
+        name: toolName,
+        success: false,
+        result: {
+          success: false,
+          output: "",
+          error: `Tool not found: ${toolName}`
+        }
+      };
+    }
+    try {
+      const toolContext = {
+        session_id: ctx.context.sessionId,
+        message_id: ctx.context.messageId,
+        abort: ctx.context.abort,
+        workdir: ctx.context.metadata?.workdir,
+        metadata: ctx.context.metadata
+      };
+      const request = {
+        name: toolName,
+        args: toolCall.arguments,
+        context: toolContext
+      };
+      let result;
+      if (this.toolComponent?.execute) {
+        result = await this.toolComponent.execute(request);
+      } else {
+        logger.debug(`[executeTool] No ToolComponent available, executing tool directly`);
+        result = await tool.execute(toolCall.arguments, toolContext);
+      }
+      this.pushEnvEvent({
+        type: "tool.result",
+        payload: {
+          id: toolCall.id,
+          name: toolName,
+          result,
+          success: result.success
+        }
+      });
+      return {
+        id: toolCall.id,
+        name: toolName,
+        success: result.success,
+        result
+      };
+    } catch (error) {
+      if (error instanceof AskUserError) {
+        throw error;
+      }
+      this.pushEnvEvent({
+        type: "tool.error",
+        payload: {
+          error: error instanceof Error ? error.message : String(error),
+          toolName
+        }
+      });
+      return {
+        id: toolCall.id,
+        name: toolName,
+        success: false,
+        result: {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  async executePluginHooks(agent, point, ctx) {
+    const hooks = [];
+    for (const [name, plugin] of agent.plugins) {
+      for (const hook of plugin.hooks) {
+        if (hook.point === point) {
+          hooks.push({
+            plugin,
+            priority: hook.priority ?? 0,
+            execute: plugin.execute
+          });
+        }
+      }
+    }
+    hooks.sort((a, b) => b.priority - a.priority);
+    for (const { plugin, execute } of hooks) {
+      try {
+        const result = await execute(ctx);
+        if (!result.continue) {
+          ctx._stopped = true;
+          ctx._stopReason = `Plugin ${plugin.name} stopped execution`;
+          logger.info(`Hook ${point} stopped by plugin ${plugin.name}`);
+          break;
+        }
+        if (result.action) {
+          await this.handleHookAction(result.action, ctx);
+        }
+      } catch (error) {
+        logger.error(`Hook ${point} error in plugin ${plugin.name}`, { error });
+        ctx._errors = ctx._errors || [];
+        ctx._errors.push({
+          plugin: plugin.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  async handleHookAction(action, ctx) {
+    switch (action.type) {
+      case "stop":
+        ctx._stopped = true;
+        ctx._stopReason = "stopped_by_hook";
+        break;
+      case "inject_message":
+        if (action.payload && typeof action.payload === "object") {
+          const msg = action.payload;
+          ctx.messages.push(msg);
+        }
+        break;
+      case "skip_tool":
+        ctx._pendingAction = action;
+        break;
+    }
+  }
+  notifyMessageAdded(message) {
+    logger.debug(`Message added: ${message.role}`);
+  }
+  finalizeResult(result, ctx) {
+    return {
+      ...result,
+      stopped: ctx._stopped,
+      stopReason: ctx._stopReason
+    };
+  }
+  async recordSessionMessages(sessionId, allMessages = []) {
+    if (!sessionId) {
+      return;
+    }
+    try {
+      const sessionComponent = this.env.getComponent("session");
+      if (!sessionComponent) {
+        logger.warn("SessionComponent not found, skipping session recording");
+        return;
+      }
+      for (const msg of allMessages) {
+        if (msg.role === "system") {
+          continue;
+        }
+        if (msg.role === "assistant" || msg.role === "tool") {
+          if (this.isEmptyMessage(msg.content)) {
+            continue;
+          }
+        }
+        await sessionComponent.addMessage(sessionId, this.messageConverter.fromModelMessage(msg, { sessionID: sessionId }));
+      }
+    } catch (err) {
+      logger.warn(`Failed to record session messages: ${err}`);
+    }
+  }
+  isEmptyMessage(content) {
+    if (content === null || content === undefined) {
+      return true;
+    }
+    if (typeof content === "string" && content.trim() === "") {
+      return true;
+    }
+    if (Array.isArray(content) && content.length === 0) {
+      return true;
+    }
+    return false;
+  }
+  pushEnvEvent(event) {
+    if (this.env && "pushEnvEvent" in this.env) {
+      try {
+        const fullEvent = {
+          id: `evt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          type: event.type,
+          timestamp: Date.now(),
+          metadata: {
+            source: "agent",
+            agent_name: this.name
+          },
+          payload: event.payload
+        };
+        this.env?.pushEnvEvent(fullEvent);
+      } catch (err) {
+        logger.warn(`[pushEnvEvent] Failed to push event: ${err}`);
+      }
+    }
+  }
+  async getConversationHistory(sessionComponent, sessionId, options = {}) {
+    const minUserMessages = options.minUserMessages ?? 100;
+    const filterHistory = options.filterHistory ?? false;
+    const ctx = await sessionComponent.getContext(sessionId, {
+      fullHistory: false,
+      minUserMessages
+    });
+    let messages = ctx.messages;
+    if (filterHistory) {
+      messages = messages.filter((msg) => {
+        if (msg.metadata?.type === "tool_call" || msg.metadata?.type === "tool_result") {
+          return false;
+        }
+        return msg.role === "user" || msg.role === "assistant";
+      });
+    }
+    return messages;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("agent.component.run", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "_run", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.invokeLLM", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "invokeLLM", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.executeTool", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "executeTool", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.recordSessionMessages", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "recordSessionMessages", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.getConversationHistory", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "getConversationHistory", null);
+export { AgentComponentConfigSchema, AgentComponent };