plugin-agent-orchestrator 1.0.28 → 1.0.32

package/dist/server/services/AgentHarness.js

@@ -29,525 +29,50 @@ __export(AgentHarness_exports, {
   AgentHarness: () => AgentHarness
 });
 module.exports = __toCommonJS(AgentHarness_exports);
-var import_zod = require("zod");
-var import_prebuilt = require("@langchain/langgraph/prebuilt");
-var import_tools = require("@langchain/core/tools");
-var import_messages = require("@langchain/core/messages");
-var import_ExecutionSpanService = require("./ExecutionSpanService");
-var import_TokenTracker = require("./TokenTracker");
-var import_ContextAggregator = require("./ContextAggregator");
-var import_CircuitBreaker = require("./CircuitBreaker");
 var import_ctx_utils = require("../utils/ctx-utils");
-var import_skill_settings = require("../utils/skill-settings");
-var import_logging = require("../utils/logging");
-var import_ai_manager = require("../utils/ai-manager");
-const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
-const ORCHESTRATOR_PATH_KEY = "__orchestratorPath";
-function sanitizeToolPart(value) {
-  return (value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
+function retiredExecutionError(stepType) {
+  return new Error(
+    `Legacy AgentHarness ${stepType || "agent"} execution is retired. Use @nocobase/plugin-ai native AIEmployee/SubAgentsDispatcher flow for new sub-agent runs.`
+  );
 }
-function buildDelegateToolName(leaderUsername, subAgentUsername) {
-  return `delegate_${sanitizeToolPart(leaderUsername)}_to_${sanitizeToolPart(subAgentUsername)}`;
+function harnessTagFrom(run, step) {
+  return (0, import_ctx_utils.asObject)(run == null ? void 0 : run.metadata).harnessTag || (0, import_ctx_utils.asObject)(step == null ? void 0 : step.metadata).harnessTag || "default";
 }
 class AgentHarness {
   constructor(plugin, registryService, tokenTracker) {
     this.plugin = plugin;
     this.registryService = registryService;
-    this.spanService = new import_ExecutionSpanService.ExecutionSpanService(plugin);
-    this.tokenTracker = tokenTracker || new import_TokenTracker.TokenTracker(plugin);
-    this.contextAggregator = new import_ContextAggregator.ContextAggregator(plugin);
+    this.tokenTracker = tokenTracker;
   }
-  spanService;
-  tokenTracker;
-  contextAggregator;
   get db() {
-    return this.plugin.db;
+    var _a;
+    return (_a = this.plugin) == null ? void 0 : _a.db;
   }
   get app() {
-    return this.plugin.app;
+    var _a;
+    return (_a = this.plugin) == null ? void 0 : _a.app;
   }
-  async executeStep(run, step, options = {}) {
-    const harnessTag = (0, import_ctx_utils.asObject)(run.metadata).harnessTag || (0, import_ctx_utils.asObject)(step.metadata).harnessTag || "default";
-    const profile = await this.registryService.getHarnessProfile(harnessTag);
-    const settings = (0, import_ctx_utils.asObject)(profile == null ? void 0 : profile.settings);
-    if (step.type === "sub_agent") {
-      if (settings.allowSubAgents === false) {
-        throw new Error(`Harness profile "${harnessTag}" does not allow sub-agent execution.`);
-      }
-      return this.invokeSubAgentStep(run, step, settings, options);
-    }
-    if ((step.type === "tool" || step.type === "skill") && step.target) {
-      if (settings.allowToolCalls === false) {
-        throw new Error(`Harness profile "${harnessTag}" does not allow tool/skill execution.`);
-      }
-      return this.invokeNamedTool(run, step, step.target, step.input || {}, settings, options);
-    }
-    if (step.type === "verification") {
+  async executeStep(run, step, _options = {}) {
+    const harnessTag = harnessTagFrom(run, step);
+    if ((step == null ? void 0 : step.type) === "verification") {
       return {
         passed: true,
-        summary: "Verification completed by orchestrator controller.",
+        summary: "Verification completed by legacy orchestrator compatibility shim.",
         checkedDependencies: Array.isArray(step.dependsOn) ? step.dependsOn.map(String) : [],
-        harnessTag
+        harnessTag,
+        retired: true
       };
     }
-    return {
-      summary: `${step.title || step.planKey} completed by orchestrator controller.`,
-      description: step.description || "",
-      input: step.input || {},
-      harnessTag
-    };
-  }
-  async invokeSubAgentStep(run, step, settings, options) {
-    var _a;
-    const target = step.target || (0, import_ctx_utils.asObject)(step.metadata).subAgentUsername || ((_a = step.input) == null ? void 0 : _a.subAgentUsername);
-    if (!target) {
-      throw new Error(`Sub-agent step "${step.planKey}" is missing target sub-agent username.`);
-    }
-    if (!run.leaderUsername) {
-      throw new Error(`Sub-agent step "${step.planKey}" requires a leader AI employee username.`);
-    }
-    const toolName = String(target).startsWith("delegate_") ? String(target) : buildDelegateToolName(run.leaderUsername, target);
-    const task = step.description || step.title || run.goal;
-    const context = (0, import_ctx_utils.trimText)(
-      {
-        goal: run.goal,
-        input: step.input || {},
-        harnessTag: (0, import_ctx_utils.asObject)(run.metadata).harnessTag || (0, import_ctx_utils.asObject)(step.metadata).harnessTag || "default",
-        agentLoopRunId: String(run.id),
-        agentLoopStepId: String(step.id)
-      },
-      2e4
-    );
-    const circuitBreaker = (0, import_CircuitBreaker.getCircuitBreaker)({ appLog: this.app });
-    const circuitKey = (0, import_CircuitBreaker.subAgentCircuitKey)(run.leaderUsername, target);
-    if (!circuitBreaker.isAllowed(circuitKey)) {
-      const state = circuitBreaker.getState(circuitKey);
-      throw new Error(
-        `Sub-agent "${target}" circuit is open (${(state == null ? void 0 : state.failures) || 0} failures). Retry after the recovery timeout.`
-      );
-    }
-    try {
-      const result = await this.invokeNamedTool(run, step, toolName, { task, context }, settings, options);
-      circuitBreaker.recordSuccess(circuitKey);
-      return result;
-    } catch (e) {
-      if ((e == null ? void 0 : e.message) !== "requires_approval") {
-        circuitBreaker.recordFailure(circuitKey);
-      }
-      throw e;
-    }
-  }
-  async invokeNamedTool(run, step, toolName, args, settings, options) {
-    var _a, _b, _c;
-    if (String(toolName).startsWith("orchestrator_")) {
-      throw new Error(`Tool step "${step.planKey}" cannot call internal orchestrator control tool "${toolName}".`);
-    }
-    if (Array.isArray(settings.allowTools) && settings.allowTools.length > 0) {
-      if (!settings.allowTools.includes(toolName)) {
-        throw new Error(`Tool "${toolName}" is not on the allowed list for harness profile.`);
-      }
-    }
-    if (Array.isArray(settings.denyTools) && settings.denyTools.length > 0) {
-      if (settings.denyTools.includes(toolName)) {
-        throw new Error(`Tool "${toolName}" is on the denied list for harness profile.`);
-      }
-    }
-    const toolsManager = (0, import_ai_manager.tryGetAIToolsManager)(this.app);
-    const tool = await ((_a = toolsManager == null ? void 0 : toolsManager.getTools) == null ? void 0 : _a.call(toolsManager, toolName));
-    if (!(tool == null ? void 0 : tool.invoke)) {
-      throw new Error(`Tool "${toolName}" was not found or is missing standard invoke handler.`);
-    }
-    const isDelegationTool = await this.registryService.isRegisteredDelegationTool(toolName);
-    const isStepAlreadyApproved = ((_b = step == null ? void 0 : step.approval) == null ? void 0 : _b.approved) === true;
-    if (!isDelegationTool && !isStepAlreadyApproved && (tool.defaultPermission === "ASK" || settings.requireApprovalRiskLevel && tool.riskLevel && tool.riskLevel >= settings.requireApprovalRiskLevel)) {
-      throw new Error("requires_approval");
-    }
-    const ctx = options.ctx || {};
-    const previousEmployee = ctx._currentAIEmployee;
-    const previousStateEmployee = (_c = ctx.state) == null ? void 0 : _c.currentAIEmployee;
-    if (run.leaderUsername) {
-      ctx._currentAIEmployee = run.leaderUsername;
-      ctx.state = { ...ctx.state || {}, currentAIEmployee: run.leaderUsername };
-    }
-    const previousRuntime = ctx.runtime;
-    const toolCallId = `agent-loop-${run.id}-${step.id}`;
-    const runtime = {
-      toolCallId,
-      writer: (chunk) => {
-        this.app.log.trace(`[AgentHarness] Tool output:`, chunk);
-      }
-    };
-    ctx.runtime = runtime;
-    try {
-      const result = await tool.invoke(ctx, args, runtime);
-      if ((result == null ? void 0 : result.status) === "error") {
-        throw new Error(result.content || `Tool "${toolName}" returned an error.`);
-      }
+    if (!(step == null ? void 0 : step.target) && ((step == null ? void 0 : step.type) === "reasoning" || !(step == null ? void 0 : step.type))) {
       return {
-        toolName,
-        args,
-        result
+        summary: `${(step == null ? void 0 : step.title) || (step == null ? void 0 : step.planKey) || "Step"} is retained as a legacy planning record.`,
+        description: (step == null ? void 0 : step.description) || "",
+        input: (step == null ? void 0 : step.input) || {},
+        harnessTag,
+        retired: true
       };
-    } finally {
-      if (previousRuntime === void 0) {
-        delete ctx.runtime;
-      } else {
-        ctx.runtime = previousRuntime;
-      }
-      if (previousEmployee === void 0) {
-        delete ctx._currentAIEmployee;
-      } else {
-        ctx._currentAIEmployee = previousEmployee;
-      }
-      if (ctx.state) {
-        if (previousStateEmployee === void 0) {
-          delete ctx.state.currentAIEmployee;
-        } else {
-          ctx.state.currentAIEmployee = previousStateEmployee;
-        }
-      }
     }
-  }
-  async runSubAgent(ctx, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-    const {
-      leaderUsername,
-      subAgentUsername,
-      subAgentEmployee,
-      task,
-      context,
-      maxDepth,
-      timeout,
-      toolCallId,
-      toolName,
-      llmService,
-      model,
-      recursionLimit,
-      rootRunId,
-      parentSpanId,
-      agentLoopRunId,
-      agentLoopStepId
-    } = options;
-    const effectiveRootRunId = rootRunId || `run_${Date.now()}`;
-    const startTime = Date.now();
-    const currentDepth = options.currentDepth ?? 0;
-    const currentPath = options.currentPath ?? [leaderUsername];
-    const trace = [
-      {
-        type: "start",
-        at: (0, import_ctx_utils.nowIso)(),
-        title: `Delegation started: ${leaderUsername} -> ${subAgentUsername}`,
-        content: task
-      }
-    ];
-    const executionSpan = await this.spanService.create({
-      rootRunId: effectiveRootRunId,
-      parentSpanId,
-      type: "sub_agent",
-      status: "running",
-      leaderUsername,
-      employeeUsername: subAgentUsername,
-      title: `Delegation: ${leaderUsername} -> ${subAgentUsername}`,
-      input: { task, context },
-      metadata: {
-        depth: maxDepth,
-        toolName,
-        recursionLimit,
-        agentLoopRunId,
-        agentLoopStepId
-      },
-      userId: ((_b = (_a = ctx == null ? void 0 : ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id) || ((_d = (_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id)
-    });
-    const executionSpanId = (executionSpan == null ? void 0 : executionSpan.id) ? String(executionSpan.id) : void 0;
-    const logRecord = await this.logDelegation(ctx, {
-      leaderUsername,
-      subAgentUsername,
-      toolName,
-      task,
-      context,
-      result: "",
-      status: "running",
-      depth: maxDepth,
-      durationMs: 0,
-      trace
-    });
-    if (executionSpanId && (logRecord == null ? void 0 : logRecord.id)) {
-      await this.spanService.update(executionSpanId, { orchestratorLogId: logRecord.id });
-    }
-    try {
-      const aiPlugin = ctx.app.pm.get("ai");
-      if (!aiPlugin) {
-        throw new Error("Plugin AI is not enabled.");
-      }
-      const modelSettings = await this.registryService.resolveModelSettings(
-        subAgentUsername,
-        leaderUsername,
-        llmService && model ? { llmService, model } : void 0
-      );
-      if (!modelSettings) {
-        throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured.`);
-      }
-      const { provider } = await aiPlugin.aiManager.getLLMService({
-        llmService: modelSettings.llmService,
-        model: modelSettings.model
-      });
-      const chatModel = provider.createModel();
-      const coreToolsManager = (0, import_ai_manager.getAIToolsManager)(ctx.app);
-      const allTools = await coreToolsManager.listTools();
-      const normalizedSkillSettings = (0, import_skill_settings.normalizeAIEmployeeSkillSettings)(subAgentEmployee.skillSettings).skillSettings;
-      const employeeTools = normalizedSkillSettings.tools.filter((tool) => Boolean(tool.name));
-      const employeeToolMap = new Map(employeeTools.map((tool) => [tool.name, tool]));
-      const langchainTools = [];
-      for (const toolEntry of allTools) {
-        const entryName = toolEntry.definition.name;
-        if (!entryName) continue;
-        const employeeTool = employeeToolMap.get(entryName);
-        if (!employeeTool || employeeTool.autoCall !== true || toolEntry.execution === "frontend") {
-          continue;
-        }
-        langchainTools.push(
-          new import_tools.DynamicStructuredTool({
-            name: entryName.replace(/[^a-zA-Z0-9_-]/g, "_"),
-            description: toolEntry.definition.description || entryName,
-            schema: toolEntry.definition.schema || import_zod.z.object({}),
-            func: async (toolArgs) => {
-              var _a2, _b2, _c2, _d2, _e2;
-              const invokeCtx = Object.create(ctx);
-              invokeCtx._currentAIEmployee = subAgentUsername;
-              invokeCtx[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
-              invokeCtx[ORCHESTRATOR_PATH_KEY] = [...currentPath, subAgentUsername];
-              if (ctx.state) {
-                invokeCtx.state = Object.create(ctx.state);
-                invokeCtx.state.currentAIEmployee = subAgentUsername;
-              }
-              const toolStartedAt = Date.now();
-              const isSkillHubTool = entryName === "skill_hub_execute" || entryName.startsWith("skill_hub_");
-              const toolSpan = await this.spanService.create({
-                rootRunId: effectiveRootRunId,
-                parentSpanId: executionSpanId,
-                type: isSkillHubTool ? "skill" : "tool",
-                status: "running",
-                leaderUsername,
-                employeeUsername: subAgentUsername,
-                toolName: toolEntry.definition.name,
-                title: isSkillHubTool ? `Skill: ${toolEntry.definition.name}` : `Tool: ${toolEntry.definition.name}`,
-                input: toolArgs,
-                metadata: {
-                  depth: currentDepth + 1,
-                  toolCallId: `orch-${toolCallId}`,
-                  agentLoopRunId,
-                  agentLoopStepId
-                },
-                userId: ((_b2 = (_a2 = ctx == null ? void 0 : ctx.auth) == null ? void 0 : _a2.user) == null ? void 0 : _b2.id) || ((_d2 = (_c2 = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c2.currentUser) == null ? void 0 : _d2.id)
-              });
-              const toolSpanId = (toolSpan == null ? void 0 : toolSpan.id) ? String(toolSpan.id) : void 0;
-              (0, import_ExecutionSpanService.setOrchestratorTraceContext)(invokeCtx, {
-                rootRunId: effectiveRootRunId,
-                spanId: toolSpanId,
-                parentSpanId: executionSpanId,
-                toolCallId: `orch-${toolCallId}`,
-                leaderUsername,
-                employeeUsername: subAgentUsername,
-                toolName: toolEntry.definition.name,
-                agentLoopRunId,
-                agentLoopStepId
-              });
-              trace.push({
-                type: "tool_call",
-                at: (0, import_ctx_utils.nowIso)(),
-                title: `Calling tool: ${toolEntry.definition.name}`,
-                toolName: toolEntry.definition.name,
-                args: toolArgs
-              });
-              const subToolCallId = `orch-${toolCallId}`;
-              const runtime = {
-                toolCallId: subToolCallId,
-                writer: (chunk) => {
-                  this.app.log.trace(`[AgentHarness] Tool output:`, chunk);
-                }
-              };
-              invokeCtx.runtime = runtime;
-              try {
-                const res = await toolEntry.invoke(invokeCtx, toolArgs, runtime);
-                const output = (0, import_ctx_utils.trimText)((res == null ? void 0 : res.content) ?? (res == null ? void 0 : res.result) ?? res, 5e4);
-                trace.push({
-                  type: "tool_result",
-                  at: (0, import_ctx_utils.nowIso)(),
-                  title: `Tool finished: ${toolEntry.definition.name}`,
-                  toolName: toolEntry.definition.name,
-                  status: (res == null ? void 0 : res.status) || "success",
-                  content: (0, import_ctx_utils.trimText)(output, 2e3)
-                });
-                if ((res == null ? void 0 : res.status) === "error") {
-                  await this.spanService.finish(toolSpanId, "error", toolStartedAt, {
-                    output,
-                    error: (0, import_ctx_utils.trimText)(res.content || output, 1e4)
-                  });
-                  throw new Error(`Tool <${toolEntry.definition.name}> failed: ${res.content}`);
-                }
-                await this.spanService.finish(toolSpanId, "success", toolStartedAt, {
-                  output,
-                  skillExecutionId: ((_e2 = res == null ? void 0 : res.result) == null ? void 0 : _e2.execId) || (res == null ? void 0 : res.execId)
-                });
-                return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
-              } catch (e) {
-                trace.push({
-                  type: "tool_error",
-                  at: (0, import_ctx_utils.nowIso)(),
-                  title: `Tool failed: ${toolEntry.definition.name}`,
-                  toolName: toolEntry.definition.name,
-                  status: "error",
-                  content: e.message
-                });
-                await this.spanService.finish(toolSpanId, "error", toolStartedAt, {
-                  error: (0, import_ctx_utils.trimText)(e.message, 1e4)
-                });
-                throw e;
-              }
-            }
-          })
-        );
-      }
-      const abortController = new AbortController();
-      const executor = (0, import_prebuilt.createReactAgent)({
-        llm: chatModel,
-        tools: langchainTools
-      });
-      let systemPrompt = ((_e = subAgentEmployee.chatSettings) == null ? void 0 : _e.systemPrompt) || subAgentEmployee.bio || `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${subAgentEmployee.about || ""}`;
-      try {
-        const kbPlugin = ctx.app.pm.get("plugin-knowledge-base");
-        if (kbPlugin == null ? void 0 : kbPlugin.sessionContext) {
-          const sessionId = ((_h = (_g = (_f = ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.values) == null ? void 0 : _h.sessionId) || ((_j = (_i = ctx.action) == null ? void 0 : _i.params) == null ? void 0 : _j.sessionId) || ((_k = ctx.state) == null ? void 0 : _k.sessionId);
-          const contextSummary = await kbPlugin.sessionContext.buildSummary(
-            { rootRunId: effectiveRootRunId, ...sessionId ? { sessionId } : {} },
-            6e3
-          );
-          if (contextSummary) {
-            systemPrompt += `
-
-<shared_context>
-The following context was shared by other agents in this workflow:
-${contextSummary}
-</shared_context>`;
-          }
-        }
-      } catch (e) {
-      }
-      if (agentLoopRunId) {
-        try {
-          systemPrompt = await this.contextAggregator.enrichSystemPrompt(systemPrompt, agentLoopRunId, agentLoopStepId);
-        } catch {
-        }
-      }
-      const combinedTask = context ? `Task: ${task}
-
-Context:
-${context}` : `Task: ${task}`;
-      const effectiveLimit = recursionLimit && recursionLimit > 0 ? recursionLimit : 50;
-      let timeoutId;
-      const timeoutMs = Number(timeout) > 0 ? Number(timeout) : 12e4;
-      const timeoutPromise = new Promise((_resolve, reject) => {
-        timeoutId = setTimeout(() => {
-          abortController.abort();
-          reject(new Error(`Sub-agent execution timed out after ${timeoutMs}ms.`));
-        }, timeoutMs);
-      });
-      const invokePromise = executor.invoke(
-        {
-          messages: [new import_messages.SystemMessage(systemPrompt), new import_messages.HumanMessage(combinedTask)]
-        },
-        { recursionLimit: effectiveLimit, signal: abortController.signal }
-      );
-      let finalState;
-      try {
-        finalState = await Promise.race([invokePromise, timeoutPromise]);
-      } finally {
-        if (timeoutId) clearTimeout(timeoutId);
-      }
-      const tokenUsage = (0, import_TokenTracker.extractTokenUsage)(finalState);
-      if (tokenUsage) {
-        await this.tokenTracker.trackSpan(executionSpanId, tokenUsage, agentLoopRunId);
-      }
-      const messages = (finalState == null ? void 0 : finalState.messages) || [];
-      const lastAIMessage = [...messages].reverse().find((m) => m.getType() === "ai");
-      let content = "";
-      if (lastAIMessage) {
-        content = typeof lastAIMessage.content === "string" ? lastAIMessage.content : Array.isArray(lastAIMessage.content) ? lastAIMessage.content.map((c) => c.text || JSON.stringify(c)).join("\n") : String(lastAIMessage.content);
-      }
-      trace.push({
-        type: "finish",
-        at: (0, import_ctx_utils.nowIso)(),
-        title: `Delegation finished: ${subAgentUsername}`,
-        status: "success",
-        content: (0, import_ctx_utils.trimText)(content, 2e3)
-      });
-      await this.logDelegation(ctx, {
-        id: logRecord == null ? void 0 : logRecord.id,
-        leaderUsername,
-        subAgentUsername,
-        toolName,
-        task,
-        context,
-        result: content,
-        status: "success",
-        depth: maxDepth,
-        durationMs: Date.now() - startTime,
-        trace
-      });
-      await this.spanService.finish(executionSpanId, "success", startTime, {
-        output: content,
-        metadata: {
-          depth: currentDepth,
-          toolName,
-          recursionLimit,
-          agentLoopRunId,
-          agentLoopStepId
-        }
-      });
-      return {
-        status: "success",
-        content
-      };
-    } catch (e) {
-      trace.push({
-        type: "error",
-        at: (0, import_ctx_utils.nowIso)(),
-        title: `Delegation failed: ${subAgentUsername}`,
-        status: "error",
-        content: e.message
-      });
-      await this.logDelegation(ctx, {
-        id: logRecord == null ? void 0 : logRecord.id,
-        leaderUsername,
-        subAgentUsername,
-        toolName,
-        task,
-        context,
-        result: "",
-        status: "error",
-        depth: maxDepth,
-        durationMs: Date.now() - startTime,
-        error: e.message,
-        trace
-      });
-      await this.spanService.finish(executionSpanId, "error", startTime, {
-        error: (0, import_ctx_utils.trimText)(e.message, 1e4),
-        metadata: {
-          depth: currentDepth,
-          toolName,
-          recursionLimit,
-          agentLoopRunId,
-          agentLoopStepId
-        }
-      });
-      return {
-        status: "error",
-        content: e.message
-      };
-    }
-  }
-  async logDelegation(ctx, data) {
-    return (0, import_logging.logDelegation)(ctx, this.plugin, data);
+    throw retiredExecutionError(step == null ? void 0 : step.type);
   }
 }
 // Annotate the CommonJS export names for ESM import in node: