plugin-agent-orchestrator 1.0.17 → 1.0.19

package/dist/server/tools/orchestrator-plan.js

@@ -0,0 +1,291 @@
+/**
+ * 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 orchestrator_plan_exports = {};
+__export(orchestrator_plan_exports, {
+  createOrchestratorPlanTools: () => createOrchestratorPlanTools
+});
+module.exports = __toCommonJS(orchestrator_plan_exports);
+var import_zod = require("zod");
+const stepSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  key: import_zod.z.string().optional(),
+  planKey: import_zod.z.string().optional(),
+  parentStepId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+  title: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  type: import_zod.z.enum(["reasoning", "skill", "tool", "sub_agent", "verification"]).optional(),
+  target: import_zod.z.string().optional(),
+  input: import_zod.z.any().optional(),
+  dependsOn: import_zod.z.array(import_zod.z.string()).optional(),
+  dependencyPolicy: import_zod.z.enum(["require_success", "allow_skipped"]).optional(),
+  maxAttempts: import_zod.z.number().int().min(1).max(10).optional(),
+  metadata: import_zod.z.any().optional()
+});
+const policySchema = import_zod.z.object({
+  maxIterations: import_zod.z.number().int().min(1).max(100).optional(),
+  maxStepAttempts: import_zod.z.number().int().min(1).max(10).optional(),
+  allowReplan: import_zod.z.boolean().optional(),
+  requireVerification: import_zod.z.boolean().optional(),
+  stopOnApprovalRequired: import_zod.z.boolean().optional()
+}).optional();
+function toolResult(status, payload) {
+  return {
+    status,
+    content: typeof payload === "string" ? payload : JSON.stringify(payload)
+  };
+}
+function valuesFromCtx(ctx) {
+  var _a, _b, _c;
+  return ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) || ((_c = ctx == null ? void 0 : ctx.request) == null ? void 0 : _c.body) || {};
+}
+function currentUserId(ctx) {
+  var _a, _b, _c, _d;
+  return ((_b = (_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentUser) == null ? void 0 : _b.id) || ((_d = (_c = ctx == null ? void 0 : ctx.auth) == null ? void 0 : _c.user) == null ? void 0 : _d.id);
+}
+function resolveSessionId(ctx, args) {
+  var _a, _b, _c;
+  const values = valuesFromCtx(ctx);
+  return (args == null ? void 0 : args.sessionId) || values.sessionId || ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.sessionId) || ((_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.sessionId);
+}
+function resolveMessageId(ctx, args) {
+  var _a, _b;
+  const values = valuesFromCtx(ctx);
+  return (args == null ? void 0 : args.messageId) || values.messageId || ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.messageId);
+}
+function normalizeEmployeeUsername(raw) {
+  if (!raw) return null;
+  if (typeof raw === "string") return raw;
+  return raw.username || raw.aiEmployeeUsername || raw.name || null;
+}
+async function resolveLeaderUsername(ctx, plugin, args) {
+  var _a, _b, _c, _d, _e, _f;
+  const values = valuesFromCtx(ctx);
+  const direct = normalizeEmployeeUsername(
+    (args == null ? void 0 : args.leaderUsername) || (ctx == null ? void 0 : ctx._currentAIEmployee) || ((_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentAIEmployee) || ((_c = (_b = ctx == null ? void 0 : ctx.runtime) == null ? void 0 : _b.context) == null ? void 0 : _c.currentAIEmployee) || values.aiEmployee
+  );
+  if (direct) return direct;
+  const sessionId = resolveSessionId(ctx, args);
+  if (!sessionId) return void 0;
+  try {
+    const repo = ((_e = (_d = ctx == null ? void 0 : ctx.db) == null ? void 0 : _d.getRepository) == null ? void 0 : _e.call(_d, "aiConversations")) || plugin.db.getRepository("aiConversations");
+    const conversation = await repo.findOne({ filter: { sessionId } });
+    return normalizeEmployeeUsername((conversation == null ? void 0 : conversation.aiEmployeeUsername) || ((_f = conversation == null ? void 0 : conversation.get) == null ? void 0 : _f.call(conversation, "aiEmployeeUsername")));
+  } catch {
+    return void 0;
+  }
+}
+function summarizePlan(steps) {
+  return (steps || []).map((step) => ({
+    id: step.id,
+    planKey: step.planKey,
+    title: step.title,
+    description: step.description,
+    type: step.type,
+    target: step.target,
+    dependsOn: step.dependsOn || [],
+    status: step.status
+  }));
+}
+function inferTargetAgent(args) {
+  if (args == null ? void 0 : args.targetAgent) return args.targetAgent;
+  const plan = Array.isArray(args == null ? void 0 : args.plan) ? args.plan : [];
+  const subAgentStep = plan.find((step) => (step == null ? void 0 : step.type) === "sub_agent" && (step == null ? void 0 : step.target));
+  return subAgentStep == null ? void 0 : subAgentStep.target;
+}
+async function resolveHarnessTag(plugin, leaderUsername, targetAgent, args) {
+  var _a, _b;
+  const direct = String((args == null ? void 0 : args.harnessTag) || ((_a = args == null ? void 0 : args.metadata) == null ? void 0 : _a.harnessTag) || "").trim();
+  if (direct) return direct;
+  if (!leaderUsername || !targetAgent) return "default";
+  try {
+    const repo = plugin.db.getRepository("orchestratorConfig");
+    const config = await repo.findOne({
+      filter: {
+        leaderUsername,
+        subAgentUsername: targetAgent,
+        enabled: true
+      }
+    });
+    return (config == null ? void 0 : config.harnessTag) || ((_b = config == null ? void 0 : config.get) == null ? void 0 : _b.call(config, "harnessTag")) || "default";
+  } catch {
+    return "default";
+  }
+}
+function createOrchestratorPlanTools(plugin, service) {
+  return [
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Orchestrator - Plan Goal",
+        about: "Create a draft plan and pause for explicit user approval before execution."
+      },
+      definition: {
+        name: "orchestrator_plan_goal",
+        description: "Create or revise a persistent orchestrator run in waiting_plan_approval state. Use this before any multi-step/sub-agent execution. Provide a concrete plan with small executable steps and stable planKey dependencies whenever possible. Pass runId only when revising after user-requested changes. This tool does not execute the plan.",
+        schema: import_zod.z.object({
+          goal: import_zod.z.string().min(1).describe("The user goal to complete."),
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional().describe("Existing run id to revise after the user requested plan changes. Omit for a new run."),
+          leaderUsername: import_zod.z.string().optional().describe("Leader AI employee username. Usually omit; inferred from chat."),
+          sessionId: import_zod.z.string().optional(),
+          messageId: import_zod.z.string().optional(),
+          harnessTag: import_zod.z.string().optional().default("default").describe("Harness profile tag, for example default, safe, or file-heavy."),
+          targetAgent: import_zod.z.string().optional().describe("Optional sub-agent username for generated fallback plans."),
+          plannerModel: import_zod.z.string().optional(),
+          policy: policySchema,
+          metadata: import_zod.z.any().optional(),
+          plan: import_zod.z.array(stepSchema).optional().describe("Draft plan steps. Tool/sub_agent steps should include target. Dependencies must reference planKey values.")
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const leaderUsername = await resolveLeaderUsername(ctx, plugin, args);
+          const targetAgent = inferTargetAgent(args);
+          const harnessTag = await resolveHarnessTag(plugin, leaderUsername, targetAgent, args);
+          const detail = await service.planGoal({
+            goal: args.goal,
+            runId: args.runId,
+            leaderUsername,
+            sessionId: resolveSessionId(ctx, args),
+            messageId: resolveMessageId(ctx, args),
+            userId: currentUserId(ctx),
+            policy: args.policy,
+            metadata: args.metadata,
+            plan: Array.isArray(args.plan) ? args.plan : void 0,
+            plannerModel: args.plannerModel,
+            harnessTag,
+            targetAgent
+          });
+          return toolResult("success", {
+            run: detail.run,
+            plan: summarizePlan(detail.steps),
+            approval: {
+              required: true,
+              nextTool: "orchestrator_execute_plan",
+              args: {
+                runId: detail.run.id,
+                planVersion: detail.run.planVersion || 1,
+                plan: summarizePlan(detail.steps)
+              }
+            }
+          });
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ASK",
+      introduction: {
+        title: "Orchestrator - Execute Approved Plan",
+        about: "Execute a draft plan only after the user approves the plan card."
+      },
+      definition: {
+        name: "orchestrator_execute_plan",
+        description: "Execute a run created by orchestrator_plan_goal. This tool must be called with the runId after the user reviews the plan. The UI will ask the user to accept or reject the plan before invoke runs.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).describe("The agentLoopRuns id returned by orchestrator_plan_goal."),
+          planVersion: import_zod.z.number().int().optional(),
+          plan: import_zod.z.array(stepSchema).optional().describe("Optional copy of the displayed plan for the approval UI."),
+          reason: import_zod.z.string().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const detail = await service.approvePlanAndExecute(args.runId, {
+            userId: currentUserId(ctx),
+            ctx,
+            reason: args.reason
+          });
+          return toolResult("success", detail);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Orchestrator - Status",
+        about: "Read a run, its plan steps, events, and linked traces."
+      },
+      definition: {
+        name: "orchestrator_status",
+        description: "Read the current status of an orchestrator run without mutating it.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
+        })
+      },
+      invoke: async (_ctx, args) => {
+        try {
+          return toolResult("success", await service.getRunDetail(args.runId));
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ASK",
+      introduction: {
+        title: "Orchestrator - Cancel Run",
+        about: "Cancel an orchestrator run with user approval."
+      },
+      definition: {
+        name: "orchestrator_cancel",
+        description: "Cancel an orchestrator run. This mutates run state and therefore requires user approval.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          reason: import_zod.z.string().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          return toolResult(
+            "success",
+            await service.cancelRun(args.runId, {
+              reason: args.reason,
+              userId: currentUserId(ctx)
+            })
+          );
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createOrchestratorPlanTools
+});

package/dist/server/tools/skill-execute.d.ts

@@ -0,0 +1,36 @@
+export declare function createSkillExecuteTool(plugin: any): {
+    scope: string;
+    execution: string;
+    defaultPermission: string;
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                skillName: {
+                    type: string;
+                    description: string;
+                };
+                input: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    invoke(ctx: any, args: Record<string, any>, _id?: string): Promise<{
+        status: string;
+        content: string;
+    }>;
+};

package/dist/server/tools/skill-execute.js

@@ -143,6 +143,8 @@ IMPORTANT: If the skill returns file download URLs, you MUST format them as clic
               stderr: result.stderr,
               files: result.files,
               execId: result.execId,
+              agentLoopRunId: result.agentLoopRunId,
+              agentLoopStepId: result.agentLoopStepId,
               durationMs: result.durationMs
             })
           };

package/package.json

@@ -4,7 +4,7 @@
   "displayName.zh-CN": "代理协调器",
   "displayName.vi-VN": "Điều phối Agent",
   "description": "Hierarchical Multi-Agent orchestration for NocoBase AI Employees. Enables Leader agents to delegate tasks to Sub-Agent employees without modifying core plugin-ai.",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "license": "Apache-2.0",
   "main": "dist/server/index.js",
   "keywords": [