@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

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

@@ -1,1130 +0,0 @@
-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-kkbwepqb.js";
-import {
-  SessionMessageConverter
-} from "./roy-agent-core-jfh9q2qh.js";
-import {
-  TracedAs,
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.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.context?.additionInfo) {
-      messages.push({
-        role: "user",
-        content: `额外信息：
-${ctx.context.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 };