@ai-setting/roy-agent-core 1.5.83 → 1.5.85

package/dist/shared/@ai-setting/roy-agent-core-r5axf0ad.js

@@ -0,0 +1,751 @@
+import {
+  TAG_MAX_COUNT,
+  TAG_MIN_COUNT
+} from "./roy-agent-core-tq9528d3.js";
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-k05v31rc.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/tools/ask-user-tool.ts
+init_workflow_hil();
+import { z } from "zod";
+var AskUserInputSchema = z.object({
+  query: z.string().describe("The question or request to ask the user"),
+  options: z.array(z.string()).optional().describe("Optional choices for the user"),
+  required_confirm: z.boolean().optional().describe("If true, user must explicitly confirm")
+});
+var askUserTool = {
+  name: "ask_user",
+  description: "Ask user for input or confirmation. Use this tool when you need user input or validation to continue the workflow.",
+  parameters: AskUserInputSchema,
+  async execute(args, context) {
+    const runId = context.metadata?.runId || "unknown";
+    const sessionId = context.metadata?.sessionId || `workflow_${runId}`;
+    const nodeId = context.metadata?.nodeId || "unknown";
+    let fullQuery = args.query;
+    if (args.options && args.options.length > 0) {
+      fullQuery = `${args.query} (选项: ${args.options.join(", ")})`;
+    }
+    throw new AskUserError(runId, sessionId, nodeId, "agent", fullQuery);
+  },
+  metadata: {
+    category: "workflow",
+    tags: ["human-in-loop", "user-input"],
+    version: "1.0.0"
+  }
+};
+var askUserToolInstance = askUserTool;
+
+// src/env/workflow/tools/workflow-get-tool.ts
+init_logger();
+import { z as z2 } from "zod";
+var logger = createLogger("workflow-get-tool");
+var WorkflowGetInputSchema = z2.object({
+  name: z2.string().optional().describe("Workflow name to get definition details"),
+  run_id: z2.string().optional().describe("Run/session ID to get run status")
+});
+function createWorkflowGetTool(workflowService) {
+  return {
+    name: "workflow_get",
+    description: "Get workflow definition details by name, or run status by run_id. Returns workflow name, version, description, inputs schema, and node list.",
+    parameters: WorkflowGetInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowGetInputSchema.parse(args);
+      try {
+        if (params.run_id) {
+          const session = await workflowService.getSession(params.run_id);
+          if (!session) {
+            return {
+              success: false,
+              output: "",
+              error: `Run not found: ${params.run_id}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          let messages = [];
+          try {
+            messages = await workflowService.getSessionMessages(params.run_id);
+          } catch {}
+          return {
+            success: true,
+            output: JSON.stringify({
+              run_id: session.id,
+              status: session.metadata?.status,
+              workflow_name: session.metadata?.workflowName,
+              workflow_version: session.metadata?.workflowVersion,
+              input: session.metadata?.input,
+              created_at: session.createdAt,
+              updated_at: session.updatedAt,
+              message_count: messages.length
+            }, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        if (params.name) {
+          const workflow = workflowService.getWorkflowByName(params.name);
+          if (!workflow) {
+            return {
+              success: false,
+              output: "",
+              error: `Workflow not found: ${params.name}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          return {
+            success: true,
+            output: JSON.stringify({
+              name: workflow.name,
+              version: workflow.version,
+              description: workflow.description,
+              inputs: workflow.definition.inputs,
+              definition: workflow.definition,
+              config: workflow.definition.config,
+              tags: workflow.tags,
+              created_at: workflow.createdAt,
+              updated_at: workflow.updatedAt
+            }, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: false,
+          output: "",
+          error: "Either 'name' or 'run_id' must be provided",
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger.error("Failed to get workflow info", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-list-tool.ts
+init_logger();
+import { z as z3 } from "zod";
+var logger2 = createLogger("workflow-list-tool");
+var WorkflowListInputSchema = z3.object({
+  tag: z3.string().optional().describe("Filter by single tag (legacy single-tag filter)"),
+  tags: z3.array(z3.string()).optional().describe("Filter by multiple tags (AND)"),
+  search: z3.string().optional().describe("Search workflows by keyword"),
+  limit: z3.number().positive().optional().describe("Maximum number of results to return"),
+  offset: z3.number().min(0).optional().describe("Offset for pagination")
+});
+function createWorkflowListTool(workflowService) {
+  return {
+    name: "workflow_list",
+    description: "List all registered workflows with optional filtering. " + "Returns `workflows`, `total` (filtered count regardless of pagination), `count` (returned count), " + "`limit`, `offset`, and `available_tags` (sorted by usage_count DESC). " + "Multi-tag filter uses AND logic. " + "\uD83D\uDCA1 TIP: The `available_tags` field tells you what tags already exist. " + "Before calling `workflow_add` with new tags, call `workflow_tag_list` to discover " + "existing tags and prefer reusing them for semantic consistency " + "(e.g. reuse 'ci-cd' rather than creating 'continuous-integration'). " + "Avoid tag proliferation is a design goal — limit the number of distinct tags in the pool.",
+    parameters: WorkflowListInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowListInputSchema.parse(args);
+      try {
+        const options = {};
+        if (params.tag !== undefined)
+          options.tag = params.tag;
+        if (params.search !== undefined)
+          options.search = params.search;
+        if (params.limit !== undefined)
+          options.limit = params.limit;
+        if (params.offset !== undefined)
+          options.offset = params.offset;
+        if (params.tags && params.tags.length > 0) {
+          const result2 = await workflowService.searchWorkflowsWithTags ? await workflowService.searchWorkflowsWithTags({
+            tags: params.tags,
+            limit: params.limit,
+            offset: params.offset
+          }) : { workflows: workflowService.searchWorkflows({ tags: params.tags, limit: params.limit, offset: params.offset }), available_tags: [], total: 0 };
+          return {
+            success: true,
+            output: JSON.stringify({
+              workflows: result2.workflows.map((w) => ({
+                name: w.name,
+                version: w.version,
+                description: w.description,
+                tags: w.tags,
+                created_at: w.createdAt
+              })),
+              available_tags: result2.available_tags,
+              total: result2.total,
+              count: result2.workflows.length,
+              limit: params.limit,
+              offset: params.offset
+            }, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const result = workflowService.listWorkflowsWithTags ? await workflowService.listWorkflowsWithTags(options) : {
+          workflows: workflowService.listWorkflows(options),
+          available_tags: [],
+          total: 0
+        };
+        return {
+          success: true,
+          output: JSON.stringify({
+            workflows: result.workflows.map((w) => ({
+              name: w.name,
+              version: w.version,
+              description: w.description,
+              tags: w.tags,
+              created_at: w.createdAt
+            })),
+            available_tags: result.available_tags,
+            total: result.total,
+            count: result.workflows.length,
+            limit: params.limit,
+            offset: params.offset
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger2.error("Failed to list workflows", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-tag-list-tool.ts
+init_logger();
+init_decorator();
+import { z as z4 } from "zod";
+var logger3 = createLogger("workflow-tag-list-tool");
+var WorkflowTagListInputSchema = z4.object({
+  sort_by: z4.enum(["usage_count", "name", "created_at"]).default("usage_count").describe("Sort field: usage_count (default), name, or created_at"),
+  order: z4.enum(["asc", "desc"]).default("desc").describe("Sort order: desc (default) or asc"),
+  limit: z4.number().int().positive().max(1000).optional().describe("Max number of tags to return (default 100, max 1000)")
+});
+
+class WorkflowTagListRunner {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  async run(options) {
+    if (typeof this.service.listTags !== "function") {
+      return { tags: [], total: 0 };
+    }
+    return await this.service.listTags(options);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("workflow.tool.tag_list", {
+    recordParams: true,
+    recordResult: false,
+    log: false
+  })
+], WorkflowTagListRunner.prototype, "run", null);
+function createWorkflowTagListTool(workflowService) {
+  const runner = new WorkflowTagListRunner(workflowService);
+  return {
+    name: "workflow_tag_list",
+    description: `List all existing workflow tags from the workflow_tags tag pool. ` + `⚠️ IMPORTANT: Call this tool BEFORE workflow_add to see available tags. ` + `When adding a new workflow, you should select tags from this pool to ensure ` + `semantic consistency. New tags will be auto-created if needed, but prefer existing ones. ` + `Returns tags sorted by usage_count DESC by default (most-used first).`,
+    parameters: WorkflowTagListInputSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const params = WorkflowTagListInputSchema.parse(args);
+        const result = await runner.run({
+          sortBy: params.sort_by,
+          order: params.order,
+          limit: params.limit
+        });
+        const output = {
+          tags: result.tags,
+          total: result.total,
+          hint: "Select 1-3 tags from this list when calling workflow_add. Existing tags ensure semantic consistency across workflows."
+        };
+        return {
+          success: true,
+          output: JSON.stringify(output, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger3.error("Failed to list workflow tags", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-add-tool.ts
+import { z as z5 } from "zod";
+init_logger();
+import yaml from "yaml";
+var logger4 = createLogger("workflow-add-tool");
+var WorkflowAddInputSchema = z5.object({
+  definition: z5.any().optional().describe("Workflow definition object (alternative to definition_yaml)"),
+  definition_yaml: z5.string().optional().describe("Workflow definition as YAML or JSON string"),
+  name: z5.string().min(1).optional().describe("Workflow name (must match definition.name when both provided)"),
+  description: z5.string().optional().describe("Workflow description (overrides definition_yaml description)"),
+  tags: z5.array(z5.string()).min(TAG_MIN_COUNT, `Workflow requires at least ${TAG_MIN_COUNT} tag`).max(TAG_MAX_COUNT, `Workflow supports at most ${TAG_MAX_COUNT} tags`).describe(`Tags (${TAG_MIN_COUNT}-${TAG_MAX_COUNT} required). ` + `STRONGLY RECOMMENDED: select from existing tag pool via workflow_tag_list ` + `to ensure semantic consistency. ` + `Format: lowercase or kebab-case preferred (e.g. "ai", "data-pipeline").`)
+});
+function parseDefinitionYaml(content) {
+  try {
+    const parsed = yaml.parse(content);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {}
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error("definition_yaml is not valid YAML or JSON");
+  }
+}
+function createWorkflowAddTool(workflowService) {
+  return {
+    name: "workflow_add",
+    description: `Create a new workflow. Tags are required (${TAG_MIN_COUNT}-${TAG_MAX_COUNT}). ` + `⚠️ IMPORTANT: Before calling this tool, you MUST call workflow_tag_list first ` + `to retrieve the existing tag pool. ` + `Select tags from this pool to ensure semantic consistency across workflows. ` + `New tags will be auto-created if not in the pool, but prefer existing ones when possible.`,
+    parameters: WorkflowAddInputSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const params = WorkflowAddInputSchema.parse(args);
+        if (!Array.isArray(params.tags) || params.tags.length === 0) {
+          return {
+            success: false,
+            output: "",
+            error: "Workflow requires at least 1 tag (got empty)",
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        for (let i = 0;i < params.tags.length; i++) {
+          const t = params.tags[i] ?? "";
+          if (typeof t !== "string" || t.trim().length === 0) {
+            return {
+              success: false,
+              output: "",
+              error: `tag at index ${i} is empty`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          if (t.includes(",")) {
+            return {
+              success: false,
+              output: "",
+              error: `tag "${t}" contains comma; pass them as separate --tags`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+        }
+        let definition = {};
+        if (params.definition && typeof params.definition === "object") {
+          if (params.definition.name && params.name && params.definition.name !== params.name) {
+            return {
+              success: false,
+              output: "",
+              error: `definition.name ('${params.definition.name}') does not match name ('${params.name}')`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          definition = params.definition;
+        } else if (params.definition_yaml) {
+          try {
+            definition = parseDefinitionYaml(params.definition_yaml);
+          } catch (e) {
+            return {
+              success: false,
+              output: "",
+              error: e instanceof Error ? e.message : String(e),
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+        } else {
+          return {
+            success: false,
+            output: "",
+            error: "definition is required (provide `definition` object, `definition_yaml`, or just `name`)",
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        if (params.name && !definition.name) {
+          definition.name = params.name;
+        }
+        if (params.description && !definition.description) {
+          definition.description = params.description;
+        }
+        if (!definition.name) {
+          return {
+            success: false,
+            output: "",
+            error: "definition must have a `name` field",
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const workflow = await workflowService.createWorkflow(definition, {
+          tags: params.tags
+        });
+        const availableTags = workflowService.tagRepository?.list?.()?.map((t) => ({
+          name: t.name,
+          count: t.usage_count
+        })) ?? [];
+        return {
+          success: true,
+          output: JSON.stringify({
+            workflow: {
+              name: workflow.name,
+              version: workflow.version,
+              description: workflow.description,
+              tags: workflow.tags,
+              created_at: workflow.createdAt
+            },
+            available_tags: availableTags
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        if (error && typeof error === "object" && "issues" in error && Array.isArray(error.issues)) {
+          const zodError = error;
+          const messages = zodError.issues.map((i) => i.message ?? "validation failed");
+          return {
+            success: false,
+            output: "",
+            error: messages.join("; "),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        logger4.error("Failed to add workflow", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-search-tool.ts
+init_logger();
+import { z as z6 } from "zod";
+var logger5 = createLogger("workflow-search-tool");
+var WorkflowSearchInputSchema = z6.object({
+  keyword: z6.string().optional().describe("Search keyword in name and description (case-insensitive substring)"),
+  tags: z6.array(z6.string()).optional().describe("Filter by tags (ALL must match - AND filter)"),
+  limit: z6.number().positive().optional().describe("Maximum number of results"),
+  offset: z6.number().min(0).optional().describe("Pagination offset")
+});
+function createWorkflowSearchTool(workflowService) {
+  return {
+    name: "workflow_search",
+    description: "Search workflows by keyword and/or tags. Multiple tags use AND filter. v2: returns available_tags so the caller knows what tags exist.",
+    parameters: WorkflowSearchInputSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const params = WorkflowSearchInputSchema.parse(args);
+        if (!params.keyword && (!params.tags || params.tags.length === 0)) {
+          return {
+            success: false,
+            output: "",
+            error: "At least one of 'keyword' or 'tags' must be provided",
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const result = await workflowService.searchWorkflowsWithTags({
+          keyword: params.keyword,
+          tags: params.tags,
+          limit: params.limit,
+          offset: params.offset
+        });
+        return {
+          success: true,
+          output: JSON.stringify({
+            workflows: result.workflows.map((w) => ({
+              name: w.name,
+              version: w.version,
+              description: w.description,
+              tags: w.tags,
+              createdAt: w.createdAt,
+              updatedAt: w.updatedAt
+            })),
+            available_tags: result.available_tags,
+            total: result.total,
+            count: result.workflows.length,
+            keyword: params.keyword,
+            tags: params.tags,
+            limit: params.limit,
+            offset: params.offset
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger5.error("Failed to search workflows", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/run-workflow.ts
+init_logger();
+import { z as z7 } from "zod";
+var logger6 = createLogger("run-workflow-tool");
+var RunWorkflowInputSchema = z7.object({
+  workflow_name: z7.string().describe("Name of the workflow to run"),
+  input: z7.record(z7.any()).optional().describe("Input to pass to the workflow"),
+  sync: z7.boolean().default(true).describe("Wait for completion (default: true)"),
+  timeout: z7.number().positive().optional().describe("Timeout in milliseconds (default: 1800000 = 30 min)")
+});
+function createRunWorkflowTool(workflowService) {
+  return {
+    name: "workflow_run",
+    description: "Run a workflow by name with optional input. Returns run_id, status, output, error, and duration_ms. Default timeout: 30 minutes.",
+    parameters: RunWorkflowInputSchema,
+    sandbox: {
+      enabled: false
+    },
+    permission: {
+      level: "safe"
+    },
+    metadata: {
+      category: "workflow",
+      tags: ["workflow", "execute", "run"],
+      version: "1.0.0",
+      experimental: false
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { workflow_name, input, sync = true, timeout = 1800000 } = args;
+      logger6.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
+      let timeoutHandle;
+      let durationMs;
+      try {
+        let result;
+        if (timeout) {
+          result = await Promise.race([
+            workflowService.runWorkflow(workflow_name, input, { sync }),
+            new Promise((_, reject) => {
+              timeoutHandle = setTimeout(() => {
+                reject(new Error("Workflow execution timed out"));
+              }, timeout);
+            })
+          ]);
+        } else {
+          result = await workflowService.runWorkflow(workflow_name, input, { sync });
+        }
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        durationMs = Date.now() - startTime;
+        if (sync) {
+          return {
+            success: result.status === "completed",
+            output: {
+              run_id: result.runId,
+              status: result.status,
+              output: result.output,
+              error: result.error,
+              duration_ms: result.durationMs || durationMs
+            },
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        } else {
+          return {
+            success: true,
+            output: {
+              run_id: result.runId,
+              status: result.status,
+              duration_ms: durationMs
+            },
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        }
+      } catch (error) {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        durationMs = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("Workflow not found")) {
+          return {
+            success: false,
+            output: "",
+            error: `Workflow not found: ${workflow_name}`,
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        }
+        if (errorMessage.includes("abort") || errorMessage.includes("timed out")) {
+          return {
+            success: false,
+            output: "",
+            error: `Workflow execution timed out or was aborted: ${workflow_name}`,
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        }
+        if (logger6?.error) {
+          logger6.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+        }
+        return {
+          success: false,
+          output: "",
+          error: `Failed to run workflow ${workflow_name}: ${errorMessage}`,
+          metadata: {
+            execution_time_ms: durationMs
+          }
+        };
+      }
+    }
+  };
+}
+var _runWorkflowTool = null;
+var _workflowService = null;
+function initRunWorkflowTool(workflowService) {
+  _workflowService = workflowService;
+  _runWorkflowTool = createRunWorkflowTool(workflowService);
+}
+function getRunWorkflowTool() {
+  if (!_runWorkflowTool || !_workflowService) {
+    throw new Error("workflow_run tool not initialized. Call initRunWorkflowTool(workflowService) first.");
+  }
+  return _runWorkflowTool;
+}
+function resetRunWorkflowTool() {
+  _runWorkflowTool = null;
+  _workflowService = null;
+}
+function createLegacyRunWorkflowTool(workflowService) {
+  const tool = createRunWorkflowTool(workflowService);
+  return {
+    ...tool,
+    name: "run-workflow"
+  };
+}
+
+// src/env/workflow/tools/workflow-run-status-tool.ts
+init_logger();
+import { z as z8 } from "zod";
+var logger7 = createLogger("workflow-run-status-tool");
+var WorkflowRunStatusInputSchema = z8.object({
+  run_id: z8.string().describe("Run/session ID to query status")
+});
+function createWorkflowRunStatusTool(workflowService) {
+  return {
+    name: "workflow_run_status",
+    description: "Query the status of a workflow run by run_id. Returns run_id, status, output, error, and progress information.",
+    parameters: WorkflowRunStatusInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowRunStatusInputSchema.parse(args);
+      try {
+        const session = await workflowService.getSession(params.run_id);
+        if (!session) {
+          return {
+            success: false,
+            output: "",
+            error: `Run not found: ${params.run_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const metadata = session.metadata;
+        let messages = [];
+        try {
+          messages = await workflowService.getSessionMessages(params.run_id);
+        } catch {}
+        return {
+          success: true,
+          output: JSON.stringify({
+            run_id: session.id,
+            title: session.title,
+            status: metadata?.status || "unknown",
+            workflow_name: metadata?.workflowName,
+            workflow_version: metadata?.workflowVersion,
+            input: metadata?.input,
+            created_at: session.createdAt,
+            updated_at: session.updatedAt,
+            message_count: messages.length
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger7.error("Failed to get run status", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-run-stop-tool.ts
+init_logger();
+import { z as z9 } from "zod";
+var logger8 = createLogger("workflow-run-stop-tool");
+var WorkflowRunStopInputSchema = z9.object({
+  run_id: z9.string().describe("Run/session ID to stop"),
+  reason: z9.string().optional().describe("Optional reason for stopping the workflow")
+});
+function createWorkflowRunStopTool(workflowService) {
+  return {
+    name: "workflow_run_stop",
+    description: "Stop a running workflow by run_id. Optionally provide a reason. Returns success status.",
+    parameters: WorkflowRunStopInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowRunStopInputSchema.parse(args);
+      try {
+        await workflowService.stopRun(params.run_id, params.reason);
+        return {
+          success: true,
+          output: JSON.stringify({
+            success: true,
+            run_id: params.run_id,
+            status: "stopped",
+            reason: params.reason || undefined
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger8.error("Failed to stop workflow run", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+export { AskUserInputSchema, askUserTool, askUserToolInstance, WorkflowGetInputSchema, createWorkflowGetTool, WorkflowListInputSchema, createWorkflowListTool, WorkflowTagListInputSchema, createWorkflowTagListTool, WorkflowAddInputSchema, createWorkflowAddTool, WorkflowSearchInputSchema, createWorkflowSearchTool, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };