plugin-agent-orchestrator 1.0.16 → 1.0.18

package/dist/server/collections/skill-loop-configs.d.ts

@@ -0,0 +1,3 @@
+import { CollectionOptions } from '@nocobase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/dist/server/collections/skill-loop-configs.js

@@ -0,0 +1,94 @@
+/**
+ * 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 skill_loop_configs_exports = {};
+__export(skill_loop_configs_exports, {
+  default: () => skill_loop_configs_default
+});
+module.exports = __toCommonJS(skill_loop_configs_exports);
+var skill_loop_configs_default = {
+  name: "skillLoopConfigs",
+  title: "Skill Loop Configs",
+  fields: [
+    {
+      name: "id",
+      type: "bigInt",
+      autoIncrement: true,
+      primaryKey: true
+    },
+    {
+      name: "skill",
+      type: "belongsTo",
+      target: "skillDefinitions",
+      foreignKey: "skillId"
+    },
+    {
+      name: "enabled",
+      type: "boolean",
+      defaultValue: true
+    },
+    {
+      name: "title",
+      type: "string",
+      length: 200
+    },
+    {
+      name: "templateKey",
+      type: "string",
+      length: 80,
+      defaultValue: "confirm"
+    },
+    {
+      name: "prompt",
+      type: "text"
+    },
+    {
+      // Resolved interaction schema consumed by the generic Skill Hub UI card.
+      name: "schema",
+      type: "text"
+    },
+    {
+      // Optional template-specific state for future loop renderers.
+      name: "config",
+      type: "text",
+      defaultValue: null
+    },
+    {
+      name: "createdAt",
+      type: "date"
+    },
+    {
+      name: "updatedAt",
+      type: "date"
+    },
+    {
+      name: "createdBy",
+      type: "belongsTo",
+      target: "users",
+      foreignKey: "createdById"
+    }
+  ]
+};

package/dist/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.d.ts

@@ -0,0 +1,7 @@
+import { Migration } from '@nocobase/server';
+export default class AddAgentLoopFieldsToSkillExecutions extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/dist/server/migrations/20260524000000-add-agent-loop-fields-to-skill-executions.js

@@ -0,0 +1,55 @@
+/**
+ * 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 add_agent_loop_fields_to_skill_executions_exports = {};
+__export(add_agent_loop_fields_to_skill_executions_exports, {
+  default: () => AddAgentLoopFieldsToSkillExecutions
+});
+module.exports = __toCommonJS(add_agent_loop_fields_to_skill_executions_exports);
+var import_server = require("@nocobase/server");
+class AddAgentLoopFieldsToSkillExecutions extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.db.options.tablePrefix || "";
+    const tableName = `${tablePrefix}skillExecutions`;
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, {
+        type: "VARCHAR(100)",
+        allowNull: true
+      });
+    };
+    await addIfMissing("agentLoopRunId");
+    await addIfMissing("agentLoopStepId");
+  }
+  async down() {
+  }
+}

package/dist/server/migrations/20260524001000-add-plan-approval-and-harness-profiles.d.ts

@@ -0,0 +1,12 @@
+import { Migration } from '@nocobase/server';
+export default class AddPlanApprovalAndHarnessProfiles extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+    addRunColumns(queryInterface: any, tableName: string): Promise<void>;
+    addStepColumns(queryInterface: any, tableName: string): Promise<void>;
+    addConfigColumns(queryInterface: any, tableName: string): Promise<void>;
+    ensureHarnessProfiles(queryInterface: any, tableName: string): Promise<void>;
+    seedDefaultProfiles(): Promise<void>;
+    down(): Promise<void>;
+}

package/dist/server/migrations/20260524001000-add-plan-approval-and-harness-profiles.js

@@ -0,0 +1,162 @@
+/**
+ * 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 add_plan_approval_and_harness_profiles_exports = {};
+__export(add_plan_approval_and_harness_profiles_exports, {
+  default: () => AddPlanApprovalAndHarnessProfiles
+});
+module.exports = __toCommonJS(add_plan_approval_and_harness_profiles_exports);
+var import_database = require("@nocobase/database");
+var import_server = require("@nocobase/server");
+class AddPlanApprovalAndHarnessProfiles extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    const db = this.db;
+    const queryInterface = db.sequelize.getQueryInterface();
+    const tablePrefix = db.options.tablePrefix || "";
+    await this.addRunColumns(queryInterface, `${tablePrefix}agentLoopRuns`);
+    await this.addStepColumns(queryInterface, `${tablePrefix}agentLoopSteps`);
+    await this.addConfigColumns(queryInterface, `${tablePrefix}orchestratorConfig`);
+    await this.ensureHarnessProfiles(queryInterface, `${tablePrefix}agentHarnessProfiles`);
+    await this.seedDefaultProfiles();
+  }
+  async addRunColumns(queryInterface, tableName) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name, spec) => {
+      if (tableDesc[name]) return;
+      await queryInterface.addColumn(tableName, name, spec);
+    };
+    await addIfMissing("approvalStatus", { type: import_database.DataTypes.STRING(30), allowNull: true, defaultValue: "none" });
+    await addIfMissing("approvedById", { type: import_database.DataTypes.BIGINT, allowNull: true });
+    await addIfMissing("approvedAt", { type: import_database.DataTypes.DATE, allowNull: true });
+    await addIfMissing("rejectionReason", { type: import_database.DataTypes.TEXT, allowNull: true });
+    await addIfMissing("changeRequest", { type: import_database.DataTypes.TEXT, allowNull: true });
+    await addIfMissing("planVersion", { type: import_database.DataTypes.INTEGER, allowNull: true, defaultValue: 1 });
+    await addIfMissing("planSource", { type: import_database.DataTypes.STRING(50), allowNull: true });
+    await addIfMissing("plannerModel", { type: import_database.DataTypes.STRING(100), allowNull: true });
+    await addIfMissing("lockedBy", { type: import_database.DataTypes.STRING(100), allowNull: true });
+    await addIfMissing("lockedUntil", { type: import_database.DataTypes.DATE, allowNull: true });
+  }
+  async addStepColumns(queryInterface, tableName) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc.dependencyPolicy) {
+      await queryInterface.addColumn(tableName, "dependencyPolicy", {
+        type: import_database.DataTypes.STRING(30),
+        allowNull: true,
+        defaultValue: "require_success"
+      });
+    }
+  }
+  async addConfigColumns(queryInterface, tableName) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc.harnessTag) {
+      await queryInterface.addColumn(tableName, "harnessTag", {
+        type: import_database.DataTypes.STRING(100),
+        allowNull: true,
+        defaultValue: "default"
+      });
+    }
+  }
+  async ensureHarnessProfiles(queryInterface, tableName) {
+    const tableExists = await queryInterface.tableExists(tableName).catch(() => false);
+    if (tableExists) return;
+    await queryInterface.createTable(tableName, {
+      id: { type: import_database.DataTypes.BIGINT, primaryKey: true, autoIncrement: true },
+      tag: { type: import_database.DataTypes.STRING(100), allowNull: false, unique: true },
+      title: { type: import_database.DataTypes.STRING(200), allowNull: true },
+      description: { type: import_database.DataTypes.TEXT, allowNull: true },
+      enabled: { type: import_database.DataTypes.BOOLEAN, allowNull: true, defaultValue: true },
+      settings: { type: import_database.DataTypes.JSON, allowNull: true, defaultValue: {} },
+      createdAt: { type: import_database.DataTypes.DATE, allowNull: true },
+      updatedAt: { type: import_database.DataTypes.DATE, allowNull: true }
+    });
+  }
+  async seedDefaultProfiles() {
+    const repo = this.db.getRepository("agentHarnessProfiles");
+    if (!repo) return;
+    const profiles = [
+      {
+        tag: "default",
+        title: "Default",
+        description: "Balanced profile for normal multi-agent work.",
+        settings: {
+          requirePlanApproval: true,
+          allowSubAgents: true,
+          allowToolCalls: true,
+          maxParallelSubAgents: 3,
+          maxControllerSteps: 100
+        }
+      },
+      {
+        tag: "safe",
+        title: "Safe",
+        description: "Strict approval-first profile for higher-risk work.",
+        settings: {
+          requirePlanApproval: true,
+          allowSubAgents: true,
+          allowToolCalls: true,
+          maxParallelSubAgents: 1,
+          maxControllerSteps: 50,
+          requireVerification: true
+        }
+      },
+      {
+        tag: "file-heavy",
+        title: "File Heavy",
+        description: "Profile for tasks that inspect or transform many attachments/files.",
+        settings: {
+          requirePlanApproval: true,
+          allowSubAgents: true,
+          allowToolCalls: true,
+          maxParallelSubAgents: 2,
+          maxControllerSteps: 120,
+          preferFileTools: true
+        }
+      }
+    ];
+    for (const profile of profiles) {
+      const existing = await repo.findOne({ filter: { tag: profile.tag } });
+      if (existing) continue;
+      await repo.create({
+        values: {
+          ...profile,
+          enabled: true,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    }
+  }
+  async down() {
+  }
+}

package/dist/server/plugin.d.ts

@@ -1,7 +1,9 @@
 import { Plugin } from '@nocobase/server';
 import SkillHubSubFeature from './skill-hub/plugin';
+import { AgentLoopService } from './services/AgentLoopService';
 export declare class PluginAgentOrchestratorServer extends Plugin {
     skillHub: SkillHubSubFeature;
+    agentLoopService: AgentLoopService;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;

package/dist/server/plugin.js

@@ -44,12 +44,17 @@ var import_server = require("@nocobase/server");
 var import_path = __toESM(require("path"));
 var import_delegate_task = require("./tools/delegate-task");
 var import_external_rag_search = require("./tools/external-rag-search");
+var import_orchestrator_plan = require("./tools/orchestrator-plan");
 var import_tracing = require("./resources/tracing");
+var import_agent_loop = require("./resources/agent-loop");
 var import_plugin = __toESM(require("./skill-hub/plugin"));
+var import_AgentLoopService = require("./services/AgentLoopService");
 class PluginAgentOrchestratorServer extends import_server.Plugin {
   skillHub;
+  agentLoopService;
   async afterAdd() {
     this.skillHub = new import_plugin.default(this);
+    this.agentLoopService = new import_AgentLoopService.AgentLoopService(this);
   }
   async beforeLoad() {
     this.db.import({ directory: import_path.default.resolve(__dirname, "collections") });
@@ -66,16 +71,24 @@ class PluginAgentOrchestratorServer extends import_server.Plugin {
       actions: [
         "orchestratorConfig:*",
         "orchestratorTracing:*",
+        "agentLoops:*",
+        "agentLoopRuns:*",
+        "agentLoopSteps:*",
+        "agentLoopEvents:*",
+        "agentHarnessProfiles:*",
         "agentExecutionSpans:*",
         "skillDefinitions:*",
         "skillExecutions:*",
+        "skillLoopConfigs:*",
         "skillHub:*",
         "skillWorkerConfigs:*"
       ]
     });
     const toolsManager = this.app.aiManager.toolsManager;
+    toolsManager.registerTools((0, import_orchestrator_plan.createOrchestratorPlanTools)(this, this.agentLoopService));
     toolsManager.registerTools((0, import_external_rag_search.createExternalRagSearchTool)(this));
     toolsManager.registerDynamicTools((0, import_delegate_task.createDelegateToolsProvider)(this));
+    (0, import_agent_loop.registerAgentLoopResource)(this, this.agentLoopService);
     (0, import_tracing.registerTracingResource)(this);
     this.app.cronJobManager.addJob({
       cronTime: "0 30 2 * * *",

package/dist/server/resources/agent-loop.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@nocobase/server';
+import { AgentLoopService } from '../services/AgentLoopService';
+export declare function registerAgentLoopResource(plugin: Plugin, service: AgentLoopService): void;

package/dist/server/resources/agent-loop.js

@@ -0,0 +1,205 @@
+/**
+ * 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 agent_loop_exports = {};
+__export(agent_loop_exports, {
+  registerAgentLoopResource: () => registerAgentLoopResource
+});
+module.exports = __toCommonJS(agent_loop_exports);
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+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 values(ctx) {
+  var _a, _b, _c;
+  return ((_a = ctx.request) == null ? void 0 : _a.body) || ((_c = (_b = ctx.action) == null ? void 0 : _b.params) == null ? void 0 : _c.values) || {};
+}
+function formatRunRow(raw) {
+  const row = toPlain(raw);
+  return {
+    id: row.id,
+    rootRunId: row.rootRunId,
+    sessionId: row.sessionId,
+    messageId: row.messageId,
+    leaderUsername: row.leaderUsername,
+    goal: row.goal,
+    status: row.status,
+    approvalStatus: row.approvalStatus,
+    planVersion: row.planVersion,
+    planSource: row.planSource,
+    plannerModel: row.plannerModel,
+    approvedById: row.approvedById,
+    approvedAt: row.approvedAt,
+    rejectionReason: row.rejectionReason,
+    changeRequest: row.changeRequest,
+    currentStepId: row.currentStepId,
+    iterationCount: row.iterationCount || 0,
+    finalAnswer: row.finalAnswer,
+    summary: row.summary,
+    userId: row.userId,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function registerAgentLoopResource(plugin, service) {
+  const app = plugin.app;
+  app.resource({
+    name: "agentLoops",
+    actions: {
+      async list(ctx, next) {
+        const { page = 1, pageSize = 20, sort = ["-createdAt"], filter = {} } = ctx.action.params;
+        const repo = ctx.db.getRepository("agentLoopRuns");
+        const [rows, count] = await repo.findAndCount({
+          filter,
+          sort,
+          offset: (Number(page) - 1) * Number(pageSize),
+          limit: Number(pageSize)
+        });
+        ctx.body = {
+          data: rows.map(formatRunRow),
+          meta: {
+            count,
+            page: Number(page),
+            pageSize: Number(pageSize),
+            totalPage: Math.ceil(count / Number(pageSize))
+          }
+        };
+        await next();
+      },
+      async get(ctx, next) {
+        const { filterByTk } = ctx.action.params;
+        if (!filterByTk) {
+          ctx.throw(400, "run id is required");
+          return;
+        }
+        ctx.body = { data: await service.getRunDetail(filterByTk) };
+        await next();
+      },
+      async resume(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, "runId is required");
+          return;
+        }
+        ctx.body = {
+          data: await service.resumeRun(runId, {
+            stepId: body.stepId,
+            approved: body.approved !== false,
+            editedInput: body.editedInput,
+            userId: currentUserId(ctx),
+            ctx
+          })
+        };
+        await next();
+      },
+      async approvePlan(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, "runId is required");
+          return;
+        }
+        ctx.body = {
+          data: await service.approvePlanAndExecute(runId, {
+            userId: currentUserId(ctx),
+            ctx,
+            reason: body.reason
+          })
+        };
+        await next();
+      },
+      async rejectPlan(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, "runId is required");
+          return;
+        }
+        ctx.body = {
+          data: await service.rejectPlan(runId, {
+            reason: body.reason,
+            userId: currentUserId(ctx)
+          })
+        };
+        await next();
+      },
+      async requestPlanChanges(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, "runId is required");
+          return;
+        }
+        ctx.body = {
+          data: await service.requestPlanChanges(runId, {
+            feedback: body.feedback,
+            userId: currentUserId(ctx)
+          })
+        };
+        await next();
+      },
+      async cancel(ctx, next) {
+        const body = values(ctx);
+        const runId = body.runId || ctx.action.params.filterByTk;
+        if (!runId) {
+          ctx.throw(400, "runId is required");
+          return;
+        }
+        ctx.body = {
+          data: await service.cancelRun(runId, {
+            reason: body.reason,
+            userId: currentUserId(ctx)
+          })
+        };
+        await next();
+      },
+      async retryStep(ctx, next) {
+        const body = values(ctx);
+        if (!body.stepId) {
+          ctx.throw(400, "stepId is required");
+          return;
+        }
+        ctx.body = {
+          data: await service.retryStep(body.stepId, {
+            userId: currentUserId(ctx)
+          })
+        };
+        await next();
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerAgentLoopResource
+});

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

@@ -0,0 +1,42 @@
+import { AgentRegistryService } from './AgentRegistryService';
+export declare class AgentHarness {
+    private readonly plugin;
+    private readonly registryService;
+    private readonly spanService;
+    constructor(plugin: any, registryService: AgentRegistryService);
+    get db(): any;
+    get app(): any;
+    executeStep(run: any, step: any, options?: {
+        userId?: string | number;
+        ctx?: any;
+    }): Promise<any>;
+    private invokeSubAgentStep;
+    private invokeNamedTool;
+    runSubAgent(ctx: any, options: {
+        leaderUsername: string;
+        subAgentUsername: string;
+        subAgentEmployee: any;
+        task: string;
+        context?: string;
+        currentDepth?: number;
+        currentPath?: string[];
+        maxDepth: number;
+        timeout: number;
+        toolCallId: string;
+        toolName: string;
+        llmService?: string;
+        model?: string;
+        recursionLimit?: number;
+        rootRunId?: string;
+        parentSpanId?: string;
+        agentLoopRunId?: string;
+        agentLoopStepId?: string;
+    }): Promise<{
+        status: "success";
+        content: string;
+    } | {
+        status: "error";
+        content: any;
+    }>;
+    private logDelegation;
+}