plugin-agent-orchestrator 1.0.17 → 1.0.19

package/dist/server/tools/delegate-task.js

@@ -32,9 +32,6 @@ __export(delegate_task_exports, {
 module.exports = __toCommonJS(delegate_task_exports);
 var import_zod = require("zod");
 var import_crypto = require("crypto");
-var import_prebuilt = require("@langchain/langgraph/prebuilt");
-var import_tools = require("@langchain/core/tools");
-var import_messages = require("@langchain/core/messages");
 var import_ExecutionSpanService = require("../services/ExecutionSpanService");
 const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
 const ORCHESTRATOR_PATH_KEY = "__orchestratorPath";
@@ -97,7 +94,7 @@ function createDelegateToolOptions(plugin, options) {
   return {
     scope: "CUSTOM",
     execution: "backend",
-    defaultPermission: "ALLOW",
+    defaultPermission: "ASK",
     silence: false,
     introduction: {
       title: `[${leaderUsername}] ${subAgentEmployee.nickname || subAgentUsername}${legacyAlias ? " (legacy)" : ""}`,
@@ -206,7 +203,7 @@ ${subAgentList}`
   return {
     scope: "CUSTOM",
     execution: "backend",
-    defaultPermission: "ALLOW",
+    defaultPermission: "ASK",
     silence: false,
     introduction: {
       title: `[${leaderUsername}] Dispatch sub-agents`,
@@ -555,7 +552,6 @@ function invalidateDelegateToolsCache() {
   registeredDelegateNamesByPlugin = /* @__PURE__ */ new WeakMap();
 }
 async function invokeDelegateTask(ctx, plugin, options) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
   const {
     leaderUsername,
     subAgentUsername,
@@ -614,320 +610,31 @@ async function invokeDelegateTask(ctx, plugin, options) {
       content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`
     };
   }
-  const spanService = new import_ExecutionSpanService.ExecutionSpanService(plugin);
   const upstreamTraceContext = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx);
   const rootRunId = providedRootRunId || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.rootRunId) || createRootRunId(`${leaderUsername}:${subAgentUsername}`);
   const parentSpanId = providedParentSpanId || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.spanId) || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.parentSpanId);
-  const startTime = Date.now();
-  const trace = [
-    {
-      type: "start",
-      at: nowIso(),
-      title: `Delegation started: ${leaderUsername} -> ${subAgentUsername}`,
-      content: task
-    }
-  ];
-  const executionSpan = await spanService.create({
-    rootRunId,
-    parentSpanId,
-    type: "sub_agent",
-    status: "running",
-    leaderUsername,
-    employeeUsername: subAgentUsername,
-    title: `Delegation: ${leaderUsername} -> ${subAgentUsername}`,
-    input: { task, context },
-    metadata: {
-      depth: currentDepth,
-      maxDepth,
-      toolName,
-      recursionLimit,
-      llmOverride: llmService && model ? { llmService, model } : void 0
-    },
-    userId: ctxSnapshot.userId
-  });
-  const executionSpanId = (executionSpan == null ? void 0 : executionSpan.id) ? String(executionSpan.id) : void 0;
-  const logRecord = await logDelegation(ctx, plugin, {
+  const agentLoopRunId = upstreamTraceContext == null ? void 0 : upstreamTraceContext.agentLoopRunId;
+  const agentLoopStepId = upstreamTraceContext == null ? void 0 : upstreamTraceContext.agentLoopStepId;
+  return plugin.agentLoopService.harness.runSubAgent(ctx, {
     leaderUsername,
     subAgentUsername,
-    toolName,
+    subAgentEmployee,
     task,
     context,
-    result: "",
-    status: "running",
-    depth: currentDepth,
-    durationMs: 0,
-    trace,
-    snapshot: ctxSnapshot
+    currentDepth,
+    currentPath,
+    maxDepth,
+    timeout,
+    toolCallId,
+    toolName,
+    llmService,
+    model,
+    recursionLimit,
+    rootRunId,
+    parentSpanId,
+    agentLoopRunId,
+    agentLoopStepId
   });
-  if (executionSpanId && (logRecord == null ? void 0 : logRecord.id)) {
-    await spanService.update(executionSpanId, { orchestratorLogId: logRecord.id });
-  }
-  try {
-    const aiPlugin = ctx.app.pm.get("ai");
-    if (!aiPlugin) {
-      throw new Error("Plugin AI is not installed or enabled");
-    }
-    let modelSettings = hasModelSettings(subAgentEmployee.modelSettings) ? subAgentEmployee.modelSettings : void 0;
-    if (llmService && model) {
-      modelSettings = { llmService, model };
-    }
-    if (!hasModelSettings(modelSettings)) {
-      const leaderEmployee = await plugin.db.getRepository("aiEmployees").findOne({
-        filter: { username: leaderUsername }
-      });
-      const dynamicModel = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.model;
-      modelSettings = hasModelSettings(leaderEmployee == null ? void 0 : leaderEmployee.modelSettings) ? leaderEmployee.modelSettings : hasModelSettings(dynamicModel) ? dynamicModel : void 0;
-      if (!hasModelSettings(modelSettings)) {
-        throw new Error(
-          `Sub-agent "${subAgentUsername}" has no LLM model configured (and leader fallback failed). Please configure a model in the Orchestrator Config or AI Employee settings.`
-        );
-      }
-    }
-    const { provider } = await aiPlugin.aiManager.getLLMService({
-      llmService: modelSettings.llmService,
-      model: modelSettings.model
-    });
-    const chatModel = provider.createModel();
-    const coreToolsManager = ctx.app.aiManager.toolsManager;
-    const allTools = await coreToolsManager.listTools();
-    const employeeSkills = (((_d = subAgentEmployee.skillSettings) == null ? void 0 : _d.skills) ?? []).map(
-      (s) => typeof s === "string" ? { name: s, autoCall: false } : { name: s == null ? void 0 : s.name, autoCall: (s == null ? void 0 : s.autoCall) === true }
-    ).filter((s) => Boolean(s.name));
-    const employeeSkillMap = new Map(employeeSkills.map((skill) => [skill.name, skill]));
-    const langchainTools = [];
-    for (const toolEntry of allTools) {
-      const entryName = toolEntry.definition.name;
-      if (!entryName) continue;
-      const employeeSkill = employeeSkillMap.get(entryName);
-      if (!employeeSkill || isDelegateToolName(plugin, entryName) || employeeSkill.autoCall !== true) {
-        continue;
-      }
-      langchainTools.push(
-        new import_tools.DynamicStructuredTool({
-          name: entryName.replace(/[^a-zA-Z0-9_-]/g, "_"),
-          description: toolEntry.definition.description || entryName,
-          schema: toolEntry.definition.schema || import_zod.z.object({}),
-          func: async (toolArgs) => {
-            var _a2;
-            const invokeCtx = Object.create(ctx);
-            invokeCtx[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
-            invokeCtx[ORCHESTRATOR_PATH_KEY] = [...currentPath, subAgentUsername];
-            invokeCtx._currentAIEmployee = subAgentUsername;
-            if (ctx.state) {
-              invokeCtx.state = Object.create(ctx.state);
-              invokeCtx.state.currentAIEmployee = subAgentUsername;
-            }
-            const toolStartedAt = Date.now();
-            const isSkillHubTool = entryName === "skill_hub_execute" || entryName.startsWith("skill_hub_");
-            const toolSpan = await spanService.create({
-              rootRunId,
-              parentSpanId: executionSpanId,
-              type: isSkillHubTool ? "skill" : "tool",
-              status: "running",
-              leaderUsername,
-              employeeUsername: subAgentUsername,
-              toolName: toolEntry.definition.name,
-              title: isSkillHubTool ? `Skill: ${toolEntry.definition.name}` : `Tool: ${toolEntry.definition.name}`,
-              input: toolArgs,
-              metadata: {
-                depth: currentDepth + 1,
-                toolCallId: `orch-${toolCallId}`,
-                defaultPermission: toolEntry.defaultPermission
-              },
-              userId: ctxSnapshot.userId
-            });
-            const toolSpanId = (toolSpan == null ? void 0 : toolSpan.id) ? String(toolSpan.id) : void 0;
-            (0, import_ExecutionSpanService.setOrchestratorTraceContext)(invokeCtx, {
-              rootRunId,
-              spanId: toolSpanId,
-              parentSpanId: executionSpanId,
-              toolCallId: `orch-${toolCallId}`,
-              leaderUsername,
-              employeeUsername: subAgentUsername,
-              toolName: toolEntry.definition.name
-            });
-            trace.push({
-              type: "tool_call",
-              at: nowIso(),
-              title: `Calling tool: ${toolEntry.definition.name}`,
-              toolName: toolEntry.definition.name,
-              args: toolArgs
-            });
-            try {
-              const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
-              const output = truncateText((res == null ? void 0 : res.content) ?? (res == null ? void 0 : res.result) ?? res, 5e4);
-              trace.push({
-                type: "tool_result",
-                at: nowIso(),
-                title: `Tool finished: ${toolEntry.definition.name}`,
-                toolName: toolEntry.definition.name,
-                status: (res == null ? void 0 : res.status) || "success",
-                content: truncateText(output, 2e3)
-              });
-              if ((res == null ? void 0 : res.status) === "error") {
-                await spanService.finish(toolSpanId, "error", toolStartedAt, {
-                  output,
-                  error: truncateText(res.content || output, 1e4)
-                });
-                throw new Error(`Tool <${toolEntry.definition.name}> failed: ${res.content}`);
-              }
-              await spanService.finish(toolSpanId, "success", toolStartedAt, {
-                output,
-                skillExecutionId: ((_a2 = res == null ? void 0 : res.result) == null ? void 0 : _a2.execId) || (res == null ? void 0 : res.execId)
-              });
-              return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
-            } catch (e) {
-              trace.push({
-                type: "tool_error",
-                at: nowIso(),
-                title: `Tool failed: ${toolEntry.definition.name}`,
-                toolName: toolEntry.definition.name,
-                status: "error",
-                content: e.message
-              });
-              await spanService.finish(toolSpanId, "error", toolStartedAt, {
-                error: truncateText(e.message, 1e4)
-              });
-              throw e;
-            }
-          }
-        })
-      );
-    }
-    const abortController = new AbortController();
-    const executor = (0, import_prebuilt.createReactAgent)({
-      llm: chatModel,
-      tools: langchainTools
-    });
-    let systemPrompt = ((_e = subAgentEmployee.chatSettings) == null ? void 0 : _e.systemPrompt) || subAgentEmployee.bio || `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${subAgentEmployee.about || ""}`;
-    try {
-      const kbPlugin = ctx.app.pm.get("plugin-knowledge-base");
-      if (kbPlugin == null ? void 0 : kbPlugin.sessionContext) {
-        const sessionId = ((_h = (_g = (_f = ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.values) == null ? void 0 : _h.sessionId) || ((_j = (_i = ctx.action) == null ? void 0 : _i.params) == null ? void 0 : _j.sessionId) || ((_k = ctx.state) == null ? void 0 : _k.sessionId);
-        const contextSummary = await kbPlugin.sessionContext.buildSummary(
-          { rootRunId, ...sessionId ? { sessionId } : {} },
-          6e3
-        );
-        if (contextSummary) {
-          systemPrompt += `
-
-<shared_context>
-The following context was shared by other agents in this workflow. Use it to avoid redundant work:
-${contextSummary}
-</shared_context>`;
-        }
-      }
-    } catch (e) {
-      (_m = (_l = ctx.app.log) == null ? void 0 : _l.debug) == null ? void 0 : _m.call(_l, `[AgentOrchestrator] Shared context injection skipped: ${e.message}`);
-    }
-    const combinedTask = context ? `Task: ${task}
-
-Context Provided:
-${context}` : `Task: ${task}`;
-    const effectiveRecursionLimit = Number.isFinite(recursionLimit) && recursionLimit > 0 ? recursionLimit : 50;
-    const invokePromise = executeAgent(
-      executor,
-      systemPrompt,
-      combinedTask,
-      abortController.signal,
-      effectiveRecursionLimit
-    );
-    const timeoutHandle = createTimeout(timeout, subAgentUsername, abortController);
-    let result;
-    try {
-      result = await Promise.race([invokePromise, timeoutHandle.promise]);
-    } finally {
-      timeoutHandle.cancel();
-    }
-    const content = result.content || "Sub-agent completed the task but produced no output.";
-    trace.push({
-      type: "finish",
-      at: nowIso(),
-      title: `Delegation finished: ${subAgentUsername}`,
-      status: "success",
-      content: truncateText(content, 2e3)
-    });
-    await logDelegation(ctx, plugin, {
-      id: logRecord == null ? void 0 : logRecord.id,
-      leaderUsername,
-      subAgentUsername,
-      toolName,
-      task,
-      context,
-      result: content,
-      status: "success",
-      depth: currentDepth,
-      durationMs: Date.now() - startTime,
-      trace,
-      messages: result.messages,
-      snapshot: ctxSnapshot
-    });
-    await spanService.finish(executionSpanId, "success", startTime, {
-      output: content,
-      metadata: {
-        depth: currentDepth,
-        maxDepth,
-        toolName,
-        recursionLimit,
-        messages: result.messages,
-        traceCount: trace.length
-      }
-    });
-    return {
-      status: "success",
-      content
-    };
-  } catch (e) {
-    plugin.app.log.error(`[AgentOrchestrator] Sub-agent ${subAgentUsername} failed`, e);
-    await logDelegation(ctx, plugin, {
-      id: logRecord == null ? void 0 : logRecord.id,
-      leaderUsername,
-      subAgentUsername,
-      toolName,
-      task,
-      context,
-      result: "",
-      status: "error",
-      depth: currentDepth,
-      durationMs: Date.now() - startTime,
-      error: e.message,
-      trace: [
-        ...trace,
-        {
-          type: "error",
-          at: nowIso(),
-          title: `Delegation failed: ${subAgentUsername}`,
-          status: "error",
-          content: e.message
-        }
-      ],
-      snapshot: ctxSnapshot
-    }).catch((logErr) => {
-      plugin.app.log.warn("[AgentOrchestrator] Failed to save error log for delegation", logErr);
-    });
-    await spanService.finish(executionSpanId, "error", startTime, {
-      error: truncateText(e.message, 1e4),
-      metadata: {
-        depth: currentDepth,
-        maxDepth,
-        toolName,
-        recursionLimit,
-        traceCount: trace.length + 1
-      }
-    });
-    const diagnosticTrace = trace.filter((t) => t.type === "tool_error" || t.type === "error").map((t) => `[${t.toolName ? `Tool: ${t.toolName}` : "Sub-agent"}] Error: ${t.content || t.title}`).join("\n");
-    const formattedError = [
-      `Sub-agent "${subAgentUsername}" failed execution: ${e.message}`,
-      diagnosticTrace ? `
-Diagnostic Details of internal failures:
-${diagnosticTrace}` : "",
-      `Suggestion: Review the tool parameters above or try dividing the task into simpler independent tasks.`
-    ].filter(Boolean).join("\n");
-    return {
-      status: "error",
-      content: formattedError
-    };
-  }
 }
 async function logDelegation(ctx, plugin, data) {
   var _a, _b, _c, _d, _e, _f;
@@ -978,62 +685,6 @@ async function logDelegation(ctx, plugin, data) {
     plugin.app.log.warn("[AgentOrchestrator] Failed to log delegation event", e);
   }
 }
-async function executeAgent(executor, systemPrompt, task, signal, recursionLimit = 50) {
-  const config = { recursionLimit };
-  if (signal) {
-    config.signal = signal;
-  }
-  const finalState = await executor.invoke(
-    {
-      messages: [new import_messages.SystemMessage(systemPrompt), new import_messages.HumanMessage(task)]
-    },
-    config
-  );
-  const messages = (finalState == null ? void 0 : finalState.messages) || [];
-  const lastAIMessage = [...messages].reverse().find((m) => m.getType() === "ai");
-  if (!lastAIMessage || !lastAIMessage.content) {
-    return { content: "", messages: serializeMessages(messages) };
-  }
-  let content = "";
-  if (typeof lastAIMessage.content === "string") {
-    content = lastAIMessage.content;
-  } else if (Array.isArray(lastAIMessage.content)) {
-    content = lastAIMessage.content.map((c) => c.text || JSON.stringify(c)).join("\n");
-  } else {
-    content = String(lastAIMessage.content);
-  }
-  return { content, messages: serializeMessages(messages) };
-}
-function serializeMessages(messages) {
-  return (messages || []).map((message, index) => {
-    const type = typeof message.getType === "function" ? message.getType() : message.type;
-    return {
-      index,
-      type,
-      name: message.name,
-      content: truncateText(message.content, 1e4),
-      toolCalls: message.tool_calls || message.toolCalls || [],
-      toolCallId: message.tool_call_id,
-      additionalKwargs: message.additional_kwargs,
-      responseMetadata: message.response_metadata
-    };
-  });
-}
-function createTimeout(ms, agentName, abortController) {
-  let timer;
-  const promise = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => {
-      abortController == null ? void 0 : abortController.abort();
-      reject(new Error(`Sub-agent "${agentName}" timed out after ${ms / 1e3}s`));
-    }, ms);
-  });
-  return {
-    promise,
-    cancel: () => {
-      if (timer) clearTimeout(timer);
-    }
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createDelegateToolsProvider,

package/dist/server/tools/external-rag-search.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare function createExternalRagSearchTool(plugin: any): {
+    scope: "CUSTOM";
+    execution: "backend";
+    defaultPermission: "ALLOW";
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            query: z.ZodString;
+            knowledgeBaseIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            topK: z.ZodOptional<z.ZodNumber>;
+            scoreThreshold: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            query?: string;
+            knowledgeBaseIds?: string[];
+            topK?: number;
+            scoreThreshold?: number;
+        }, {
+            query?: string;
+            knowledgeBaseIds?: string[];
+            topK?: number;
+            scoreThreshold?: number;
+        }>;
+    };
+    invoke: (ctx: any, args: {
+        query?: string;
+        knowledgeBaseIds?: string[];
+        topK?: number;
+        scoreThreshold?: number;
+    }) => Promise<{
+        status: "error";
+        content: string;
+    } | {
+        status: "success";
+        content: string;
+    }>;
+};

package/dist/server/tools/orchestrator-plan.d.ts

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+import { AgentLoopService } from '../services/AgentLoopService';
+export declare function createOrchestratorPlanTools(plugin: any, service: AgentLoopService): ({
+    scope: "CUSTOM";
+    execution: "backend";
+    defaultPermission: "ALLOW";
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            goal: z.ZodString;
+            runId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+            leaderUsername: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            harnessTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            targetAgent: z.ZodOptional<z.ZodString>;
+            plannerModel: z.ZodOptional<z.ZodString>;
+            policy: z.ZodOptional<z.ZodObject<{
+                maxIterations: z.ZodOptional<z.ZodNumber>;
+                maxStepAttempts: z.ZodOptional<z.ZodNumber>;
+                allowReplan: z.ZodOptional<z.ZodBoolean>;
+                requireVerification: z.ZodOptional<z.ZodBoolean>;
+                stopOnApprovalRequired: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                maxIterations?: number;
+                maxStepAttempts?: number;
+                allowReplan?: boolean;
+                requireVerification?: boolean;
+                stopOnApprovalRequired?: boolean;
+            }, {
+                maxIterations?: number;
+                maxStepAttempts?: number;
+                allowReplan?: boolean;
+                requireVerification?: boolean;
+                stopOnApprovalRequired?: boolean;
+            }>>;
+            metadata: z.ZodOptional<z.ZodAny>;
+            plan: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                key: z.ZodOptional<z.ZodString>;
+                planKey: z.ZodOptional<z.ZodString>;
+                parentStepId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodEnum<["reasoning", "skill", "tool", "sub_agent", "verification"]>>;
+                target: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodAny>;
+                dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                dependencyPolicy: z.ZodOptional<z.ZodEnum<["require_success", "allow_skipped"]>>;
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "reasoning" | "skill" | "tool" | "sub_agent" | "verification";
+                key?: string;
+                title?: string;
+                description?: string;
+                metadata?: any;
+                input?: any;
+                planKey?: string;
+                target?: string;
+                dependsOn?: string[];
+                id?: string;
+                parentStepId?: string | number;
+                dependencyPolicy?: "require_success" | "allow_skipped";
+                maxAttempts?: number;
+            }, {
+                type?: "reasoning" | "skill" | "tool" | "sub_agent" | "verification";
+                key?: string;
+                title?: string;
+                description?: string;
+                metadata?: any;
+                input?: any;
+                planKey?: string;
+                target?: string;
+                dependsOn?: string[];
+                id?: string;
+                parentStepId?: string | number;
+                dependencyPolicy?: "require_success" | "allow_skipped";
+                maxAttempts?: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            leaderUsername?: string;
+            metadata?: any;
+            runId?: string | number;
+            sessionId?: string;
+            goal?: string;
+            messageId?: string;
+            policy?: {
+                maxIterations?: number;
+                maxStepAttempts?: number;
+                allowReplan?: boolean;
+                requireVerification?: boolean;
+                stopOnApprovalRequired?: boolean;
+            };
+            harnessTag?: string;
+            targetAgent?: string;
+            plannerModel?: string;
+            plan?: {
+                type?: "reasoning" | "skill" | "tool" | "sub_agent" | "verification";
+                key?: string;
+                title?: string;
+                description?: string;
+                metadata?: any;
+                input?: any;
+                planKey?: string;
+                target?: string;
+                dependsOn?: string[];
+                id?: string;
+                parentStepId?: string | number;
+                dependencyPolicy?: "require_success" | "allow_skipped";
+                maxAttempts?: number;
+            }[];
+        }, {
+            leaderUsername?: string;
+            metadata?: any;
+            runId?: string | number;
+            sessionId?: string;
+            goal?: string;
+            messageId?: string;
+            policy?: {
+                maxIterations?: number;
+                maxStepAttempts?: number;
+                allowReplan?: boolean;
+                requireVerification?: boolean;
+                stopOnApprovalRequired?: boolean;
+            };
+            harnessTag?: string;
+            targetAgent?: string;
+            plannerModel?: string;
+            plan?: {
+                type?: "reasoning" | "skill" | "tool" | "sub_agent" | "verification";
+                key?: string;
+                title?: string;
+                description?: string;
+                metadata?: any;
+                input?: any;
+                planKey?: string;
+                target?: string;
+                dependsOn?: string[];
+                id?: string;
+                parentStepId?: string | number;
+                dependencyPolicy?: "require_success" | "allow_skipped";
+                maxAttempts?: number;
+            }[];
+        }>;
+    };
+    invoke: (ctx: any, args: any) => Promise<{
+        status: "success" | "error";
+        content: string;
+    }>;
+} | {
+    scope: "CUSTOM";
+    execution: "backend";
+    defaultPermission: "ALLOW";
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            runId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        }, "strip", z.ZodTypeAny, {
+            runId?: string | number;
+        }, {
+            runId?: string | number;
+        }>;
+    };
+    invoke: (_ctx: any, args: any) => Promise<{
+        status: "success" | "error";
+        content: string;
+    }>;
+} | {
+    scope: "CUSTOM";
+    execution: "backend";
+    defaultPermission: "ASK";
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            runId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            runId?: string | number;
+            reason?: string;
+        }, {
+            runId?: string | number;
+            reason?: string;
+        }>;
+    };
+    invoke: (ctx: any, args: any) => Promise<{
+        status: "success" | "error";
+        content: string;
+    }>;
+})[];