plugin-agent-orchestrator 1.0.16 → 1.0.18

package/dist/server/services/AgentLoopRepository.d.ts

@@ -0,0 +1,20 @@
+export declare class AgentLoopRepository {
+    private readonly plugin;
+    constructor(plugin: any);
+    get db(): any;
+    getRun(runId: string | number): Promise<any>;
+    requireRun(runId: string | number): Promise<any>;
+    createRun(values: any): Promise<any>;
+    updateRun(runId: string | number, values: any): Promise<void>;
+    getStep(stepId: string | number): Promise<any>;
+    requireStep(stepId: string | number): Promise<any>;
+    createStep(values: any): Promise<any>;
+    updateStep(stepId: string | number, values: any): Promise<void>;
+    getSteps(runId: string | number): Promise<any>;
+    createEvent(values: any): Promise<any>;
+    getEvents(runId: string | number): Promise<any>;
+    getLinkedSpans(runId: string | number, rootRunId?: string): Promise<any>;
+    getLinkedSkillExecutions(runId: string | number, steps: any[]): Promise<any>;
+    lockRun(runId: string | number, lockName: string, durationMs: number): Promise<boolean>;
+    unlockRun(runId: string | number): Promise<void>;
+}

package/dist/server/services/AgentLoopRepository.js

@@ -0,0 +1,210 @@
+/**
+ * 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 AgentLoopRepository_exports = {};
+__export(AgentLoopRepository_exports, {
+  AgentLoopRepository: () => AgentLoopRepository
+});
+module.exports = __toCommonJS(AgentLoopRepository_exports);
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+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;
+}
+class AgentLoopRepository {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  async getRun(runId) {
+    const run = await this.db.getRepository("agentLoopRuns").findOne({
+      filter: { id: runId }
+    });
+    return run ? toPlain(run) : null;
+  }
+  async requireRun(runId) {
+    const run = await this.getRun(runId);
+    if (!run) {
+      throw new Error(`Agent loop run "${runId}" was not found.`);
+    }
+    return run;
+  }
+  async createRun(values) {
+    const run = await this.db.getRepository("agentLoopRuns").create({
+      values
+    });
+    return toPlain(run);
+  }
+  async updateRun(runId, values) {
+    await this.db.getRepository("agentLoopRuns").update({
+      filterByTk: runId,
+      values
+    });
+  }
+  async getStep(stepId) {
+    const step = await this.db.getRepository("agentLoopSteps").findOne({
+      filter: { id: stepId }
+    });
+    return step ? toPlain(step) : null;
+  }
+  async requireStep(stepId) {
+    const step = await this.getStep(stepId);
+    if (!step) {
+      throw new Error(`Agent loop step "${stepId}" was not found.`);
+    }
+    return step;
+  }
+  async createStep(values) {
+    const step = await this.db.getRepository("agentLoopSteps").create({
+      values
+    });
+    return toPlain(step);
+  }
+  async updateStep(stepId, values) {
+    await this.db.getRepository("agentLoopSteps").update({
+      filterByTk: stepId,
+      values
+    });
+  }
+  async getSteps(runId) {
+    const steps = await this.db.getRepository("agentLoopSteps").find({
+      filter: { runId },
+      sort: ["index", "createdAt"],
+      pageSize: 1e3
+    });
+    return steps.map(toPlain);
+  }
+  async createEvent(values) {
+    const record = await this.db.getRepository("agentLoopEvents").create({
+      values: {
+        ...values,
+        content: trimText(values.content || "", 1e4),
+        payload: values.payload || {},
+        createdAt: /* @__PURE__ */ new Date()
+      }
+    });
+    return toPlain(record);
+  }
+  async getEvents(runId) {
+    const events = await this.db.getRepository("agentLoopEvents").find({
+      filter: { runId },
+      sort: ["createdAt"],
+      pageSize: 500
+    });
+    return events.map(toPlain);
+  }
+  async getLinkedSpans(runId, rootRunId) {
+    const repo = this.db.getRepository("agentExecutionSpans");
+    if (!repo) return [];
+    const filters = [];
+    if (rootRunId) filters.push({ rootRunId });
+    filters.push({ "metadata.agentLoopRunId": String(runId) });
+    try {
+      const rows = await repo.find({
+        filter: { $or: filters },
+        sort: ["createdAt"],
+        pageSize: 1e3
+      });
+      return rows.map(toPlain);
+    } catch {
+      if (!rootRunId) return [];
+      const rows = await repo.find({
+        filter: { rootRunId },
+        sort: ["createdAt"],
+        pageSize: 1e3
+      });
+      return rows.map(toPlain);
+    }
+  }
+  async getLinkedSkillExecutions(runId, steps) {
+    const ids = Array.from(
+      new Set(
+        steps.map((step) => step.skillExecutionId).filter(Boolean).map(String)
+      )
+    );
+    const repo = this.db.getRepository("skillExecutions");
+    if (!repo) return [];
+    const filters = [{ agentLoopRunId: String(runId) }];
+    if (ids.length) {
+      filters.push({ id: { $in: ids } });
+    }
+    const rows = await repo.find({
+      filter: { $or: filters },
+      sort: ["createdAt"],
+      pageSize: 1e3
+    });
+    return rows.map(toPlain);
+  }
+  async lockRun(runId, lockName, durationMs) {
+    const repo = this.db.getRepository("agentLoopRuns");
+    if (!repo) return false;
+    const now = /* @__PURE__ */ new Date();
+    const Op = repo.model.sequelize.Sequelize.Op;
+    const result = await repo.model.update(
+      {
+        lockedBy: lockName,
+        lockedUntil: new Date(now.getTime() + durationMs)
+      },
+      {
+        where: {
+          id: runId,
+          [Op.or]: [
+            { lockedBy: null },
+            { lockedUntil: { [Op.lt]: now.toISOString() } },
+            { lockedBy: lockName }
+          ]
+        }
+      }
+    );
+    const affectedCount = Array.isArray(result) ? result[0] : Number(result || 0);
+    return affectedCount > 0;
+  }
+  async unlockRun(runId) {
+    await this.updateRun(runId, {
+      lockedBy: null,
+      lockedUntil: null
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentLoopRepository
+});

package/dist/server/services/AgentLoopService.d.ts

@@ -0,0 +1,149 @@
+import { AgentRegistryService } from './AgentRegistryService';
+import { AgentPlannerService } from './AgentPlannerService';
+import { AgentPlanValidator } from './AgentPlanValidator';
+import { AgentLoopRepository } from './AgentLoopRepository';
+import { AgentHarness } from './AgentHarness';
+import { AgentLoopController } from './AgentLoopController';
+export type AgentLoopRunStatus = 'planning' | 'waiting_plan_approval' | 'approved' | 'running' | 'waiting_user' | 'needs_replan' | 'succeeded' | 'failed' | 'rejected' | 'canceled';
+export type AgentLoopStepStatus = 'pending' | 'running' | 'waiting_user' | 'succeeded' | 'failed' | 'skipped';
+export type AgentLoopStepType = 'reasoning' | 'skill' | 'tool' | 'sub_agent' | 'verification';
+export type AgentLoopStepDependencyPolicy = 'require_success' | 'allow_skipped';
+export type AgentLoopPolicy = {
+    maxIterations: number;
+    maxStepAttempts: number;
+    allowReplan: boolean;
+    requireVerification: boolean;
+    stopOnApprovalRequired: boolean;
+};
+export type AgentLoopPlanStepInput = {
+    id?: string;
+    key?: string;
+    planKey?: string;
+    parentStepId?: string | number;
+    title?: string;
+    description?: string;
+    type?: AgentLoopStepType;
+    target?: string;
+    input?: any;
+    dependsOn?: string[];
+    dependencyPolicy?: AgentLoopStepDependencyPolicy;
+    maxAttempts?: number;
+    metadata?: any;
+};
+export declare class AgentLoopService {
+    private readonly plugin;
+    readonly registryService: AgentRegistryService;
+    readonly plannerService: AgentPlannerService;
+    readonly validator: AgentPlanValidator;
+    readonly repository: AgentLoopRepository;
+    readonly harness: AgentHarness;
+    readonly controller: AgentLoopController;
+    constructor(plugin: any);
+    get db(): any;
+    get app(): any;
+    createRun(options: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    planGoal(options: any): Promise<{
+        events: any;
+        spans: any;
+        skillExecutions: any;
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    revisePlanGoal(runId: any, plan: any, options?: any): Promise<{
+        events: any;
+        spans: any;
+        skillExecutions: any;
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    approvePlanAndExecute(runId: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    rejectPlan(runId: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    requestPlanChanges(runId: any, options?: any): Promise<{
+        events: any;
+        spans: any;
+        skillExecutions: any;
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    replacePlan(runId: any, plan: any, options?: any): Promise<any[]>;
+    replan(runId: any, plan: any, options?: any): Promise<any[]>;
+    startStep(stepId: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    completeStep(stepId: any, output: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    failStep(stepId: any, error: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    skipStep(stepId: any, reason?: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    requestApproval(stepId: any, approval: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    resumeRun(runId: any, options: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    retryStep(stepId: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    finishRun(runId: any, finalAnswer: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    cancelRun(runId: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    executeApprovedPlan(runId: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    getRunSnapshot(runId: any): Promise<{
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    getRunDetail(runId: any): Promise<{
+        events: any;
+        spans: any;
+        skillExecutions: any;
+        run: any;
+        steps: any;
+        nextStep: any;
+    }>;
+    createEvent(values: any): Promise<any>;
+}

package/dist/server/services/AgentLoopService.js

@@ -0,0 +1,133 @@
+/**
+ * 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 AgentLoopService_exports = {};
+__export(AgentLoopService_exports, {
+  AgentLoopService: () => AgentLoopService
+});
+module.exports = __toCommonJS(AgentLoopService_exports);
+var import_AgentRegistryService = require("./AgentRegistryService");
+var import_AgentPlannerService = require("./AgentPlannerService");
+var import_AgentPlanValidator = require("./AgentPlanValidator");
+var import_AgentLoopRepository = require("./AgentLoopRepository");
+var import_AgentHarness = require("./AgentHarness");
+var import_AgentLoopController = require("./AgentLoopController");
+class AgentLoopService {
+  constructor(plugin) {
+    this.plugin = plugin;
+    this.registryService = new import_AgentRegistryService.AgentRegistryService(plugin);
+    this.plannerService = new import_AgentPlannerService.AgentPlannerService();
+    this.validator = new import_AgentPlanValidator.AgentPlanValidator();
+    this.repository = new import_AgentLoopRepository.AgentLoopRepository(plugin);
+    this.harness = new import_AgentHarness.AgentHarness(plugin, this.registryService);
+    this.controller = new import_AgentLoopController.AgentLoopController(
+      this.registryService,
+      this.plannerService,
+      this.validator,
+      this.repository,
+      this.harness
+    );
+  }
+  registryService;
+  plannerService;
+  validator;
+  repository;
+  harness;
+  controller;
+  get db() {
+    return this.plugin.db;
+  }
+  get app() {
+    return this.plugin.app;
+  }
+  async createRun(options) {
+    return this.controller.createRun(options);
+  }
+  async planGoal(options) {
+    return this.controller.planGoal(options);
+  }
+  async revisePlanGoal(runId, plan, options = {}) {
+    return this.controller.revisePlanGoal(runId, plan, options);
+  }
+  async approvePlanAndExecute(runId, options = {}) {
+    return this.controller.approvePlanAndExecute(runId, options);
+  }
+  async rejectPlan(runId, options = {}) {
+    return this.controller.rejectPlan(runId, options);
+  }
+  async requestPlanChanges(runId, options = {}) {
+    return this.controller.requestPlanChanges(runId, options);
+  }
+  async replacePlan(runId, plan, options = {}) {
+    return this.controller.replacePlan(runId, plan, options);
+  }
+  async replan(runId, plan, options = {}) {
+    return this.controller.replan(runId, plan, options);
+  }
+  async startStep(stepId, options = {}) {
+    return this.controller.startStep(stepId, options);
+  }
+  async completeStep(stepId, output, options = {}) {
+    return this.controller.completeStep(stepId, output, options);
+  }
+  async failStep(stepId, error, options = {}) {
+    return this.controller.failStep(stepId, error, options);
+  }
+  async skipStep(stepId, reason = "Skipped", options = {}) {
+    return this.controller.skipStep(stepId, reason, options);
+  }
+  async requestApproval(stepId, approval, options = {}) {
+    return this.controller.requestApproval(stepId, approval, options);
+  }
+  async resumeRun(runId, options) {
+    return this.controller.resumeRun(runId, options);
+  }
+  async retryStep(stepId, options = {}) {
+    return this.controller.retryStep(stepId, options);
+  }
+  async finishRun(runId, finalAnswer, options = {}) {
+    return this.controller.finishRun(runId, finalAnswer, options);
+  }
+  async cancelRun(runId, options = {}) {
+    return this.controller.cancelRun(runId, options);
+  }
+  async executeApprovedPlan(runId, options = {}) {
+    return this.controller.executeApprovedPlan(runId, options);
+  }
+  async getRunSnapshot(runId) {
+    return this.controller.getRunSnapshot(runId);
+  }
+  async getRunDetail(runId) {
+    return this.controller.getRunDetail(runId);
+  }
+  async createEvent(values) {
+    return this.repository.createEvent(values);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentLoopService
+});

package/dist/server/services/AgentPlanValidator.d.ts

@@ -0,0 +1,4 @@
+import { AgentLoopPlanStepInput } from './AgentLoopService';
+export declare class AgentPlanValidator {
+    validate(plan: AgentLoopPlanStepInput[]): void;
+}

package/dist/server/services/AgentPlanValidator.js

@@ -0,0 +1,99 @@
+/**
+ * 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 AgentPlanValidator_exports = {};
+__export(AgentPlanValidator_exports, {
+  AgentPlanValidator: () => AgentPlanValidator
+});
+module.exports = __toCommonJS(AgentPlanValidator_exports);
+function normalizeStepType(value) {
+  return ["reasoning", "skill", "tool", "sub_agent", "verification"].includes(value) ? value : "tool";
+}
+function normalizePlanKey(step, index) {
+  return String(step.planKey || step.key || step.id || `step_${index + 1}`);
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+const ORCHESTRATOR_CONTROLLER_MAX_STEPS = 100;
+class AgentPlanValidator {
+  validate(plan) {
+    if (!Array.isArray(plan) || plan.length === 0) {
+      throw new Error("Plan must include at least one step.");
+    }
+    if (plan.length > ORCHESTRATOR_CONTROLLER_MAX_STEPS) {
+      throw new Error(`Plan cannot exceed ${ORCHESTRATOR_CONTROLLER_MAX_STEPS} steps.`);
+    }
+    const keys = /* @__PURE__ */ new Set();
+    const graph = /* @__PURE__ */ new Map();
+    for (let i = 0; i < plan.length; i++) {
+      const key = normalizePlanKey(plan[i], i).trim();
+      if (!key) {
+        throw new Error(`Plan step ${i + 1} has an empty planKey.`);
+      }
+      if (keys.has(key)) {
+        throw new Error(`Duplicate planKey "${key}" in plan.`);
+      }
+      const type = normalizeStepType(plan[i].type);
+      if (["tool", "skill", "sub_agent"].includes(type) && !plan[i].target) {
+        throw new Error(`Step "${key}" of type "${type}" must include a target.`);
+      }
+      keys.add(key);
+      graph.set(key, asArray(plan[i].dependsOn).map(String));
+    }
+    for (const [key, dependencies] of graph.entries()) {
+      for (const dependency of dependencies) {
+        if (!keys.has(dependency)) {
+          throw new Error(`Step "${key}" depends on unknown step "${dependency}".`);
+        }
+        if (dependency === key) {
+          throw new Error(`Step "${key}" cannot depend on itself.`);
+        }
+      }
+    }
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (key) => {
+      if (visited.has(key)) return;
+      if (visiting.has(key)) {
+        throw new Error(`Plan has a dependency cycle at "${key}".`);
+      }
+      visiting.add(key);
+      for (const dependency of graph.get(key) || []) {
+        visit(dependency);
+      }
+      visiting.delete(key);
+      visited.add(key);
+    };
+    for (const key of graph.keys()) {
+      visit(key);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentPlanValidator
+});

package/dist/server/services/AgentPlannerService.d.ts

@@ -0,0 +1,8 @@
+import { AgentLoopPlanStepInput } from './AgentLoopService';
+export declare class AgentPlannerService {
+    buildPlan(goal: string, plan: AgentLoopPlanStepInput[] | undefined, options: {
+        targetAgent?: string;
+        harnessTag?: string;
+        metadata?: any;
+    }): AgentLoopPlanStepInput[];
+}