@ai-setting/roy-agent-core 1.5.81 → 1.5.84

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

@@ -1,428 +0,0 @@
-import {
-  AskUserError,
-  init_workflow_hil
-} from "./roy-agent-core-e25xkv53.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-shme7set.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 tag"),
-  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 by tag or keyword search. Returns workflow name, version, description, and tags.",
-    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;
-        const workflows = workflowService.listWorkflows(options);
-        return {
-          success: true,
-          output: JSON.stringify({
-            workflows: workflows.map((w) => ({
-              name: w.name,
-              version: w.version,
-              description: w.description,
-              tags: w.tags,
-              created_at: w.createdAt
-            })),
-            total: workflows.length,
-            count: 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/run-workflow.ts
-init_logger();
-import { z as z4 } from "zod";
-var logger3 = createLogger("run-workflow-tool");
-var RunWorkflowInputSchema = z4.object({
-  workflow_name: z4.string().describe("Name of the workflow to run"),
-  input: z4.record(z4.any()).optional().describe("Input to pass to the workflow"),
-  sync: z4.boolean().default(true).describe("Wait for completion (default: true)"),
-  timeout: z4.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;
-      logger3.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 (logger3?.error) {
-          logger3.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 z5 } from "zod";
-var logger4 = createLogger("workflow-run-status-tool");
-var WorkflowRunStatusInputSchema = z5.object({
-  run_id: z5.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) {
-        logger4.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 z6 } from "zod";
-var logger5 = createLogger("workflow-run-stop-tool");
-var WorkflowRunStopInputSchema = z6.object({
-  run_id: z6.string().describe("Run/session ID to stop"),
-  reason: z6.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) {
-        logger5.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, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };