plugin-agent-orchestrator 1.0.20 → 1.0.21

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

@@ -14,6 +14,11 @@ export type AgentLoopPolicy = {
     allowReplan: boolean;
     requireVerification: boolean;
     stopOnApprovalRequired: boolean;
+    maxContextTokens?: number;
+    contextSummaryStrategy?: 'last_n' | 'all';
+    includeToolResults?: boolean;
+    includeStepOutputs?: boolean;
+    maxConcurrency?: number;
 };
 export type AgentLoopPlanStepInput = {
     id?: string;
@@ -44,7 +49,7 @@ export declare class AgentLoopService {
     createRun(options: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     planGoal(options: any): Promise<{
         events: any;
@@ -52,7 +57,7 @@ export declare class AgentLoopService {
         skillExecutions: any;
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     revisePlanGoal(runId: any, plan: any, options?: any): Promise<{
         events: any;
@@ -60,17 +65,17 @@ export declare class AgentLoopService {
         skillExecutions: any;
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     approvePlanAndExecute(runId: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     rejectPlan(runId: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     requestPlanChanges(runId: any, options?: any): Promise<{
         events: any;
@@ -78,64 +83,69 @@ export declare class AgentLoopService {
         skillExecutions: any;
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: 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;
+        nextSteps: any[];
     }>;
     completeStep(stepId: any, output: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     failStep(stepId: any, error: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     skipStep(stepId: any, reason?: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     requestApproval(stepId: any, approval: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     resumeRun(runId: any, options: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     retryStep(stepId: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
+    }>;
+    stepFeedback(stepId: any, feedback: any, options?: any): Promise<{
+        run: any;
+        steps: any;
+        nextSteps: any[];
     }>;
     finishRun(runId: any, finalAnswer: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     cancelRun(runId: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     executeApprovedPlan(runId: any, options?: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     getRunSnapshot(runId: any): Promise<{
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     getRunDetail(runId: any): Promise<{
         events: any;
@@ -143,7 +153,7 @@ export declare class AgentLoopService {
         skillExecutions: any;
         run: any;
         steps: any;
-        nextStep: any;
+        nextSteps: any[];
     }>;
     createEvent(values: any): Promise<any>;
 }

package/dist/server/services/AgentLoopService.js

@@ -35,6 +35,7 @@ var import_AgentPlanValidator = require("./AgentPlanValidator");
 var import_AgentLoopRepository = require("./AgentLoopRepository");
 var import_AgentHarness = require("./AgentHarness");
 var import_AgentLoopController = require("./AgentLoopController");
+var import_TokenTracker = require("./TokenTracker");
 class AgentLoopService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -43,12 +44,14 @@ class AgentLoopService {
     this.validator = new import_AgentPlanValidator.AgentPlanValidator();
     this.repository = new import_AgentLoopRepository.AgentLoopRepository(plugin);
     this.harness = new import_AgentHarness.AgentHarness(plugin, this.registryService);
+    const tokenTracker = new import_TokenTracker.TokenTracker(plugin);
     this.controller = new import_AgentLoopController.AgentLoopController(
       this.registryService,
       this.plannerService,
       this.validator,
       this.repository,
-      this.harness
+      this.harness,
+      tokenTracker
     );
   }
   registryService;
@@ -108,6 +111,9 @@ class AgentLoopService {
   async retryStep(stepId, options = {}) {
     return this.controller.retryStep(stepId, options);
   }
+  async stepFeedback(stepId, feedback, options = {}) {
+    return this.controller.stepFeedback(stepId, feedback, options);
+  }
   async finishRun(runId, finalAnswer, options = {}) {
     return this.controller.finishRun(runId, finalAnswer, options);
   }

package/dist/server/services/AgentPlannerService.js

@@ -29,27 +29,7 @@ __export(AgentPlannerService_exports, {
   AgentPlannerService: () => AgentPlannerService
 });
 module.exports = __toCommonJS(AgentPlannerService_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 : [];
-}
-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 {};
-}
+var import_ctx_utils = require("../utils/ctx-utils");
 class AgentPlannerService {
   buildPlan(goal, plan, options) {
     var _a;
@@ -58,11 +38,11 @@ class AgentPlannerService {
         var _a2;
         return {
           ...step,
-          planKey: normalizePlanKey(step, index),
-          type: normalizeStepType(step.type),
-          dependsOn: asArray(step.dependsOn).map(String),
+          planKey: (0, import_ctx_utils.normalizePlanKey)(step, index),
+          type: (0, import_ctx_utils.normalizeStepType)(step.type),
+          dependsOn: (0, import_ctx_utils.asArray)(step.dependsOn).map(String),
           metadata: {
-            ...asObject(step.metadata),
+            ...(0, import_ctx_utils.asObject)(step.metadata),
             harnessTag: options.harnessTag || ((_a2 = options.metadata) == null ? void 0 : _a2.harnessTag) || "default"
           }
         };

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

@@ -9,5 +9,13 @@ export declare class AgentRegistryService {
         llmService: string;
         model: string;
     }>;
+    /**
+     * Find alternative sub-agents for the same leader, excluding a specific one.
+     * Used by the smart retry feature to route around a failing sub-agent.
+     */
+    findAlternativeSubAgents(leaderUsername: string, excludeSubAgentUsername: string): Promise<{
+        username: string;
+        label: string;
+    }[]>;
     isRegisteredDelegationTool(toolName: string): Promise<boolean>;
 }

package/dist/server/services/AgentRegistryService.js

@@ -29,27 +29,7 @@ __export(AgentRegistryService_exports, {
   AgentRegistryService: () => AgentRegistryService
 });
 module.exports = __toCommonJS(AgentRegistryService_exports);
-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 normalizeEmployeeUsername(raw) {
-  if (!raw) return null;
-  if (typeof raw === "string") return raw;
-  return raw.username || raw.aiEmployeeUsername || raw.name || null;
-}
+var import_ctx_utils = require("../utils/ctx-utils");
 class AgentRegistryService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -67,7 +47,7 @@ class AgentRegistryService {
           enabled: true
         }
       });
-      return profile ? toPlain(profile) : null;
+      return profile ? (0, import_ctx_utils.toPlain)(profile) : null;
     } catch {
       return null;
     }
@@ -83,7 +63,7 @@ class AgentRegistryService {
           enabled: true
         }
       });
-      return config ? toPlain(config) : null;
+      return config ? (0, import_ctx_utils.toPlain)(config) : null;
     } catch {
       return null;
     }
@@ -95,7 +75,7 @@ class AgentRegistryService {
       const employee = await repo.findOne({
         filter: { username }
       });
-      return employee ? toPlain(employee) : null;
+      return employee ? (0, import_ctx_utils.toPlain)(employee) : null;
     } catch {
       return null;
     }
@@ -122,6 +102,36 @@ class AgentRegistryService {
     }
     return modelSettings;
   }
+  /**
+   * Find alternative sub-agents for the same leader, excluding a specific one.
+   * Used by the smart retry feature to route around a failing sub-agent.
+   */
+  async findAlternativeSubAgents(leaderUsername, excludeSubAgentUsername) {
+    try {
+      const repo = this.db.getRepository("orchestratorConfig");
+      if (!repo) return [];
+      const configs = await repo.find({
+        filter: {
+          leaderUsername,
+          enabled: true,
+          subAgentUsername: { $ne: excludeSubAgentUsername }
+        }
+      });
+      if (!configs || configs.length === 0) return [];
+      const result = [];
+      for (const config of configs) {
+        const plain = (0, import_ctx_utils.toPlain)(config);
+        const employee = await this.getAIEmployee(plain.subAgentUsername);
+        result.push({
+          username: plain.subAgentUsername,
+          label: (employee == null ? void 0 : employee.nickname) || (employee == null ? void 0 : employee.username) || plain.subAgentUsername
+        });
+      }
+      return result;
+    } catch {
+      return [];
+    }
+  }
   async isRegisteredDelegationTool(toolName) {
     if (!toolName || typeof toolName !== "string") return false;
     if (!toolName.startsWith("delegate_") && !toolName.startsWith("dispatch_subagents_")) {

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

@@ -0,0 +1,40 @@
+export interface CircuitState {
+    failures: number;
+    lastFailureTime: number;
+    state: 'closed' | 'open' | 'half-open';
+}
+/**
+ * CircuitBreakerRegistry — prevents cascading failures by tracking per-key
+ * failure rates and temporarily stopping calls when thresholds are exceeded.
+ *
+ * State machine: closed → open (after threshold failures) → half-open (after recoveryTimeout)
+ * half-open: allows 1 probe request; success → closed, failure → open.
+ */
+export declare class CircuitBreakerRegistry {
+    private readonly circuits;
+    readonly threshold: number;
+    readonly recoveryTimeout: number;
+    readonly halfOpenMaxRequests: number;
+    private readonly appLog;
+    constructor(options?: {
+        threshold?: number;
+        recoveryTimeout?: number;
+        halfOpenMaxRequests?: number;
+        appLog?: any;
+    });
+    private getOrCreate;
+    recordSuccess(key: string): void;
+    recordFailure(key: string): void;
+    isAllowed(key: string): boolean;
+    getState(key: string): CircuitState | null;
+    /** Reset a circuit back to closed state. */
+    reset(key: string): void;
+    /** Get all circuit state keys (for monitoring/diagnostics). */
+    getKeys(): string[];
+}
+export declare function getCircuitBreaker(options?: {
+    threshold?: number;
+    recoveryTimeout?: number;
+    halfOpenMaxRequests?: number;
+    appLog?: any;
+}): CircuitBreakerRegistry;

package/dist/server/services/CircuitBreaker.js

@@ -0,0 +1,120 @@
+/**
+ * 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 CircuitBreaker_exports = {};
+__export(CircuitBreaker_exports, {
+  CircuitBreakerRegistry: () => CircuitBreakerRegistry,
+  getCircuitBreaker: () => getCircuitBreaker
+});
+module.exports = __toCommonJS(CircuitBreaker_exports);
+class CircuitBreakerRegistry {
+  circuits = /* @__PURE__ */ new Map();
+  threshold;
+  recoveryTimeout;
+  halfOpenMaxRequests;
+  appLog;
+  constructor(options) {
+    this.threshold = (options == null ? void 0 : options.threshold) ?? 3;
+    this.recoveryTimeout = (options == null ? void 0 : options.recoveryTimeout) ?? 3e4;
+    this.halfOpenMaxRequests = (options == null ? void 0 : options.halfOpenMaxRequests) ?? 1;
+    this.appLog = options == null ? void 0 : options.appLog;
+  }
+  getOrCreate(key) {
+    let state = this.circuits.get(key);
+    if (!state) {
+      state = { failures: 0, lastFailureTime: 0, state: "closed" };
+      this.circuits.set(key, state);
+    }
+    return state;
+  }
+  recordSuccess(key) {
+    var _a, _b;
+    const state = this.getOrCreate(key);
+    if (state.state === "half-open") {
+      state.state = "closed";
+      state.failures = 0;
+      (_b = (_a = this.appLog) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, `[CircuitBreaker] "${key}" recovered \u2192 closed`);
+    } else if (state.state === "closed" && state.failures > 0) {
+      state.failures = Math.max(0, state.failures - 1);
+    }
+  }
+  recordFailure(key) {
+    var _a, _b, _c, _d;
+    const state = this.getOrCreate(key);
+    state.failures += 1;
+    state.lastFailureTime = Date.now();
+    if (state.state === "half-open") {
+      state.state = "open";
+      (_b = (_a = this.appLog) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `[CircuitBreaker] "${key}" half-open probe failed \u2192 open`);
+    } else if (state.state === "closed" && state.failures >= this.threshold) {
+      state.state = "open";
+      (_d = (_c = this.appLog) == null ? void 0 : _c.warn) == null ? void 0 : _d.call(_c, `[CircuitBreaker] "${key}" opened after ${state.failures} failures`);
+    }
+  }
+  isAllowed(key) {
+    var _a, _b;
+    const state = this.getOrCreate(key);
+    if (state.state === "closed") return true;
+    if (state.state === "open") {
+      const elapsed = Date.now() - state.lastFailureTime;
+      if (elapsed >= this.recoveryTimeout) {
+        state.state = "half-open";
+        (_b = (_a = this.appLog) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, `[CircuitBreaker] "${key}" open timeout elapsed \u2192 half-open`);
+        return true;
+      }
+      return false;
+    }
+    return this.halfOpenMaxRequests > 0;
+  }
+  getState(key) {
+    return this.circuits.get(key) ?? null;
+  }
+  /** Reset a circuit back to closed state. */
+  reset(key) {
+    const state = this.circuits.get(key);
+    if (state) {
+      state.state = "closed";
+      state.failures = 0;
+      state.lastFailureTime = 0;
+    }
+  }
+  /** Get all circuit state keys (for monitoring/diagnostics). */
+  getKeys() {
+    return Array.from(this.circuits.keys());
+  }
+}
+let globalInstance = null;
+function getCircuitBreaker(options) {
+  if (!globalInstance) {
+    globalInstance = new CircuitBreakerRegistry(options);
+  }
+  return globalInstance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CircuitBreakerRegistry,
+  getCircuitBreaker
+});

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

@@ -0,0 +1,45 @@
+/**
+ * ContextAggregator — builds structured step context for sub-agent system prompts.
+ *
+ * Responsibilities:
+ * 1. Query completed steps of a run
+ * 2. Format them as structured XML context
+ * 3. Apply truncation/summarization based on policy
+ * 4. Inject into sub-agent system prompt
+ */
+export declare class ContextAggregator {
+    private readonly plugin;
+    constructor(plugin: any);
+    get db(): any;
+    get app(): any;
+    /**
+     * Build a structured context string from completed steps of a run.
+     *
+     * @param runId - agentLoopRuns.id
+     * @param maxTokens - Maximum tokens for the context output (default 4000)
+     * @param options - Strategy options
+     */
+    buildStepContext(runId: string | number, maxTokens?: number, options?: {
+        strategy?: 'last_n' | 'all';
+        includeToolResults?: boolean;
+        includeStepOutputs?: boolean;
+    }): Promise<string>;
+    /**
+     * Enrich a base system prompt with step context from the run.
+     * Fetches the run from DB to access policy settings (maxContextTokens, etc.).
+     *
+     * @param basePrompt - The original system prompt to enrich
+     * @param runId - agentLoopRuns.id
+     * @param _stepId - agentLoopSteps.id (reserved for future per-step context)
+     */
+    enrichSystemPrompt(basePrompt: string, runId: string | number, _stepId?: string | number, options?: {
+        maxContextTokens?: number;
+        contextSummaryStrategy?: 'last_n' | 'all';
+        includeToolResults?: boolean;
+        includeStepOutputs?: boolean;
+    }): Promise<string>;
+    private truncateToTokenLimit;
+    private splitStepBlocks;
+    private escapeXml;
+    private safeStringify;
+}