plugin-agent-orchestrator 1.0.17 → 1.0.19

package/dist/server/services/AgentHarness.js

@@ -0,0 +1,565 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AgentHarness_exports = {};
+__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");
+const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
+const ORCHESTRATOR_PATH_KEY = "__orchestratorPath";
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function trimText(value, max = 5e4) {
+  let text = "";
+  if (typeof value === "string") {
+    text = value;
+  } else if (value != null) {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  }
+  return text.length > max ? `${text.slice(0, max)}
+...[truncated]` : text;
+}
+function sanitizeToolPart(value) {
+  return (value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function buildDelegateToolName(leaderUsername, subAgentUsername) {
+  return `delegate_${sanitizeToolPart(leaderUsername)}_to_${sanitizeToolPart(subAgentUsername)}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+class AgentHarness {
+  constructor(plugin, registryService) {
+    this.plugin = plugin;
+    this.registryService = registryService;
+    this.spanService = new import_ExecutionSpanService.ExecutionSpanService(plugin);
+  }
+  spanService;
+  get db() {
+    return this.plugin.db;
+  }
+  get app() {
+    return this.plugin.app;
+  }
+  async executeStep(run, step, options = {}) {
+    const harnessTag = asObject(run.metadata).harnessTag || asObject(step.metadata).harnessTag || "default";
+    const profile = await this.registryService.getHarnessProfile(harnessTag);
+    const settings = 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") {
+      return {
+        passed: true,
+        summary: "Verification completed by orchestrator controller.",
+        checkedDependencies: Array.isArray(step.dependsOn) ? step.dependsOn.map(String) : [],
+        harnessTag
+      };
+    }
+    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 || 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 = trimText(
+      {
+        goal: run.goal,
+        input: step.input || {},
+        harnessTag: asObject(run.metadata).harnessTag || asObject(step.metadata).harnessTag || "default",
+        agentLoopRunId: String(run.id),
+        agentLoopStepId: String(step.id)
+      },
+      2e4
+    );
+    return this.invokeNamedTool(run, step, toolName, { task, context }, settings, options);
+  }
+  async invokeNamedTool(run, step, toolName, args, settings, options) {
+    var _a, _b, _c, _d, _e;
+    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 = (_b = (_a = this.app) == null ? void 0 : _a.aiManager) == null ? void 0 : _b.toolsManager;
+    const tool = await ((_c = toolsManager == null ? void 0 : toolsManager.getTools) == null ? void 0 : _c.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 = ((_d = step == null ? void 0 : step.approval) == null ? void 0 : _d.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 = (_e = ctx.state) == null ? void 0 : _e.currentAIEmployee;
+    if (run.leaderUsername) {
+      ctx._currentAIEmployee = run.leaderUsername;
+      ctx.state = { ...ctx.state || {}, currentAIEmployee: run.leaderUsername };
+    }
+    try {
+      const result = await tool.invoke(ctx, args, `agent-loop-${run.id}-${step.id}`);
+      if ((result == null ? void 0 : result.status) === "error") {
+        throw new Error(result.content || `Tool "${toolName}" returned an error.`);
+      }
+      return {
+        toolName,
+        args,
+        result
+      };
+    } finally {
+      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, _l;
+    const {
+      leaderUsername,
+      subAgentUsername,
+      subAgentEmployee,
+      task,
+      context,
+      maxDepth,
+      timeout,
+      toolCallId,
+      toolName,
+      llmService,
+      model,
+      recursionLimit,
+      rootRunId,
+      parentSpanId,
+      agentLoopRunId,
+      agentLoopStepId
+    } = options;
+    const startTime = Date.now();
+    const currentDepth = options.currentDepth ?? 0;
+    const currentPath = options.currentPath ?? [leaderUsername];
+    const trace = [
+      {
+        type: "start",
+        at: nowIso(),
+        title: `Delegation started: ${leaderUsername} -> ${subAgentUsername}`,
+        content: task
+      }
+    ];
+    const executionSpan = await this.spanService.create({
+      rootRunId: rootRunId || `run_${Date.now()}`,
+      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 = ctx.app.aiManager.toolsManager;
+      const allTools = await coreToolsManager.listTools();
+      const employeeSkills = (((_e = subAgentEmployee.skillSettings) == null ? void 0 : _e.skills) ?? []).map(
+        (s) => typeof s === "string" ? { name: s, autoCall: false } : { name: s == null ? void 0 : s.name, autoCall: (s == null ? void 0 : s.autoCall) === true }
+      ).filter((s) => Boolean(s.name));
+      const employeeSkillMap = new Map(employeeSkills.map((s) => [s.name, s]));
+      const langchainTools = [];
+      for (const toolEntry of allTools) {
+        const entryName = toolEntry.definition.name;
+        if (!entryName) continue;
+        const employeeSkill = employeeSkillMap.get(entryName);
+        if (!employeeSkill || employeeSkill.autoCall !== true || toolEntry.defaultPermission !== "ALLOW") {
+          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: rootRunId || `run_${Date.now()}`,
+                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,
+                spanId: toolSpanId,
+                parentSpanId: executionSpanId,
+                toolCallId: `orch-${toolCallId}`,
+                leaderUsername,
+                employeeUsername: subAgentUsername,
+                toolName: toolEntry.definition.name,
+                agentLoopRunId,
+                agentLoopStepId
+              });
+              trace.push({
+                type: "tool_call",
+                at: nowIso(),
+                title: `Calling tool: ${toolEntry.definition.name}`,
+                toolName: toolEntry.definition.name,
+                args: toolArgs
+              });
+              try {
+                const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
+                const output = trimText((res == null ? void 0 : res.content) ?? (res == null ? void 0 : res.result) ?? res, 5e4);
+                trace.push({
+                  type: "tool_result",
+                  at: nowIso(),
+                  title: `Tool finished: ${toolEntry.definition.name}`,
+                  toolName: toolEntry.definition.name,
+                  status: (res == null ? void 0 : res.status) || "success",
+                  content: trimText(output, 2e3)
+                });
+                if ((res == null ? void 0 : res.status) === "error") {
+                  await this.spanService.finish(toolSpanId, "error", toolStartedAt, {
+                    output,
+                    error: 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: nowIso(),
+                  title: `Tool failed: ${toolEntry.definition.name}`,
+                  toolName: toolEntry.definition.name,
+                  status: "error",
+                  content: e.message
+                });
+                await this.spanService.finish(toolSpanId, "error", toolStartedAt, {
+                  error: trimText(e.message, 1e4)
+                });
+                throw e;
+              }
+            }
+          })
+        );
+      }
+      const abortController = new AbortController();
+      const executor = (0, import_prebuilt.createReactAgent)({
+        llm: chatModel,
+        tools: langchainTools
+      });
+      let systemPrompt = ((_f = subAgentEmployee.chatSettings) == null ? void 0 : _f.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 = ((_i = (_h = (_g = ctx.action) == null ? void 0 : _g.params) == null ? void 0 : _h.values) == null ? void 0 : _i.sessionId) || ((_k = (_j = ctx.action) == null ? void 0 : _j.params) == null ? void 0 : _k.sessionId) || ((_l = ctx.state) == null ? void 0 : _l.sessionId);
+          const contextSummary = await kbPlugin.sessionContext.buildSummary(
+            { rootRunId, ...sessionId ? { sessionId } : {} },
+            6e3
+          );
+          if (contextSummary) {
+            systemPrompt += `
+
+<shared_context>
+The following context was shared by other agents in this workflow:
+${contextSummary}
+</shared_context>`;
+          }
+        }
+      } 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((_, 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 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: nowIso(),
+        title: `Delegation finished: ${subAgentUsername}`,
+        status: "success",
+        content: 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: 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: trimText(e.message, 1e4),
+        metadata: {
+          depth: currentDepth,
+          toolName,
+          recursionLimit,
+          agentLoopRunId,
+          agentLoopStepId
+        }
+      });
+      return {
+        status: "error",
+        content: e.message
+      };
+    }
+  }
+  async logDelegation(ctx, data) {
+    var _a, _b, _c, _d;
+    try {
+      const logsRepo = this.db.getRepository("orchestratorLogs");
+      if (!logsRepo) return null;
+      const 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 values = {
+        leaderUsername: data.leaderUsername,
+        subAgentUsername: data.subAgentUsername,
+        toolName: data.toolName,
+        task: trimText(data.task, 1e4),
+        context: trimText(data.context || "", 1e4),
+        result: trimText(data.result || "", 5e4),
+        status: data.status,
+        depth: data.depth,
+        durationMs: data.durationMs,
+        error: trimText(data.error || "", 1e4),
+        trace: data.trace || [],
+        userId,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (data.id) {
+        await logsRepo.update({
+          filterByTk: data.id,
+          values
+        });
+        return { id: data.id };
+      }
+      const record = await logsRepo.create({
+        values: {
+          ...values,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+      return toPlain(record);
+    } catch {
+      return null;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentHarness
+});