plugin-agent-orchestrator 1.0.17 → 1.0.19

package/dist/server/skill-hub/plugin.js

@@ -53,6 +53,7 @@ var import_McpController = require("./mcp/McpController");
 var import_SkillRepositoryService = require("../services/SkillRepositoryService");
 var import_git_import = require("./actions/git-import");
 var import_json_fields = require("./utils/json-fields");
+var import_ExecutionSpanService = require("../services/ExecutionSpanService");
 class RateLimiter {
   constructor(maxExecutions = 10, windowMs = 60 * 1e3) {
     this.maxExecutions = maxExecutions;
@@ -77,9 +78,7 @@ class RateLimiter {
   /** Get remaining executions for a user */
   remaining(userId) {
     const now = Date.now();
-    const executions = (this.userExecutions.get(userId) || []).filter(
-      (t) => now - t < this.windowMs
-    );
+    const executions = (this.userExecutions.get(userId) || []).filter((t) => now - t < this.windowMs);
     return Math.max(0, this.maxExecutions - executions.length);
   }
   /** Periodically clean up expired entries (call from interval) */
@@ -152,7 +151,9 @@ class SkillHubSubFeature {
           require("fs").rmSync(dir, { recursive: true, force: true });
         }
       } catch (err) {
-        this.app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, { error: err });
+        this.app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, {
+          error: err
+        });
       }
     });
     this.db.on("skillDefinitions.afterSave", async (model, options) => {
@@ -168,31 +169,56 @@ class SkillHubSubFeature {
               this.app.logger.warn("[skill-hub] plugin-file-manager not found, cannot extract skill package");
               return;
             }
+            const rawStorageId = attachment.get("storageId") || attachment.storageId;
+            if (rawStorageId) {
+              const strId = String(rawStorageId);
+              let matchedKey = null;
+              for (const key of fileManager.storagesCache.keys()) {
+                if (String(key) === strId) {
+                  matchedKey = key;
+                  break;
+                }
+              }
+              if (matchedKey !== null) {
+                attachment.set("storageId", matchedKey);
+                attachment.storageId = matchedKey;
+              }
+            }
             const streamData = await fileManager.getFileStream(attachment);
             if (!streamData || !streamData.stream) {
-              this.app.logger.warn(`[skill-hub] Could not get file stream for attachment ${attachment.get("id")}`);
+              this.app.logger.warn(
+                `[skill-hub] Could not get file stream for attachment ${attachment.get("id")}`
+              );
               return;
             }
             const tempZipPath = (0, import_path.resolve)(os.tmpdir(), `skill_${Date.now()}_${model.get("id")}.zip`);
-            await new Promise((resolvePipe, rejectPipe) => {
+            await new Promise((resolve2, reject) => {
               const writeStream = (0, import_fs.createWriteStream)(tempZipPath);
               streamData.stream.pipe(writeStream);
-              writeStream.on("finish", resolvePipe);
-              writeStream.on("error", rejectPipe);
-              streamData.stream.on("error", rejectPipe);
+              writeStream.on("finish", resolve2);
+              writeStream.on("error", reject);
+              streamData.stream.on("error", reject);
             });
             if (require("fs").existsSync(tempZipPath)) {
               const skillName = model.get("name");
-              const { metadata, instructions } = await this.skillRepoService.extractSkillPackage(skillName, tempZipPath);
+              const { metadata, instructions } = await this.skillRepoService.extractSkillPackage(
+                skillName,
+                tempZipPath
+              );
               const code = this.skillRepoService.getSkillCode(skillName);
-              const updateValues = { storageType: attachment.get("storageId") ? `storage-${attachment.get("storageId")}` : "local" };
+              const updateValues = {
+                storageType: attachment.get("storageId") ? `storage-${attachment.get("storageId")}` : "local"
+              };
               if (code) updateValues.codeTemplate = code;
               if (metadata.description) updateValues.description = metadata.description;
               if (metadata.title) updateValues.title = metadata.title;
               if (metadata.language) updateValues.language = metadata.language;
-              if (metadata.inputSchema) updateValues.inputSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.inputSchema, null));
-              if (metadata.interactionSchema) updateValues.interactionSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.interactionSchema, null));
-              if (metadata.packages) updateValues.packages = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.packages, []), []);
+              if (metadata.inputSchema)
+                updateValues.inputSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.inputSchema, null));
+              if (metadata.interactionSchema)
+                updateValues.interactionSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.interactionSchema, null));
+              if (metadata.packages)
+                updateValues.packages = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.packages, []), []);
               if (metadata.timeoutSeconds) updateValues.timeoutSeconds = metadata.timeoutSeconds;
               if (instructions) updateValues.instructions = instructions;
               await this.db.getRepository("skillDefinitions").update({
@@ -262,12 +288,19 @@ class SkillHubSubFeature {
         );
       }
     }
+    const traceContext = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx);
     const execution = await this.db.getRepository("skillExecutions").create({
       values: {
         skillId: skill.id,
         status: "pending",
         inputArgs: (0, import_json_fields.stringifyJsonText)(inputArgs, {}),
         sessionId: (_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.sessionId,
+        orchestratorRootRunId: traceContext == null ? void 0 : traceContext.rootRunId,
+        orchestratorSpanId: traceContext == null ? void 0 : traceContext.spanId,
+        orchestratorParentSpanId: traceContext == null ? void 0 : traceContext.parentSpanId,
+        orchestratorToolCallId: traceContext == null ? void 0 : traceContext.toolCallId,
+        agentLoopRunId: traceContext == null ? void 0 : traceContext.agentLoopRunId,
+        agentLoopStepId: traceContext == null ? void 0 : traceContext.agentLoopStepId,
         triggeredById: (_e = (_d = ctx == null ? void 0 : ctx.state) == null ? void 0 : _d.currentUser) == null ? void 0 : _e.id
       }
     });
@@ -340,7 +373,13 @@ class SkillHubSubFeature {
         downloadUrl: `/api/skillHub:download?execId=${execId}&f=${b64name}`
       };
     });
-    return { ...result, files: filesWithUrls, execId };
+    return {
+      ...result,
+      files: filesWithUrls,
+      execId,
+      agentLoopRunId: traceContext == null ? void 0 : traceContext.agentLoopRunId,
+      agentLoopStepId: traceContext == null ? void 0 : traceContext.agentLoopStepId
+    };
   }
   async handleDownload(ctx, next) {
     var _a, _b;
@@ -455,6 +494,49 @@ class SkillHubSubFeature {
     await this.app.pubSubManager.subscribe("skill-hub.init-env.done", this.initEnvDoneCallback);
     await this.app.pubSubManager.subscribe("skill-hub.init-env.progress", this.initEnvProgressCallback);
   }
+  getSkillRecordId(skill) {
+    return String(skill.get ? skill.get("id") : skill.id);
+  }
+  resolveLoopInteractionSchema(loopConfig) {
+    if (!loopConfig) return null;
+    const schema = (0, import_json_fields.parseJsonText)(loopConfig.get ? loopConfig.get("schema") : loopConfig.schema, null);
+    const prompt = loopConfig.get ? loopConfig.get("prompt") : loopConfig.prompt;
+    if (schema && typeof schema === "object") {
+      return prompt && !schema.prompt ? { ...schema, prompt } : schema;
+    }
+    if (prompt) {
+      return {
+        type: "confirm",
+        prompt
+      };
+    }
+    return null;
+  }
+  async getLoopConfigsBySkillId(skillIds) {
+    const ids = Array.from(new Set(skillIds.map((id) => String(id)).filter(Boolean)));
+    const configsBySkillId = /* @__PURE__ */ new Map();
+    if (!ids.length) return configsBySkillId;
+    try {
+      const configs = await this.db.getRepository("skillLoopConfigs").find({
+        filter: {
+          enabled: true,
+          skillId: {
+            $in: ids
+          }
+        },
+        sort: ["-updatedAt"]
+      });
+      for (const config of configs || []) {
+        const skillId = String(config.get ? config.get("skillId") : config.skillId);
+        if (!configsBySkillId.has(skillId)) {
+          configsBySkillId.set(skillId, config);
+        }
+      }
+    } catch (err) {
+      this.app.logger.warn("[skill-hub] Failed to load loop configs", err);
+    }
+    return configsBySkillId;
+  }
   registerAITools() {
     var _a;
     try {
@@ -470,45 +552,56 @@ class SkillHubSubFeature {
             filter: { enabled: true }
           });
           if (!skills || skills.length === 0) return;
-          const tools = await Promise.all(skills.map(async (skill) => {
-            const sanitizedToolName = skill.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
-            const autoCall = !!skill.get("autoCall");
-            const interactionSchema = (0, import_json_fields.parseJsonText)(skill.get("interactionSchema"), null);
-            const fullDescription = await this.getSkillDescriptionForAI(skill);
-            const baseDescription = `${fullDescription || skill.get("description")}
-Language: ${skill.get("language")}`;
-            const description = !autoCall && interactionSchema ? `${baseDescription}
+          const loopConfigsBySkillId = await this.getLoopConfigsBySkillId(
+            skills.map((skill) => this.getSkillRecordId(skill))
+          );
+          const tools = await Promise.all(
+            skills.map(async (skill) => {
+              const sanitizedToolName = skill.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+              const autoCall = !!skill.get("autoCall");
+              const loopConfig = loopConfigsBySkillId.get(this.getSkillRecordId(skill));
+              const loopInteractionSchema = this.resolveLoopInteractionSchema(loopConfig);
+              const skillInteractionSchema = (0, import_json_fields.parseJsonText)(skill.get("interactionSchema"), null);
+              const interactionSchema = loopInteractionSchema || skillInteractionSchema;
+              const requiresHumanReview = !!interactionSchema;
+              const fullDescription = await this.getSkillDescriptionForAI(skill);
+              const baseDescription = `${fullDescription || skill.get("description")}
+Language: ${skill.get(
+                "language"
+              )}`;
+              const description = requiresHumanReview ? `${baseDescription}
 
-IMPORTANT: This skill requires human confirmation. Pass best-effort args; the user will adjust them in UI before execution.` : baseDescription;
-            return {
-              scope: "CUSTOM",
-              execution: "backend",
-              defaultPermission: autoCall ? "ALLOW" : "ASK",
-              introduction: {
-                title: `Skill Hub: ${skill.get("title")}`,
-                about: skill.get("description") || `Th\u1EF1c thi k\u1EF9 n\u0103ng ${skill.get("title")}`
-              },
-              definition: {
-                name: `skill_hub_${sanitizedToolName}`,
-                description,
-                schema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), { type: "object", properties: {} })
-              },
-              invoke: async (toolCtx, args) => {
-                const latestSkill = await this.db.getRepository("skillDefinitions").findOne({
-                  filter: { id: skill.get("id"), enabled: true }
-                });
-                if (!latestSkill) {
-                  return { status: "error", content: `Skill "${skill.get("name")}" is no longer available` };
+IMPORTANT: This skill is bound to a Skill Hub human-in-the-loop review template. Pass best-effort args; the user can approve, edit, or reject them before execution.` : baseDescription;
+              return {
+                scope: "CUSTOM",
+                execution: "backend",
+                defaultPermission: requiresHumanReview ? "ASK" : autoCall ? "ALLOW" : "ASK",
+                introduction: {
+                  title: `Skill Hub: ${skill.get("title")}`,
+                  about: skill.get("description") || `Th\u1EF1c thi k\u1EF9 n\u0103ng ${skill.get("title")}`
+                },
+                definition: {
+                  name: `skill_hub_${sanitizedToolName}`,
+                  description,
+                  schema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), { type: "object", properties: {} })
+                },
+                invoke: async (toolCtx, args) => {
+                  const latestSkill = await this.db.getRepository("skillDefinitions").findOne({
+                    filter: { id: skill.get("id"), enabled: true }
+                  });
+                  if (!latestSkill) {
+                    return { status: "error", content: `Skill "${skill.get("name")}" is no longer available` };
+                  }
+                  const result = await this.executeSkill(latestSkill, args, toolCtx);
+                  return {
+                    status: result.status === "succeeded" ? "success" : "error",
+                    result
+                    // Attach raw result
+                  };
                 }
-                const result = await this.executeSkill(latestSkill, args, toolCtx);
-                return {
-                  status: result.status === "succeeded" ? "success" : "error",
-                  result
-                  // Attach raw result
-                };
-              }
-            };
-          }));
+              };
+            })
+          );
           register.registerTools(tools);
         } catch (err) {
           this.app.logger.warn("[skill-hub] Failed to provide dynamic tools", err);
@@ -616,7 +709,9 @@ IMPORTANT: This skill requires human confirmation. Pass best-effort args; the us
    */
   registerSkillTemplate(pluginName, skillDef) {
     this.skillTemplates.set(skillDef.name, this.hydrateSkillTemplate(pluginName, skillDef));
-    this.app.logger.info(`[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`);
+    this.app.logger.info(
+      `[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`
+    );
   }
   resolveSkillTemplate(templateName) {
     if (!templateName) return null;
@@ -644,7 +739,10 @@ IMPORTANT: This skill requires human confirmation. Pass best-effort args; the us
     const description = skill.get ? skill.get("description") : skill.description;
     const instructions = await this.getSkillInstructions(skill);
     const maxInlineInstructionChars = 24e3;
-    const inlineInstructions = instructions && instructions.length > maxInlineInstructionChars ? `${instructions.slice(0, maxInlineInstructionChars)}
+    const inlineInstructions = instructions && instructions.length > maxInlineInstructionChars ? `${instructions.slice(
+      0,
+      maxInlineInstructionChars
+    )}
 
 [Instructions truncated in tool description. Call skill_hub_execute with action="describe" and this skillName to load the complete workflow.]` : instructions;
     return [description, inlineInstructions ? `Instructions:

package/dist/server/skill-hub/tasks/SkillExecutionTask.d.ts

@@ -0,0 +1,16 @@
+import Application from '@nocobase/server';
+import { SandboxRunner } from '../../services/SandboxRunner';
+import { FileManager } from '../../services/FileManager';
+import { SkillRepositoryService } from '../../services/SkillRepositoryService';
+export declare class SkillExecutionTask {
+    private execution;
+    private sandboxRunner;
+    private fileManager;
+    private skillRepoService;
+    private app;
+    constructor(execution: any, sandboxRunner: SandboxRunner, fileManager: FileManager, skillRepoService: SkillRepositoryService, app: Application);
+    run(): Promise<void>;
+    private renderTemplate;
+    private installGeneratedSkillIfRequested;
+    private validateGeneratedSkillPackages;
+}

package/dist/server/skill-hub/tasks/SkillExecutionTask.js

@@ -163,6 +163,21 @@ class SkillExecutionTask {
         const fmPlugin = this.app.pm.get("@nocobase/plugin-file-manager");
         const attachment = await this.app.db.getRepository("attachments").findOne({ filter: { id: fileId } });
         if (fmPlugin && attachment) {
+          const rawStorageId = attachment.get("storageId") || attachment.storageId;
+          if (rawStorageId) {
+            const strId = String(rawStorageId);
+            let matchedKey = null;
+            for (const key of fmPlugin.storagesCache.keys()) {
+              if (String(key) === strId) {
+                matchedKey = key;
+                break;
+              }
+            }
+            if (matchedKey !== null) {
+              attachment.set("storageId", matchedKey);
+              attachment.storageId = matchedKey;
+            }
+          }
           try {
             const streamData = await fmPlugin.getFileStream(attachment);
             if (streamData == null ? void 0 : streamData.stream) {

package/dist/server/skill-hub/utils/json-fields.d.ts

@@ -0,0 +1,7 @@
+export declare function parseJsonText<T = any>(value: any, fallback: T): T;
+export declare function stringifyJsonText(value: any, fallback?: any): string;
+export declare function parseJsonLike(value: any, fallback: any): any;
+export declare function parseSkillMarkdown(markdown: string): {
+    metadata: Record<string, any>;
+    body: string;
+};

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

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+import { AgentLoopService } from '../services/AgentLoopService';
+export declare function createAgentLoopTools(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;
+            leaderUsername: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            messageId: 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">>;
+                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;
+                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;
+                maxAttempts?: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            leaderUsername?: string;
+            metadata?: any;
+            sessionId?: string;
+            goal?: string;
+            messageId?: string;
+            policy?: {
+                maxIterations?: number;
+                maxStepAttempts?: number;
+                allowReplan?: boolean;
+                requireVerification?: boolean;
+                stopOnApprovalRequired?: boolean;
+            };
+            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;
+                maxAttempts?: number;
+            }[];
+        }, {
+            leaderUsername?: string;
+            metadata?: any;
+            sessionId?: string;
+            goal?: string;
+            messageId?: string;
+            policy?: {
+                maxIterations?: number;
+                maxStepAttempts?: number;
+                allowReplan?: boolean;
+                requireVerification?: boolean;
+                stopOnApprovalRequired?: boolean;
+            };
+            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;
+                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: "ALLOW";
+    introduction: {
+        title: string;
+        about: string;
+    };
+    definition: {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            stepId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+            status: z.ZodEnum<["running", "succeeded", "failed", "skipped"]>;
+            output: z.ZodOptional<z.ZodAny>;
+            error: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            skillExecutionId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+            agentExecutionSpanId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+            metadata: z.ZodOptional<z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            error?: string;
+            status?: "running" | "succeeded" | "failed" | "skipped";
+            metadata?: any;
+            output?: any;
+            skillExecutionId?: string | number;
+            reason?: string;
+            stepId?: string | number;
+            agentExecutionSpanId?: string | number;
+        }, {
+            error?: string;
+            status?: "running" | "succeeded" | "failed" | "skipped";
+            metadata?: any;
+            output?: any;
+            skillExecutionId?: string | number;
+            reason?: string;
+            stepId?: string | number;
+            agentExecutionSpanId?: string | 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<{
+            stepId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+            reason: z.ZodOptional<z.ZodString>;
+            approval: z.ZodOptional<z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            reason?: string;
+            stepId?: string | number;
+            approval?: any;
+        }, {
+            reason?: string;
+            stepId?: string | number;
+            approval?: any;
+        }>;
+    };
+    invoke: (ctx: any, args: any) => Promise<{
+        status: "success" | "error";
+        content: string;
+    }>;
+})[];