plugin-agent-orchestrator 1.0.20 → 1.0.22

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.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.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.js

@@ -0,0 +1,201 @@
+/**
+ * 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 ContextAggregator_exports = {};
+__export(ContextAggregator_exports, {
+  ContextAggregator: () => ContextAggregator
+});
+module.exports = __toCommonJS(ContextAggregator_exports);
+function trimText(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n...[truncated]";
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+class ContextAggregator {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  get app() {
+    return this.plugin.app;
+  }
+  /**
+   * 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
+   */
+  async buildStepContext(runId, maxTokens, options) {
+    var _a;
+    const effectiveMaxTokens = maxTokens || 4e3;
+    let steps;
+    try {
+      const repo = this.db.getRepository("agentLoopSteps");
+      if (!repo) return "";
+      steps = await repo.find({
+        filter: { runId },
+        sort: ["index", "createdAt"],
+        pageSize: 500
+      });
+    } catch {
+      return "";
+    }
+    if (!steps || steps.length === 0) return "";
+    const completedSteps = steps.filter((s) => s.status === "succeeded" || s.status === "failed");
+    if (completedSteps.length === 0) return "";
+    const config = {
+      strategy: (options == null ? void 0 : options.strategy) || "all",
+      includeToolResults: (options == null ? void 0 : options.includeToolResults) ?? false,
+      includeStepOutputs: (options == null ? void 0 : options.includeStepOutputs) ?? true
+    };
+    let candidates = completedSteps;
+    if (config.strategy === "last_n") {
+      const n = Math.min(10, completedSteps.length);
+      candidates = completedSteps.slice(-n);
+    }
+    const parts = [];
+    for (const step of candidates) {
+      const key = step.planKey || `step_${step.index || 0}`;
+      const type = step.type || "unknown";
+      const target = step.target || "";
+      const title = step.title || key;
+      const status = step.status || "unknown";
+      const lines = [];
+      lines.push(`<step key="${key}" type="${type}" target="${target}" status="${status}">`);
+      lines.push(`  <title>${this.escapeXml(title)}</title>`);
+      if (step.description) {
+        lines.push(`  <description>${this.escapeXml(trimText(step.description, 500))}</description>`);
+      }
+      if (config.includeStepOutputs && step.output) {
+        const outputStr = typeof step.output === "string" ? step.output : this.safeStringify(step.output);
+        lines.push(`  <output>${this.escapeXml(trimText(outputStr, 2e3))}</output>`);
+      }
+      if (config.includeToolResults && ((_a = step.metadata) == null ? void 0 : _a.toolResults)) {
+        const toolStr = this.safeStringify(step.metadata.toolResults);
+        lines.push(`  <tool_results>${this.escapeXml(trimText(toolStr, 1500))}</tool_results>`);
+      }
+      if (step.error) {
+        lines.push(`  <error>${this.escapeXml(trimText(step.error, 1e3))}</error>`);
+      }
+      lines.push("</step>");
+      parts.push(lines.join("\n"));
+    }
+    let context = `<previous_steps>
+${parts.join("\n\n")}
+</previous_steps>`;
+    if (estimateTokens(context) > effectiveMaxTokens) {
+      context = this.truncateToTokenLimit(context, effectiveMaxTokens);
+    }
+    return context;
+  }
+  /**
+   * 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)
+   */
+  async enrichSystemPrompt(basePrompt, runId, _stepId, options) {
+    let run;
+    try {
+      const repo = this.db.getRepository("agentLoopRuns");
+      if (!repo) return basePrompt;
+      run = await repo.findOne({ filter: { id: runId } });
+      if (!run) return basePrompt;
+    } catch {
+      return basePrompt;
+    }
+    const policy = run.policy || {};
+    const maxCtxTokens = (options == null ? void 0 : options.maxContextTokens) ?? policy.maxContextTokens ?? 4e3;
+    const strategy = (options == null ? void 0 : options.contextSummaryStrategy) ?? policy.contextSummaryStrategy ?? "all";
+    const includeToolResults = (options == null ? void 0 : options.includeToolResults) ?? policy.includeToolResults ?? false;
+    const includeStepOutputs = (options == null ? void 0 : options.includeStepOutputs) ?? policy.includeStepOutputs ?? true;
+    const stepContext = await this.buildStepContext(runId, maxCtxTokens, {
+      strategy,
+      includeToolResults,
+      includeStepOutputs
+    });
+    if (!stepContext) return basePrompt;
+    return `${basePrompt}
+
+<previous_steps_context>
+${stepContext}
+</previous_steps_context>`;
+  }
+  truncateToTokenLimit(text, maxTokens) {
+    const outerMatch = text.match(/<previous_steps>\n([\s\S]*)\n<\/previous_steps>/);
+    if (!outerMatch) return text;
+    const inner = outerMatch[1];
+    const stepBlocks = this.splitStepBlocks(inner);
+    if (stepBlocks.length <= 2) {
+      const maxChars2 = maxTokens * 4;
+      if (text.length <= maxChars2) return text;
+      return text.slice(0, maxChars2) + "\n...[truncated]\n</previous_steps>";
+    }
+    const keepFirst = stepBlocks.slice(0, 2);
+    const keepLast = stepBlocks.slice(-2);
+    const removed = stepBlocks.length - keepFirst.length - keepLast.length;
+    const rebuilt = [
+      "<previous_steps>",
+      ...keepFirst,
+      `  <!-- ... ${removed} intermediate step(s) omitted due to context limit ... -->`,
+      ...keepLast,
+      "</previous_steps>"
+    ].join("\n");
+    const maxChars = maxTokens * 4;
+    if (rebuilt.length <= maxChars) return rebuilt;
+    return rebuilt.slice(0, maxChars) + "\n...[truncated]\n</previous_steps>";
+  }
+  splitStepBlocks(text) {
+    const blocks = [];
+    const regex = /<step[\s\S]*?<\/step>/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      blocks.push(match[0]);
+    }
+    return blocks;
+  }
+  escapeXml(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  safeStringify(value) {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextAggregator
+});

package/dist/server/services/ExecutionSpanService.js

@@ -32,11 +32,8 @@ __export(ExecutionSpanService_exports, {
   setOrchestratorTraceContext: () => setOrchestratorTraceContext
 });
 module.exports = __toCommonJS(ExecutionSpanService_exports);
+var import_ctx_utils = require("../utils/ctx-utils");
 const ORCHESTRATOR_TRACE_CONTEXT_KEY = "__orchestratorTraceContext";
-function toPlain(record) {
-  var _a;
-  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
-}
 class ExecutionSpanService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -53,7 +50,7 @@ class ExecutionSpanService {
           createdAt: /* @__PURE__ */ new Date()
         }
       });
-      return toPlain(record);
+      return (0, import_ctx_utils.toPlain)(record);
     } catch (error) {
       (_b = (_a = this.plugin.app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[AgentOrchestrator] Failed to create execution span", error);
       return null;

package/dist/server/services/RunEventBus.js

@@ -0,0 +1,73 @@
+/**
+ * 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 RunEventBus_exports = {};
+__export(RunEventBus_exports, {
+  getRunEventBus: () => getRunEventBus
+});
+module.exports = __toCommonJS(RunEventBus_exports);
+class RunEventBusImpl {
+  listeners = /* @__PURE__ */ new Map();
+  subscribe(runId, callback) {
+    let set = this.listeners.get(runId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(runId, set);
+    }
+    set.add(callback);
+    return () => {
+      set == null ? void 0 : set.delete(callback);
+      if ((set == null ? void 0 : set.size) === 0) {
+        this.listeners.delete(runId);
+      }
+    };
+  }
+  emit(runId, event) {
+    const set = this.listeners.get(runId);
+    if (!set) return;
+    for (const callback of set) {
+      try {
+        callback(event);
+      } catch {
+      }
+    }
+  }
+  listenerCount(runId) {
+    var _a;
+    return ((_a = this.listeners.get(runId)) == null ? void 0 : _a.size) || 0;
+  }
+}
+let instance = null;
+function getRunEventBus() {
+  if (!instance) {
+    instance = new RunEventBusImpl();
+  }
+  return instance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRunEventBus
+});