plugin-agent-orchestrator 1.0.16 → 1.0.18

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;
+    }>;
+})[];

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

@@ -0,0 +1,406 @@
+/**
+ * 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, {
+  createAgentLoopTools: () => createAgentLoopTools
+});
+module.exports = __toCommonJS(agent_loop_exports);
+var import_zod = require("zod");
+var import_ExecutionSpanService = require("../services/ExecutionSpanService");
+const stepSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  key: import_zod.z.string().optional(),
+  planKey: import_zod.z.string().optional(),
+  parentStepId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+  title: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  type: import_zod.z.enum(["reasoning", "skill", "tool", "sub_agent", "verification"]).optional(),
+  target: import_zod.z.string().optional(),
+  input: import_zod.z.any().optional(),
+  dependsOn: import_zod.z.array(import_zod.z.string()).optional(),
+  maxAttempts: import_zod.z.number().int().min(1).max(10).optional(),
+  metadata: import_zod.z.any().optional()
+});
+const policySchema = import_zod.z.object({
+  maxIterations: import_zod.z.number().int().min(1).max(100).optional(),
+  maxStepAttempts: import_zod.z.number().int().min(1).max(10).optional(),
+  allowReplan: import_zod.z.boolean().optional(),
+  requireVerification: import_zod.z.boolean().optional(),
+  stopOnApprovalRequired: import_zod.z.boolean().optional()
+}).optional();
+function toolResult(status, payload) {
+  return {
+    status,
+    content: typeof payload === "string" ? payload : JSON.stringify(payload)
+  };
+}
+function valuesFromCtx(ctx) {
+  var _a, _b;
+  return ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) || {};
+}
+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 resolveSessionId(ctx, args) {
+  var _a, _b, _c;
+  const values = valuesFromCtx(ctx);
+  return (args == null ? void 0 : args.sessionId) || values.sessionId || ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.sessionId) || ((_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.sessionId);
+}
+function resolveMessageId(ctx, args) {
+  var _a, _b;
+  const values = valuesFromCtx(ctx);
+  return (args == null ? void 0 : args.messageId) || values.messageId || ((_b = (_a = ctx == null ? void 0 : ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.messageId);
+}
+function normalizeEmployeeUsername(raw) {
+  if (!raw) return null;
+  if (typeof raw === "string") return raw;
+  return raw.username || raw.aiEmployeeUsername || raw.name || null;
+}
+async function resolveLeaderUsername(ctx, plugin, args) {
+  var _a, _b, _c, _d, _e, _f;
+  const values = valuesFromCtx(ctx);
+  const direct = normalizeEmployeeUsername(
+    (args == null ? void 0 : args.leaderUsername) || (ctx == null ? void 0 : ctx._currentAIEmployee) || ((_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentAIEmployee) || ((_c = (_b = ctx == null ? void 0 : ctx.runtime) == null ? void 0 : _b.context) == null ? void 0 : _c.currentAIEmployee) || values.aiEmployee
+  );
+  if (direct) return direct;
+  const sessionId = resolveSessionId(ctx, args);
+  if (!sessionId) return void 0;
+  try {
+    const repo = ((_e = (_d = ctx == null ? void 0 : ctx.db) == null ? void 0 : _d.getRepository) == null ? void 0 : _e.call(_d, "aiConversations")) || plugin.db.getRepository("aiConversations");
+    const conversation = await repo.findOne({ filter: { sessionId } });
+    return normalizeEmployeeUsername((conversation == null ? void 0 : conversation.aiEmployeeUsername) || ((_f = conversation == null ? void 0 : conversation.get) == null ? void 0 : _f.call(conversation, "aiEmployeeUsername")));
+  } catch {
+    return void 0;
+  }
+}
+function setLoopTraceContext(ctx, snapshot, step) {
+  if (!ctx || !(snapshot == null ? void 0 : snapshot.run)) return;
+  const existing = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx) || {};
+  (0, import_ExecutionSpanService.setOrchestratorTraceContext)(ctx, {
+    ...existing,
+    rootRunId: snapshot.run.rootRunId || existing.rootRunId,
+    leaderUsername: snapshot.run.leaderUsername || existing.leaderUsername,
+    agentLoopRunId: String(snapshot.run.id),
+    agentLoopStepId: (step == null ? void 0 : step.id) ? String(step.id) : void 0
+  });
+}
+function planFromArgs(plan) {
+  return Array.isArray(plan) ? plan : [];
+}
+function createAgentLoopTools(plugin, service) {
+  return [
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Start",
+        about: "Create a persistent agent loop run and initial plan for a user goal."
+      },
+      definition: {
+        name: "agent_loop_start",
+        description: "Start a persistent agent loop run. Use this first when the user asks for a multi-step task. Provide a concrete plan with small executable steps before calling other tools.",
+        schema: import_zod.z.object({
+          goal: import_zod.z.string().min(1).describe("The user goal to complete."),
+          leaderUsername: import_zod.z.string().optional().describe("Leader AI employee username. Usually omit; inferred from chat."),
+          sessionId: import_zod.z.string().optional(),
+          messageId: import_zod.z.string().optional(),
+          policy: policySchema,
+          metadata: import_zod.z.any().optional(),
+          plan: import_zod.z.array(stepSchema).optional().describe("Initial plan steps. Use stable planKey values for dependencies.")
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const leaderUsername = await resolveLeaderUsername(ctx, plugin, args);
+          const snapshot = await service.createRun({
+            goal: args.goal,
+            leaderUsername,
+            sessionId: resolveSessionId(ctx, args),
+            messageId: resolveMessageId(ctx, args),
+            userId: currentUserId(ctx),
+            policy: args.policy,
+            metadata: args.metadata,
+            plan: planFromArgs(args.plan)
+          });
+          setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Status",
+        about: "Read the current run, steps, and next executable step."
+      },
+      definition: {
+        name: "agent_loop_status",
+        description: "Fetch an agent loop run. Call this before executing the next step so subsequent skill/tool calls can be linked to the current loop step.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const snapshot = await service.getRunSnapshot(args.runId);
+          setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Update Step",
+        about: "Move a plan step through running, succeeded, failed, or skipped states."
+      },
+      definition: {
+        name: "agent_loop_update_step",
+        description: 'Update one plan step after executing the corresponding skill/tool/sub-agent action. Use status="running" before the action and status="succeeded" or "failed" after it.',
+        schema: import_zod.z.object({
+          stepId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          status: import_zod.z.enum(["running", "succeeded", "failed", "skipped"]),
+          output: import_zod.z.any().optional(),
+          error: import_zod.z.string().optional(),
+          reason: import_zod.z.string().optional(),
+          skillExecutionId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+          agentExecutionSpanId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+          metadata: import_zod.z.any().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          let snapshot;
+          if (args.status === "running") {
+            snapshot = await service.startStep(args.stepId, {
+              userId: currentUserId(ctx),
+              agentExecutionSpanId: args.agentExecutionSpanId
+            });
+            const currentStep = snapshot.steps.find((step) => String(step.id) === String(args.stepId));
+            setLoopTraceContext(ctx, snapshot, currentStep);
+          } else if (args.status === "succeeded") {
+            snapshot = await service.completeStep(args.stepId, args.output === void 0 ? {} : args.output, {
+              userId: currentUserId(ctx),
+              skillExecutionId: args.skillExecutionId,
+              agentExecutionSpanId: args.agentExecutionSpanId,
+              metadata: args.metadata
+            });
+            setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          } else if (args.status === "failed") {
+            snapshot = await service.failStep(args.stepId, args.error || "Step failed.", {
+              userId: currentUserId(ctx),
+              metadata: args.metadata
+            });
+            setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          } else {
+            snapshot = await service.skipStep(args.stepId, args.reason || "Skipped.", {
+              userId: currentUserId(ctx)
+            });
+            setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          }
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Replan",
+        about: "Replace pending work or append new plan steps when execution needs a new path."
+      },
+      definition: {
+        name: "agent_loop_replan",
+        description: "Update the plan when a step fails, required context is missing, or a better execution path is discovered.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          reason: import_zod.z.string().optional(),
+          mode: import_zod.z.enum(["replace_pending", "append"]).optional(),
+          plan: import_zod.z.array(stepSchema).min(1)
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          await service.replan(args.runId, args.plan, {
+            reason: args.reason,
+            mode: args.mode || "replace_pending",
+            userId: currentUserId(ctx)
+          });
+          const snapshot = await service.getRunSnapshot(args.runId);
+          setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Request Approval",
+        about: "Pause a run and request user approval or edited input for a step."
+      },
+      definition: {
+        name: "agent_loop_request_approval",
+        description: "Pause the loop when a step needs user approval, user-edited input, or an ASK/human-review tool cannot run headlessly.",
+        schema: import_zod.z.object({
+          stepId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          reason: import_zod.z.string().optional(),
+          approval: import_zod.z.any().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const snapshot = await service.requestApproval(args.stepId, args.approval || {}, {
+            reason: args.reason,
+            userId: currentUserId(ctx)
+          });
+          setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Resume",
+        about: "Resume a waiting run after user approval or rejection."
+      },
+      definition: {
+        name: "agent_loop_resume",
+        description: "Resume a run that is waiting for user approval. Pass editedInput when the user changed step input.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          stepId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+          approved: import_zod.z.boolean(),
+          editedInput: import_zod.z.any().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const snapshot = await service.resumeRun(args.runId, {
+            stepId: args.stepId,
+            approved: args.approved,
+            editedInput: args.editedInput,
+            userId: currentUserId(ctx),
+            ctx
+          });
+          setLoopTraceContext(ctx, snapshot, snapshot.nextStep);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Finish",
+        about: "Finish a run with final answer and optional evidence."
+      },
+      definition: {
+        name: "agent_loop_finish",
+        description: 'Finish the agent loop after all required steps and verification are complete. Use status="failed" if the goal cannot be completed.',
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          finalAnswer: import_zod.z.string().optional(),
+          status: import_zod.z.enum(["succeeded", "failed"]).optional(),
+          summary: import_zod.z.string().optional(),
+          evidence: import_zod.z.any().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const snapshot = await service.finishRun(args.runId, args.finalAnswer || "", {
+            status: args.status || "succeeded",
+            summary: args.summary,
+            evidence: args.evidence,
+            userId: currentUserId(ctx)
+          });
+          setLoopTraceContext(ctx, snapshot);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    },
+    {
+      scope: "CUSTOM",
+      execution: "backend",
+      defaultPermission: "ALLOW",
+      introduction: {
+        title: "Agent Loop - Cancel",
+        about: "Cancel a run and skip unfinished steps."
+      },
+      definition: {
+        name: "agent_loop_cancel",
+        description: "Cancel an agent loop run. Use this when the user stops the task or the goal is no longer valid.",
+        schema: import_zod.z.object({
+          runId: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]),
+          reason: import_zod.z.string().optional()
+        })
+      },
+      invoke: async (ctx, args) => {
+        try {
+          const snapshot = await service.cancelRun(args.runId, {
+            reason: args.reason,
+            userId: currentUserId(ctx)
+          });
+          setLoopTraceContext(ctx, snapshot);
+          return toolResult("success", snapshot);
+        } catch (error) {
+          return toolResult("error", (error == null ? void 0 : error.message) || String(error));
+        }
+      }
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAgentLoopTools
+});