@ai-setting/roy-agent-core 1.4.10 → 1.4.12

package/dist/env/workflow/types/index.js

@@ -0,0 +1,479 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/workflow/types/workflow.ts
+import { z } from "zod";
+async function getYamlParser() {
+  if (!yamlParser) {
+    yamlParser = await import("yaml");
+  }
+  return yamlParser;
+}
+async function parseWorkflowFile(content, filename) {
+  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
+  const isJson = filename.endsWith(".json");
+  let definition;
+  if (isYaml) {
+    const yaml = await getYamlParser();
+    definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
+  } else if (isJson) {
+    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+  } else {
+    try {
+      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+    } catch {
+      const yaml = await getYamlParser();
+      definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
+    }
+  }
+  return {
+    format: isYaml ? "yaml" : "json",
+    definition
+  };
+}
+function parseWorkflowFileSync(content, filename) {
+  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
+  const isJson = filename.endsWith(".json");
+  let definition;
+  if (isJson) {
+    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+  } else if (isYaml) {
+    throw new Error("Synchronous YAML parsing not supported. Use parseWorkflowFile() instead.");
+  } else {
+    try {
+      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+    } catch {
+      throw new Error("Cannot auto-detect format. Please use .yaml, .yml, or .json extension.");
+    }
+  }
+  return {
+    format: isJson ? "json" : "yaml",
+    definition
+  };
+}
+var DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema, yamlParser = null;
+var init_workflow = __esm(() => {
+  DependsOnSchema = z.array(z.string());
+  RetryConfigSchema = z.object({
+    max_attempts: z.number().min(1).default(1),
+    backoff: z.enum(["fixed", "exponential"]).default("exponential"),
+    initial_delay: z.number().min(0).default(1000)
+  });
+  NodeDefinitionSchema = z.object({
+    id: z.string().min(1, "Node ID is required"),
+    type: z.string().min(1, "Node type is required"),
+    name: z.string().optional(),
+    config: z.record(z.string(), z.unknown()).optional().default({}),
+    depends_on: z.array(z.string()).optional(),
+    condition: z.string().optional(),
+    retry: RetryConfigSchema.optional(),
+    timeout: z.number().optional()
+  });
+  WorkflowConfigSchema = z.object({
+    parallel_limit: z.number().nullable().optional(),
+    timeout: z.number().nullable().optional(),
+    retry: RetryConfigSchema.optional(),
+    debug: z.boolean().optional()
+  });
+  OutputDefinitionSchema = z.object({
+    name: z.string(),
+    source: z.string(),
+    path: z.string()
+  });
+  WorkflowMetadataSchema = z.object({
+    author: z.string().optional(),
+    taskId: z.number().optional(),
+    tags: z.array(z.string()).optional().default([]),
+    created_at: z.string().optional(),
+    updated_at: z.string().optional()
+  });
+  WorkflowDefinitionSchema = z.object({
+    name: z.string().min(1, "Workflow name is required"),
+    version: z.string().default("1.0"),
+    description: z.string().optional(),
+    config: WorkflowConfigSchema.optional().default({}),
+    nodes: z.array(NodeDefinitionSchema).min(1, "At least one node is required"),
+    entry: z.union([z.string(), z.array(z.string())]).default("__default_entry__"),
+    outputs: z.array(OutputDefinitionSchema).optional().default([]),
+    metadata: WorkflowMetadataSchema.optional().default({})
+  });
+});
+
+// packages/core/src/env/workflow/types/workflow-hil.ts
+function createNodeInterruptEvent(runId, nodeId, nodeType, query, agentSessionId) {
+  return {
+    type: "node.interrupt",
+    run_id: runId,
+    timestamp: Date.now(),
+    node_id: nodeId,
+    node_type: nodeType,
+    query,
+    ...agentSessionId ? { agent_session_id: agentSessionId } : {}
+  };
+}
+function createWorkflowAskUserEvent(runId, sessionId, nodeId, nodeType, query) {
+  return {
+    type: "workflow.ask-user",
+    run_id: runId,
+    timestamp: Date.now(),
+    session_id: sessionId,
+    node_id: nodeId,
+    node_type: nodeType,
+    query
+  };
+}
+var AskUserError;
+var init_workflow_hil = __esm(() => {
+  AskUserError = class AskUserError extends Error {
+    runId;
+    sessionId;
+    nodeId;
+    nodeType;
+    query;
+    agentSessionId;
+    timestamp;
+    type = "ask-user";
+    name = "AskUserError";
+    constructor(runId, sessionId, nodeId, nodeType, query, agentSessionId, timestamp = Date.now()) {
+      super(`[${nodeType}:${nodeId}] Ask user: ${query}`);
+      this.runId = runId;
+      this.sessionId = sessionId;
+      this.nodeId = nodeId;
+      this.nodeType = nodeType;
+      this.query = query;
+      this.agentSessionId = agentSessionId;
+      this.timestamp = timestamp;
+    }
+    toEvent() {
+      return {
+        type: "workflow.ask-user",
+        run_id: this.runId,
+        timestamp: this.timestamp,
+        session_id: this.sessionId,
+        node_id: this.nodeId,
+        node_type: this.nodeType,
+        query: this.query
+      };
+    }
+  };
+});
+
+// packages/core/src/env/workflow/types/workflow-message.ts
+import { z as z2 } from "zod";
+var WorkflowMessageRoleSchema;
+var init_workflow_message = __esm(() => {
+  init_workflow_hil();
+  WorkflowMessageRoleSchema = z2.enum([
+    "workflow.node.call",
+    "workflow.node.interrupt",
+    "workflow.node.result",
+    "workflow.node.resume"
+  ]);
+});
+
+// packages/core/src/env/workflow/types/workflow-session.ts
+function isWorkflowSessionMetadata(metadata) {
+  if (typeof metadata !== "object" || metadata === null || !("type" in metadata) || metadata.type !== "workflow") {
+    return false;
+  }
+  const m = metadata;
+  if (!m.workflowId || typeof m.workflowId !== "string") {
+    return false;
+  }
+  if (!m.workflowName || typeof m.workflowName !== "string") {
+    return false;
+  }
+  if (!m.status || typeof m.status !== "string") {
+    return false;
+  }
+  const validStatuses = ["running", "paused", "completed", "failed", "stopped"];
+  if (!validStatuses.includes(m.status)) {
+    return false;
+  }
+  return true;
+}
+function getWorkflowSessionStatus(metadata) {
+  return metadata.status || "running";
+}
+// packages/core/src/env/workflow/types/event.ts
+import { z as z3 } from "zod";
+function createWorkflowEvent(type, runId, data) {
+  return {
+    type,
+    run_id: runId,
+    timestamp: Date.now(),
+    ...data
+  };
+}
+var BaseEventSchema, WorkflowStartedEventSchema, WorkflowPausedEventSchema, WorkflowResumedEventSchema, WorkflowStoppedEventSchema, WorkflowCompletedEventSchema, WorkflowFailedEventSchema, WorkflowOutputEventSchema, NodeScheduledEventSchema, NodeStartedEventSchema, NodeProgressEventSchema, NodeCompletedEventSchema, NodeFailedEventSchema, NodeSkippedEventSchema, NodeDataEventSchema, NodeAddedEventSchema, NodeRemovedEventSchema, ControlPauseEventSchema, ControlResumeEventSchema, ControlStopEventSchema, NodeInterruptEventSchema, WorkflowAskUserEventSchema, WorkflowEventSchema;
+var init_event = __esm(() => {
+  BaseEventSchema = z3.object({
+    type: z3.string(),
+    run_id: z3.string(),
+    timestamp: z3.number()
+  });
+  WorkflowStartedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.started"),
+    workflow_name: z3.string(),
+    input: z3.record(z3.string(), z3.unknown()).optional()
+  });
+  WorkflowPausedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.paused")
+  });
+  WorkflowResumedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.resumed")
+  });
+  WorkflowStoppedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.stopped"),
+    reason: z3.string()
+  });
+  WorkflowCompletedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.completed"),
+    result: z3.record(z3.string(), z3.unknown()).optional(),
+    duration_ms: z3.number()
+  });
+  WorkflowFailedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.failed"),
+    error: z3.object({
+      message: z3.string(),
+      stack: z3.string().optional()
+    }),
+    failed_at: z3.string()
+  });
+  WorkflowOutputEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.output"),
+    output: z3.record(z3.string(), z3.unknown())
+  });
+  NodeScheduledEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.scheduled"),
+    node_id: z3.string()
+  });
+  NodeStartedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.started"),
+    node_id: z3.string(),
+    input: z3.any(),
+    agentSessionId: z3.string().optional(),
+    userResponse: z3.string().optional()
+  });
+  NodeProgressEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.progress"),
+    node_id: z3.string(),
+    progress: z3.number(),
+    message: z3.string().optional()
+  });
+  NodeCompletedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.completed"),
+    node_id: z3.string(),
+    output: z3.any(),
+    duration_ms: z3.number()
+  });
+  NodeFailedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.failed"),
+    node_id: z3.string(),
+    error: z3.object({
+      message: z3.string(),
+      stack: z3.string().optional()
+    })
+  });
+  NodeSkippedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.skipped"),
+    node_id: z3.string(),
+    reason: z3.string()
+  });
+  NodeDataEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.data"),
+    from_node: z3.string(),
+    to_node: z3.string(),
+    data: z3.any()
+  });
+  NodeAddedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.added"),
+    node_id: z3.string(),
+    node: z3.any()
+  });
+  NodeRemovedEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.removed"),
+    node_id: z3.string()
+  });
+  ControlPauseEventSchema = BaseEventSchema.extend({
+    type: z3.literal("control.pause")
+  });
+  ControlResumeEventSchema = BaseEventSchema.extend({
+    type: z3.literal("control.resume")
+  });
+  ControlStopEventSchema = BaseEventSchema.extend({
+    type: z3.literal("control.stop")
+  });
+  NodeInterruptEventSchema = BaseEventSchema.extend({
+    type: z3.literal("node.interrupt"),
+    node_id: z3.string(),
+    node_type: z3.string(),
+    query: z3.string()
+  });
+  WorkflowAskUserEventSchema = BaseEventSchema.extend({
+    type: z3.literal("workflow.ask-user"),
+    session_id: z3.string(),
+    node_id: z3.string(),
+    node_type: z3.string(),
+    query: z3.string()
+  });
+  WorkflowEventSchema = z3.union([
+    WorkflowStartedEventSchema,
+    WorkflowPausedEventSchema,
+    WorkflowResumedEventSchema,
+    WorkflowStoppedEventSchema,
+    WorkflowCompletedEventSchema,
+    WorkflowFailedEventSchema,
+    WorkflowOutputEventSchema,
+    NodeScheduledEventSchema,
+    NodeStartedEventSchema,
+    NodeProgressEventSchema,
+    NodeCompletedEventSchema,
+    NodeFailedEventSchema,
+    NodeSkippedEventSchema,
+    NodeDataEventSchema,
+    NodeAddedEventSchema,
+    NodeRemovedEventSchema,
+    ControlPauseEventSchema,
+    ControlResumeEventSchema,
+    ControlStopEventSchema,
+    NodeInterruptEventSchema,
+    WorkflowAskUserEventSchema
+  ]);
+});
+
+// packages/core/src/env/workflow/types/run.ts
+import { z as z4 } from "zod";
+function createNodeExecutionContext(params) {
+  return {
+    ...params,
+    askUser: (query) => {
+      throw new AskUserError(params.runId, params.sessionId, params.nodeId, "unknown", query);
+    }
+  };
+}
+var RunStatusSchema, NodeStatusSchema;
+var init_run = __esm(() => {
+  init_workflow_message();
+  RunStatusSchema = z4.enum([
+    "idle",
+    "running",
+    "paused",
+    "stopped",
+    "completed",
+    "failed"
+  ]);
+  NodeStatusSchema = z4.enum([
+    "pending",
+    "scheduled",
+    "started",
+    "running",
+    "completed",
+    "failed",
+    "skipped"
+  ]);
+});
+
+// packages/core/src/env/workflow/types/index.ts
+var init_types = __esm(() => {
+  init_run();
+  init_workflow();
+  init_workflow_message();
+  init_workflow_hil();
+  init_event();
+  init_run();
+});
+init_types();
+
+export {
+  parseWorkflowFileSync,
+  parseWorkflowFile,
+  isWorkflowSessionMetadata,
+  getWorkflowSessionStatus,
+  createWorkflowEvent,
+  createWorkflowAskUserEvent,
+  createNodeInterruptEvent,
+  createNodeExecutionContext,
+  WorkflowStoppedEventSchema,
+  WorkflowStartedEventSchema,
+  WorkflowResumedEventSchema,
+  WorkflowPausedEventSchema,
+  WorkflowOutputEventSchema,
+  WorkflowMetadataSchema,
+  WorkflowMessageRoleSchema,
+  WorkflowFailedEventSchema,
+  WorkflowEventSchema,
+  WorkflowDefinitionSchema,
+  WorkflowConfigSchema,
+  WorkflowCompletedEventSchema,
+  WorkflowAskUserEventSchema,
+  RunStatusSchema,
+  RetryConfigSchema,
+  OutputDefinitionSchema,
+  NodeStatusSchema,
+  NodeStartedEventSchema,
+  NodeSkippedEventSchema,
+  NodeScheduledEventSchema,
+  NodeRemovedEventSchema,
+  NodeProgressEventSchema,
+  NodeInterruptEventSchema,
+  NodeFailedEventSchema,
+  NodeDefinitionSchema,
+  NodeDataEventSchema,
+  NodeCompletedEventSchema,
+  NodeAddedEventSchema,
+  DependsOnSchema,
+  ControlStopEventSchema,
+  ControlResumeEventSchema,
+  ControlPauseEventSchema,
+  BaseEventSchema,
+  AskUserError
+};