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

package/dist/{env/workflow/engine/index.js → shared/chunk-rncy3rtd.js}

@@ -1,438 +1,28 @@
-// @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({})
-  });
-});
+import {
+  AgentComponentAdapter,
+  AskUserError,
+  createNodeInterruptEvent,
+  init_agent_component_adapter,
+  init_workflow_hil
+} from "./chunk-0q6s9wm6.js";
+import {
+  createLogger,
+  getMaxOutput,
+  init_logger,
+  simplifyFilePath
+} from "./chunk-a9qmy3sc.js";
+import {
+  getTracerProvider,
+  init_tracer_provider
+} from "./chunk-q9j99fsm.js";
+import {
+  __esm,
+  __export,
+  __legacyDecorateClassTS,
+  __require
+} from "./chunk-wbkh7wat.js";
 
-// 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();
-});
-
-// packages/core/src/env/workflow/engine/event-bus.ts
+// src/env/workflow/engine/event-bus.ts
 class EventBus {
   handlers = new Map;
   wildcardHandlers = new Set;
@@ -448,13 +38,13 @@ class EventBus {
   }
   once(eventType, handler) {
     let executed = false;
-    const wrappedHandler = async (event2) => {
+    const wrappedHandler = async (event) => {
       if (executed) {
         return;
       }
       executed = true;
       try {
-        await handler(event2);
+        await handler(event);
       } catch (error) {
         console.error("Event handler error:", error);
       }
@@ -477,26 +67,26 @@ class EventBus {
       this.wildcardHandlers.delete(handler);
     };
   }
-  async publish(event2, waitForHandlers = false) {
-    const handlers = this.handlers.get(event2.type);
+  async publish(event, waitForHandlers = false) {
+    const handlers = this.handlers.get(event.type);
     const handlerPromises = [];
     if (handlers) {
       for (const handler of handlers) {
-        const promise = this.executeHandler(handler, event2);
+        const promise = this.executeHandler(handler, event);
         handlerPromises.push(promise);
       }
     }
     for (const handler of this.wildcardHandlers) {
-      const promise = this.executeHandler(handler, event2);
+      const promise = this.executeHandler(handler, event);
       handlerPromises.push(promise);
     }
     if (waitForHandlers && handlerPromises.length > 0) {
       await Promise.allSettled(handlerPromises);
     }
   }
-  async executeHandler(handler, event2) {
+  async executeHandler(handler, event) {
     try {
-      await handler(event2);
+      await handler(event);
     } catch (error) {
       console.error("Event handler error:", error);
     }
@@ -518,20 +108,21 @@ class EventBus {
     };
   }
 }
+var init_event_bus = () => {};
 
-// packages/core/src/env/workflow/engine/dag-manager.ts
+// src/env/workflow/engine/dag-manager.ts
 class DAGManager {
   workflow;
   nodeMap;
   extendedDefinition = null;
   cachedAnalysis = null;
-  constructor(workflow2) {
-    if (!workflow2.nodes || workflow2.nodes.length === 0) {
+  constructor(workflow) {
+    if (!workflow.nodes || workflow.nodes.length === 0) {
       throw new Error("At least one node is required");
     }
-    this.workflow = workflow2;
+    this.workflow = workflow;
     this.nodeMap = new Map;
-    for (const node of workflow2.nodes) {
+    for (const node of workflow.nodes) {
       if (node.id === "") {
         throw new Error("Node ID cannot be empty");
       }
@@ -864,8 +455,9 @@ class DAGManager {
     return this.nodeMap.size;
   }
 }
+var init_dag_manager = () => {};
 
-// packages/core/src/env/workflow/engine/scheduler.ts
+// src/env/workflow/engine/scheduler.ts
 class Scheduler {
   dagManager;
   options;
@@ -1000,817 +592,273 @@ class Scheduler {
       if (this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId)) {
         continue;
       }
-      if (this.dagManager.areDependenciesMet(nodeId, allCompleted)) {
-        this.ready.add(nodeId);
-      }
-    }
-  }
-  getParallelLimit() {
-    return this.options.parallelLimit;
-  }
-  setParallelLimit(limit) {
-    this.options.parallelLimit = limit;
-  }
-}
-
-// packages/core/src/env/log-trace/span-storage.ts
-var exports_span_storage = {};
-__export(exports_span_storage, {
-  SQLiteSpanStorage: () => SQLiteSpanStorage
-});
-
-class SQLiteSpanStorage {
-  db = null;
-  dbPath;
-  initialized = false;
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
-    }
-    if (dbPath === ":memory:") {
-      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
-    }
-    this.dbPath = dbPath;
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const { Database } = __require("bun:sqlite");
-    const fs = __require("fs");
-    const path = __require("path");
-    const dir = path.dirname(this.dbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(this.dbPath);
-    this.db.run("PRAGMA journal_mode=WAL");
-    this.db.run("PRAGMA busy_timeout=5000");
-    this.db.run("PRAGMA synchronous=NORMAL");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS span (
-        span_id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        parent_span_id TEXT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        attributes TEXT,
-        result TEXT,
-        error TEXT,
-        time_created INTEGER NOT NULL
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
-    this.initialized = true;
-  }
-  save(span) {
-    if (!this.db)
-      return;
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO span 
-      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
-    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
-  }
-  saveBatch(spans) {
-    for (const span of spans) {
-      this.save(span);
-    }
-  }
-  findByTraceId(traceId) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
-    return this.buildTree(rows.map(this.rowToSpan));
-  }
-  findBySpanId(spanId) {
-    if (!this.db)
-      return;
-    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
-    return row ? this.rowToSpan(row) : undefined;
-  }
-  listTraces(limit = 10) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare(`
-      SELECT trace_id, 
-             MIN(start_time) as start_time,
-             MAX(end_time) as end_time,
-             COUNT(*) as span_count
-      FROM span 
-      GROUP BY trace_id 
-      ORDER BY start_time DESC 
-      LIMIT ?
-    `).all(limit);
-    return rows.map((row) => ({
-      traceId: row.trace_id,
-      rootSpanName: "unknown",
-      startTime: row.start_time,
-      endTime: row.end_time,
-      duration: row.end_time - row.start_time,
-      spanCount: row.span_count,
-      status: "ok"
-    }));
-  }
-  deleteByTraceId(traceId) {
-    if (this.db) {
-      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
-    }
-  }
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  rowToSpan(row) {
-    return {
-      traceId: row.trace_id,
-      spanId: row.span_id,
-      parentSpanId: row.parent_span_id,
-      name: row.name,
-      kind: row.kind,
-      status: row.status,
-      startTime: row.start_time,
-      endTime: row.end_time,
-      attributes: row.attributes ? JSON.parse(row.attributes) : {},
-      result: row.result || undefined,
-      error: row.error || undefined
-    };
-  }
-  buildTree(spans) {
-    const spanMap = new Map;
-    const roots = [];
-    for (const span of spans) {
-      spanMap.set(span.spanId, { ...span, children: [] });
-    }
-    for (const span of spanMap.values()) {
-      if (span.parentSpanId) {
-        const parent = spanMap.get(span.parentSpanId);
-        if (parent) {
-          parent.children.push(span);
-        } else {
-          roots.push(span);
-        }
-      } else {
-        roots.push(span);
-      }
-    }
-    return roots;
-  }
-}
-
-// packages/core/src/env/log-trace/opentelemetry/propagation.ts
-function padLeft(str, length) {
-  return str.padStart(length, "0");
-}
-function isValidHex(str) {
-  return /^[0-9a-f]+$/i.test(str);
-}
-function serialize(context2) {
-  const traceId = padLeft(context2.traceId.toLowerCase(), TRACE_ID_LENGTH);
-  const spanId = padLeft(context2.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
-  const parts = [
-    TRACE_CONTEXT_VERSION,
-    traceId,
-    spanId,
-    TRACE_FLAGS_SAMPLED
-  ];
-  return parts.join("-");
-}
-function parse(traceparent) {
-  if (!traceparent || typeof traceparent !== "string") {
-    return;
-  }
-  const trimmed = traceparent.trim();
-  const parts = trimmed.split("-");
-  if (parts.length !== 4) {
-    return;
-  }
-  const [version, traceId, senderSpanId, flags] = parts;
-  if (version !== TRACE_CONTEXT_VERSION) {
-    if (version > TRACE_CONTEXT_VERSION) {
-      return;
-    }
-  }
-  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
-    return;
-  }
-  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
-    return;
-  }
-  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
-    return;
-  }
-  return {
-    traceId: traceId.toLowerCase(),
-    spanId: senderSpanId.toLowerCase()
-  };
-}
-var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
-var init_propagation = __esm(() => {
-  propagation = {
-    inject(carrier, context2) {
-      carrier[TRACEPARENT_HEADER] = serialize(context2);
-    },
-    extract(carrier) {
-      const traceparent = carrier[TRACEPARENT_HEADER];
-      if (!traceparent) {
-        return;
-      }
-      return parse(traceparent);
-    },
-    getTraceparentHeader() {
-      return TRACEPARENT_HEADER;
-    }
-  };
-});
-
-// packages/core/src/env/log-trace/types.ts
-var SpanKind, SpanStatus;
-var init_types2 = __esm(() => {
-  ((SpanKind2) => {
-    SpanKind2["CLIENT"] = "client";
-    SpanKind2["SERVER"] = "server";
-    SpanKind2["INTERNAL"] = "internal";
-  })(SpanKind ||= {});
-  ((SpanStatus2) => {
-    SpanStatus2["OK"] = "ok";
-    SpanStatus2["ERROR"] = "error";
-  })(SpanStatus ||= {});
-});
-
-// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
-var exports_tracer_provider = {};
-__export(exports_tracer_provider, {
-  resetTracerProvider: () => resetTracerProvider,
-  getTracerProvider: () => getTracerProvider,
-  OTelTracerProvider: () => OTelTracerProvider
-});
-
-class OTelSpanImpl {
-  name;
-  kind;
-  spanContext;
-  attributes = {};
-  startTime;
-  endTime;
-  error;
-  storage;
-  parentSpanContext;
-  onEnd;
-  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
-    this.name = name;
-    this.kind = "internal";
-    this.spanContext = spanContext;
-    this.parentSpanContext = parentSpanContext;
-    this.startTime = Date.now();
-    this.storage = storage;
-    this.onEnd = onEnd;
-  }
-  setAttribute(key, value) {
-    this.attributes[key] = value;
-  }
-  addEvent(name, attributes) {
-    const events = this.attributes._events || [];
-    events.push({ name, attributes });
-    this.attributes._events = events;
-  }
-  end(result, error) {
-    this.endTime = Date.now();
-    if (error) {
-      this.error = error.message;
-    }
-    this.storage.save({
-      traceId: this.spanContext.traceId,
-      spanId: this.spanContext.spanId,
-      parentSpanId: this.spanContext.parentSpanId,
-      name: this.name,
-      kind: this.kind,
-      status: error ? "error" /* ERROR */ : "ok" /* OK */,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      attributes: this.attributes,
-      result,
-      error: this.error
-    });
-    this.onEnd?.();
-  }
-}
-
-class OTelTracerImpl {
-  name;
-  version;
-  storage;
-  currentContext;
-  activeSpans = new Map;
-  onSpanEndCallback;
-  provider;
-  constructor(name, version, storage, provider) {
-    this.name = name;
-    this.version = version;
-    this.storage = storage;
-    this.provider = provider;
-  }
-  setOnSpanEndCallback(callback) {
-    this.onSpanEndCallback = callback;
-  }
-  getActiveSpanCount() {
-    return this.activeSpans.size;
-  }
-  startSpan(name, options) {
-    const parentFromOptions = options?.parent;
-    const hasExplicitParent = options && "parent" in options;
-    const globalContext = this.provider.getGlobalContext();
-    let effectiveParentContext;
-    if (hasExplicitParent) {
-      effectiveParentContext = parentFromOptions;
-    } else if (this.currentContext) {
-      effectiveParentContext = this.currentContext;
-    } else if (globalContext) {
-      effectiveParentContext = globalContext;
-    }
-    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
-    const spanId = this.generateSpanId();
-    let parentSpanId;
-    if (hasExplicitParent && parentFromOptions) {
-      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
-    } else if (this.currentContext) {
-      parentSpanId = this.currentContext.spanId;
-    } else if (globalContext) {
-      parentSpanId = globalContext.spanId;
-    }
-    const spanContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    this.currentContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
-    if (options?.attributes) {
-      for (const [key, value] of Object.entries(options.attributes)) {
-        span.setAttribute(key, value);
-      }
-    }
-    this.activeSpans.set(spanId, span);
-    return span;
-  }
-  injectToEnv(env) {
-    if (this.currentContext) {
-      propagation.inject(env, this.currentContext);
-    }
-  }
-  getCurrentContext() {
-    return this.currentContext;
-  }
-  setCurrentContext(context2) {
-    this.currentContext = context2;
-  }
-  endSpan(span) {
-    const spanContext = span.spanContext;
-    this.activeSpans.delete(spanContext.spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (spanContext.parentSpanId) {
-      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
-      if (parentSpan) {
-        const parentContext = {
-          traceId: spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-      if (currentTraceId) {
-        const parentContext = {
-          traceId: currentTraceId,
-          spanId: spanContext.parentSpanId,
-          parentSpanId: undefined
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-    }
-    this.currentContext = undefined;
-    return;
-  }
-  generateTraceId() {
-    const timestamp = Date.now().toString(16).padStart(12, "0");
-    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
-    return (timestamp + random).slice(0, 32).padStart(32, "0");
-  }
-  generateSpanId() {
-    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
-  }
-  handleSpanEnd(spanId, parentSpanId) {
-    this.activeSpans.delete(spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (parentSpanId) {
-      const parentSpan = this.activeSpans.get(parentSpanId);
-      if (parentSpan) {
-        this.currentContext = {
-          traceId: parentSpan.spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        return;
-      }
-      if (currentTraceId) {
-        this.currentContext = {
-          traceId: currentTraceId,
-          spanId: parentSpanId,
-          parentSpanId: undefined
-        };
-        return;
-      }
-    }
-    this.currentContext = undefined;
-  }
-}
-
-class OTelTracerProvider {
-  tracers = new Map;
-  storage;
-  initialized = false;
-  globalContext;
-  constructor(storage, dbPath) {
-    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.storage.initialize();
-    this.initialized = true;
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  getGlobalContext() {
-    return this.globalContext;
-  }
-  setGlobalContext(context2) {
-    this.globalContext = context2;
-  }
-  getTracer(name, version) {
-    const key = `${name}@${version || "0.0.0"}`;
-    let tracer = this.tracers.get(key);
-    if (!tracer) {
-      tracer = new OTelTracerImpl(name, version, this.storage, this);
-      this.tracers.set(key, tracer);
-      if (this.initialized) {
-        this.restoreFromEnv(tracer);
-      }
-    }
-    return tracer;
-  }
-  restoreFromEnv(tracer) {
-    const extracted = propagation.extract(process.env);
-    if (extracted) {
-      tracer.setCurrentContext({
-        traceId: extracted.traceId,
-        spanId: extracted.spanId,
-        parentSpanId: undefined
-      });
-    }
-  }
-  shutdown() {
-    for (const tracer of this.tracers.values()) {}
-    this.tracers.clear();
-    this.storage.close();
-    this.initialized = false;
-    this.globalContext = undefined;
-    delete process.env["TRACEPARENT"];
-    delete process.env["TRACE_ID"];
-    delete process.env["LOG_TRACE_REQUEST_ID"];
-  }
-  getStorage() {
-    return this.storage;
-  }
-}
-function getTracerProvider() {
-  if (!providerInstance) {
-    providerInstance = new OTelTracerProvider;
-  }
-  return providerInstance;
-}
-function resetTracerProvider() {
-  if (providerInstance) {
-    providerInstance.shutdown();
-    providerInstance = null;
-  }
-}
-function getDefaultDbPath() {
-  const os = __require("os");
-  const path = __require("path");
-  const home = os.homedir();
-  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
-  return path.join(dataHome, "roy-agent", "traces.db");
-}
-var providerInstance = null;
-var init_tracer_provider = __esm(() => {
-  init_propagation();
-  init_types2();
-});
-
-// packages/core/src/env/log-trace/logger.ts
-import { appendFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-function simplifyFilePath(fullPath) {
-  let path = fullPath.replace(/\\/g, "/");
-  const bunfsMatch = path.match(/\/\$bunfs\/root\/(.+)$/);
-  if (bunfsMatch) {
-    const virtualPath = bunfsMatch[1];
-    const packagesMatch = virtualPath.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
-    if (packagesMatch) {
-      return packagesMatch[1];
-    }
-    return virtualPath;
-  }
-  const fileProtocolMatch = path.match(/@roy-agent\+core@file\+([^/]+)\/node_modules\/@roy-agent\/core\/(.+)$/);
-  if (fileProtocolMatch) {
-    const rootPkg = fileProtocolMatch[1].replace(/\+/g, "/");
-    const remaining = fileProtocolMatch[2];
-    const prefix = rootPkg;
-    const suffix = remaining.startsWith("src/") ? remaining : `src/${remaining}`;
-    return `${prefix}/${suffix}`;
-  }
-  const packagesRootMatch = path.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
-  if (packagesRootMatch) {
-    return packagesRootMatch[1];
-  }
-  const rootMarkers = ["packages/core/src", "packages/core", "packages"];
-  for (const marker of rootMarkers) {
-    const idx = path.indexOf(marker);
-    if (idx !== -1) {
-      return path.substring(idx);
-    }
-  }
-  return path;
-}
-function getDefaultLogDir() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  try {
-    const xdg = __require("xdg-basedir");
-    if (xdg.xdgData) {
-      return join(xdg.xdgData, "roy-agent", "logs");
-    }
-  } catch {}
-  return join(home, ".local", "share", "roy-agent", "logs");
-}
-function isQuietMode() {
-  return quietMode;
-}
-function setQuietMode(enabled) {
-  quietMode = enabled;
-}
-function setConfigComponent(component) {
-  configComponentInstance = component;
-}
-function getLogLevel() {
-  if (configComponentInstance) {
-    const level = configComponentInstance.get("log_trace.logging.level");
-    if (level && ["debug", "info", "warn", "error"].includes(level)) {
-      return level;
-    }
-  }
-  const envLevel = process.env.LOG_LEVEL;
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel;
-  }
-  return "info";
-}
-function getCategoryLogLevel(category) {
-  if (configComponentInstance) {
-    const levels = configComponentInstance.get("log_trace.logging.levels");
-    if (levels && typeof levels === "object") {
-      const categoryLevel = levels[category];
-      if (categoryLevel && ["debug", "info", "warn", "error"].includes(categoryLevel)) {
-        return categoryLevel;
-      }
-    }
-    const directLevel = configComponentInstance.get(`log_trace.logging.levels.${category}`);
-    if (directLevel && ["debug", "info", "warn", "error"].includes(directLevel)) {
-      return directLevel;
-    }
-  }
-  const envKey = `LOG_LEVEL_${category.toUpperCase().replace(/:/g, "_")}`;
-  const envLevel = process.env[envKey];
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel;
-  }
-  return getLogLevel();
-}
-function isAbsolutePath(path) {
-  if (path.startsWith("/")) {
-    return true;
-  }
-  if (/^[a-zA-Z]:[/\\]/.test(path)) {
-    return true;
-  }
-  return false;
-}
-function expandHomeDir(path) {
-  if (path.startsWith("~")) {
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    return join(home, path.slice(1));
-  }
-  return path;
-}
-function getLogFile() {
-  if (configComponentInstance) {
-    const file = configComponentInstance.get("log_trace.logging.file");
-    if (file) {
-      return file;
-    }
-  }
-  return "app.log";
-}
-function getLogDir() {
-  if (configComponentInstance) {
-    const dir = configComponentInstance.get("log_trace.logging.dir");
-    if (dir) {
-      return dir;
-    }
-  }
-  return getDefaultLogDir();
-}
-function getMaxOutput() {
-  if (configComponentInstance) {
-    const maxOutput = configComponentInstance.get("log-trace.logging.maxOutput");
-    if (typeof maxOutput === "number") {
-      return maxOutput;
-    }
-  }
-  return;
-}
-function setLogDirOverride(dir) {
-  logDirOverride = dir;
-}
-function getLogDirOverride() {
-  return logDirOverride;
-}
-
-class Logger {
-  prefix;
-  constructor(prefix) {
-    this.prefix = prefix;
-  }
-  shouldLog(level) {
-    const categoryLevel = getCategoryLogLevel(this.prefix);
-    return levelPriority[level] >= levelPriority[categoryLevel];
-  }
-  ensureLogDirectory(dir) {
-    if (!existsSync(dir)) {
-      try {
-        mkdirSync(dir, { recursive: true });
-      } catch (err) {
-        console.error("[Logger] Failed to create log directory:", dir, err);
-      }
-    }
-  }
-  getCallerLocation() {
-    const originalLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 10;
-    const err = new Error;
-    Error.captureStackTrace(err, this.formatMessage);
-    const stack = err.stack?.split(`
-`) || [];
-    Error.stackTraceLimit = originalLimit;
-    for (let i = 1;i < stack.length; i++) {
-      const line = stack[i];
-      if (line.includes("at ") && !line.includes("logger.ts") && !line.includes("formatMessage")) {
-        const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
-        if (match) {
-          const filePath = match[1];
-          const relativePath = this.getRelativePath(filePath);
-          return {
-            file: relativePath,
-            line: parseInt(match[2], 10)
-          };
-        }
-      }
-    }
-    return null;
-  }
-  getRelativePath(fullPath) {
-    return simplifyFilePath(fullPath);
-  }
-  formatMessage(level, message, data) {
-    const now = new Date;
-    const timestamp = now.toLocaleString("zh-CN", {
-      timeZone: "Asia/Shanghai",
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hour12: false
-    }).replace(/\//g, "-") + "." + String(now.getMilliseconds()).padStart(3, "0");
-    const prefix = this.prefix ? `[${this.prefix}]` : "";
-    let traceIdStr = "";
-    try {
-      const provider = getTracerProvider();
-      const tracer = provider.getTracer("roy-tracer");
-      const context2 = tracer.getCurrentContext();
-      if (context2?.traceId) {
-        traceIdStr = `[traceId=${context2.traceId}]`;
-      }
-    } catch {}
-    let locationStr = "";
-    if (data && typeof data === "object" && "callerLocation" in data) {
-      const logData = data;
-      locationStr = logData.callerLocation ? ` [${logData.callerLocation}]` : "";
-      const { callerLocation: _callerLocation, ...rest } = logData;
-      data = Object.keys(rest).length > 0 ? rest : undefined;
-    } else {
-      const location = this.getCallerLocation();
-      if (location) {
-        locationStr = ` [${location.file}:${location.line}]`;
-      }
-    }
-    let formatted = `${timestamp} [${level.toUpperCase()}]${traceIdStr}${locationStr}${prefix} ${message}`;
-    if (data !== undefined) {
-      if (typeof data === "object") {
-        formatted += " " + JSON.stringify(data).replace(/\n/g, "");
-      } else {
-        formatted += " " + String(data);
-      }
-    }
-    const maxOutput = getMaxOutput();
-    if (maxOutput && maxOutput > 0 && formatted.length > maxOutput) {
-      formatted = formatted.substring(0, maxOutput) + " [TRUNCATED]";
-    }
-    return formatted;
-  }
-  writeToFile(message) {
-    try {
-      const dir = getLogDir();
-      const filename = getLogFile();
-      const expandedDir = expandHomeDir(dir);
-      const resolvedDir = isAbsolutePath(expandedDir) ? expandedDir : join(process.cwd(), expandedDir);
-      this.ensureLogDirectory(resolvedDir);
-      const logFile = join(resolvedDir, filename);
-      appendFileSync(logFile, message + `
-`, "utf-8");
-    } catch (err) {
-      console.error("[Logger] Failed to write to log file:", err);
-    }
-  }
-  log(level, message, data) {
-    if (!this.shouldLog(level))
-      return;
-    const formatted = this.formatMessage(level, message, data);
-    this.writeToFile(formatted);
-    if (!isQuietMode()) {
-      const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.log : console.debug;
-      consoleMethod(formatted);
+      if (this.dagManager.areDependenciesMet(nodeId, allCompleted)) {
+        this.ready.add(nodeId);
+      }
     }
   }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  error(message, data) {
-    this.log("error", message, data);
+  getParallelLimit() {
+    return this.options.parallelLimit;
   }
-}
-function createLogger(prefix) {
-  if (!loggerCache.has(prefix)) {
-    loggerCache.set(prefix, new Logger(prefix));
+  setParallelLimit(limit) {
+    this.options.parallelLimit = limit;
   }
-  return loggerCache.get(prefix);
 }
-function getLogLevels() {
-  return ["debug", "info", "warn", "error"];
-}
-var configComponentInstance = null, quietMode = false, logDirOverride, levelPriority, loggerCache;
-var init_logger = __esm(() => {
-  init_tracer_provider();
-  levelPriority = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
+var init_scheduler = () => {};
+
+// src/env/workflow/types/event.ts
+import { z } from "zod";
+function createWorkflowEvent(type, runId, data) {
+  return {
+    type,
+    run_id: runId,
+    timestamp: Date.now(),
+    ...data
   };
-  loggerCache = new Map;
+}
+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 = z.object({
+    type: z.string(),
+    run_id: z.string(),
+    timestamp: z.number()
+  });
+  WorkflowStartedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.started"),
+    workflow_name: z.string(),
+    input: z.record(z.string(), z.unknown()).optional()
+  });
+  WorkflowPausedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.paused")
+  });
+  WorkflowResumedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.resumed")
+  });
+  WorkflowStoppedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.stopped"),
+    reason: z.string()
+  });
+  WorkflowCompletedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.completed"),
+    result: z.record(z.string(), z.unknown()).optional(),
+    duration_ms: z.number()
+  });
+  WorkflowFailedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.failed"),
+    error: z.object({
+      message: z.string(),
+      stack: z.string().optional()
+    }),
+    failed_at: z.string()
+  });
+  WorkflowOutputEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.output"),
+    output: z.record(z.string(), z.unknown())
+  });
+  NodeScheduledEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.scheduled"),
+    node_id: z.string()
+  });
+  NodeStartedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.started"),
+    node_id: z.string(),
+    input: z.any(),
+    agentSessionId: z.string().optional(),
+    userResponse: z.string().optional()
+  });
+  NodeProgressEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.progress"),
+    node_id: z.string(),
+    progress: z.number(),
+    message: z.string().optional()
+  });
+  NodeCompletedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.completed"),
+    node_id: z.string(),
+    output: z.any(),
+    duration_ms: z.number()
+  });
+  NodeFailedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.failed"),
+    node_id: z.string(),
+    error: z.object({
+      message: z.string(),
+      stack: z.string().optional()
+    })
+  });
+  NodeSkippedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.skipped"),
+    node_id: z.string(),
+    reason: z.string()
+  });
+  NodeDataEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.data"),
+    from_node: z.string(),
+    to_node: z.string(),
+    data: z.any()
+  });
+  NodeAddedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.added"),
+    node_id: z.string(),
+    node: z.any()
+  });
+  NodeRemovedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.removed"),
+    node_id: z.string()
+  });
+  ControlPauseEventSchema = BaseEventSchema.extend({
+    type: z.literal("control.pause")
+  });
+  ControlResumeEventSchema = BaseEventSchema.extend({
+    type: z.literal("control.resume")
+  });
+  ControlStopEventSchema = BaseEventSchema.extend({
+    type: z.literal("control.stop")
+  });
+  NodeInterruptEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.interrupt"),
+    node_id: z.string(),
+    node_type: z.string(),
+    query: z.string()
+  });
+  WorkflowAskUserEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.ask-user"),
+    session_id: z.string(),
+    node_id: z.string(),
+    node_type: z.string(),
+    query: z.string()
+  });
+  WorkflowEventSchema = z.union([
+    WorkflowStartedEventSchema,
+    WorkflowPausedEventSchema,
+    WorkflowResumedEventSchema,
+    WorkflowStoppedEventSchema,
+    WorkflowCompletedEventSchema,
+    WorkflowFailedEventSchema,
+    WorkflowOutputEventSchema,
+    NodeScheduledEventSchema,
+    NodeStartedEventSchema,
+    NodeProgressEventSchema,
+    NodeCompletedEventSchema,
+    NodeFailedEventSchema,
+    NodeSkippedEventSchema,
+    NodeDataEventSchema,
+    NodeAddedEventSchema,
+    NodeRemovedEventSchema,
+    ControlPauseEventSchema,
+    ControlResumeEventSchema,
+    ControlStopEventSchema,
+    NodeInterruptEventSchema,
+    WorkflowAskUserEventSchema
+  ]);
+});
+
+// src/env/workflow/types/workflow.ts
+import { z as z2 } from "zod";
+var DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema;
+var init_workflow = __esm(() => {
+  DependsOnSchema = z2.array(z2.string());
+  RetryConfigSchema = z2.object({
+    max_attempts: z2.number().min(1).default(1),
+    backoff: z2.enum(["fixed", "exponential"]).default("exponential"),
+    initial_delay: z2.number().min(0).default(1000)
+  });
+  NodeDefinitionSchema = z2.object({
+    id: z2.string().min(1, "Node ID is required"),
+    type: z2.string().min(1, "Node type is required"),
+    name: z2.string().optional(),
+    config: z2.record(z2.string(), z2.unknown()).optional().default({}),
+    depends_on: z2.array(z2.string()).optional(),
+    condition: z2.string().optional(),
+    retry: RetryConfigSchema.optional(),
+    timeout: z2.number().optional()
+  });
+  WorkflowConfigSchema = z2.object({
+    parallel_limit: z2.number().nullable().optional(),
+    timeout: z2.number().nullable().optional(),
+    retry: RetryConfigSchema.optional(),
+    debug: z2.boolean().optional()
+  });
+  OutputDefinitionSchema = z2.object({
+    name: z2.string(),
+    source: z2.string(),
+    path: z2.string()
+  });
+  WorkflowMetadataSchema = z2.object({
+    author: z2.string().optional(),
+    taskId: z2.number().optional(),
+    tags: z2.array(z2.string()).optional().default([]),
+    created_at: z2.string().optional(),
+    updated_at: z2.string().optional()
+  });
+  WorkflowDefinitionSchema = z2.object({
+    name: z2.string().min(1, "Workflow name is required"),
+    version: z2.string().default("1.0"),
+    description: z2.string().optional(),
+    config: WorkflowConfigSchema.optional().default({}),
+    nodes: z2.array(NodeDefinitionSchema).min(1, "At least one node is required"),
+    entry: z2.union([z2.string(), z2.array(z2.string())]).default("__default_entry__"),
+    outputs: z2.array(OutputDefinitionSchema).optional().default([]),
+    metadata: WorkflowMetadataSchema.optional().default({})
+  });
+});
+
+// src/env/workflow/types/workflow-message.ts
+import { z as z3 } from "zod";
+var WorkflowMessageRoleSchema;
+var init_workflow_message = __esm(() => {
+  init_workflow_hil();
+  WorkflowMessageRoleSchema = z3.enum([
+    "workflow.node.call",
+    "workflow.node.interrupt",
+    "workflow.node.result",
+    "workflow.node.resume"
+  ]);
+});
+
+// src/env/workflow/types/workflow-session.ts
+var init_workflow_session = () => {};
+
+// src/env/workflow/types/context.ts
+var init_context = () => {};
+
+// src/env/workflow/types/run.ts
+import { z as z4 } from "zod";
+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"
+  ]);
+});
+
+// src/env/workflow/types/index.ts
+var init_types = __esm(() => {
+  init_run();
+  init_workflow();
+  init_workflow_message();
+  init_workflow_session();
+  init_context();
+  init_workflow_hil();
+  init_event();
+  init_run();
 });
 
-// packages/core/src/env/log-trace/decorator.ts
+// src/env/log-trace/decorator.ts
 function Traced(options) {
   return function(target, propertyKey, descriptor) {
     const originalFn = descriptor.value;
@@ -1967,7 +1015,7 @@ var init_decorator = __esm(() => {
   init_logger();
 });
 
-// packages/core/src/env/workflow/engine/executor.ts
+// src/env/workflow/engine/executor.ts
 var Executor;
 var init_executor = __esm(() => {
   init_event();
@@ -2241,22 +1289,22 @@ var init_executor = __esm(() => {
     }
     summarizeResult(nodeId, output, error, durationMs) {
       if (error) {
-        return `\u274C ${nodeId} failed: ${error}`;
+        return `❌ ${nodeId} failed: ${error}`;
       }
       if (output === undefined || output === null) {
-        return `\u2705 ${nodeId} completed (${durationMs}ms)`;
+        return `✅ ${nodeId} completed (${durationMs}ms)`;
       }
       if (typeof output === "object") {
         const keys = Object.keys(output);
         if (keys.length === 0) {
-          return `\u2705 ${nodeId} completed (${durationMs}ms)`;
+          return `✅ ${nodeId} completed (${durationMs}ms)`;
         }
         const summary = keys.slice(0, 3).join(", ");
-        return `\u2705 ${nodeId}: ${summary} (${durationMs}ms)`;
+        return `✅ ${nodeId}: ${summary} (${durationMs}ms)`;
       }
       const strOutput = String(output);
       const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + "..." : strOutput;
-      return `\u2705 ${nodeId}: ${truncated} (${durationMs}ms)`;
+      return `✅ ${nodeId}: ${truncated} (${durationMs}ms)`;
     }
     async writeNodeResume(sessionId, response) {
       if (!this.sessionComponent)
@@ -2294,7 +1342,7 @@ var init_executor = __esm(() => {
   ], Executor.prototype, "writeNodeResume", null);
 });
 
-// packages/core/src/env/workflow/nodes/tool-node.ts
+// src/env/workflow/nodes/tool-node.ts
 class ToolNode {
   definition;
   toolRegistry;
@@ -2556,8 +1604,9 @@ class ToolNode {
     return str.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/"/g, "\\\"").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   }
 }
+var init_tool_node = () => {};
 
-// packages/core/src/env/workflow/nodes/skill-node.ts
+// src/env/workflow/nodes/skill-node.ts
 class SkillNode {
   definition;
   skillRegistry;
@@ -2754,8 +1803,9 @@ class SkillNode {
     return JSON.stringify(value);
   }
 }
+var init_skill_node = () => {};
 
-// packages/core/src/env/workflow/nodes/agent-node.ts
+// src/env/workflow/nodes/agent-node.ts
 var AgentNode;
 var init_agent_node = __esm(() => {
   init_workflow_hil();
@@ -3011,208 +2061,7 @@ var init_agent_node = __esm(() => {
   ], AgentNode.prototype, "createAgentSubSession", null);
 });
 
-// packages/core/src/env/workflow/nodes/agent-component-adapter.ts
-var exports_agent_component_adapter = {};
-__export(exports_agent_component_adapter, {
-  AgentComponentAdapter: () => AgentComponentAdapter
-});
-
-class AgentComponentAdapter {
-  agentComponent;
-  options;
-  _sessionComponent;
-  agentSessionPrefix = "agent";
-  _currentAgentSessionId;
-  pendingSessions = new Map;
-  runSessionToAgentSessions = new Map;
-  constructor(agentComponent, options = {}, _sessionComponent) {
-    this.agentComponent = agentComponent;
-    this.options = options;
-    this._sessionComponent = _sessionComponent;
-  }
-  setSessionComponent(sessionComponent) {
-    this._sessionComponent = sessionComponent;
-  }
-  getCurrentAgentSessionId() {
-    return this._currentAgentSessionId;
-  }
-  registerAgent(name, config) {
-    this.agentComponent.registerAgent(name, {
-      type: config.type || "general",
-      model: config.model,
-      systemPrompt: config.systemPrompt,
-      maxIterations: config.maxIterations,
-      allowedTools: config.allowedTools,
-      deniedTools: config.deniedTools,
-      timeout: config.timeout,
-      maxErrorRetries: config.maxErrorRetries
-    });
-    if (config.sessionIdPrefix) {
-      this.agentSessionPrefixes.set(name, config.sessionIdPrefix);
-    }
-  }
-  async run(config, resumeOptions) {
-    const startTime = Date.now();
-    const nodeId = config.nodeId || "unknown";
-    const runId = config.runId || "unknown";
-    const workflowSessionId = config.workflowSessionId;
-    const existingAgentSessionId = config.agentSessionId;
-    const resumeAgentSessionId = resumeOptions?.agentSessionId;
-    const isResume = !!resumeOptions?.userResponse || !!existingAgentSessionId || !!resumeAgentSessionId;
-    let agentSessionId;
-    if (isResume && (this._currentAgentSessionId || existingAgentSessionId || resumeAgentSessionId)) {
-      agentSessionId = resumeAgentSessionId || existingAgentSessionId || this._currentAgentSessionId;
-      if (resumeOptions?.userResponse && this._sessionComponent && agentSessionId) {
-        try {
-          await this._sessionComponent.addMessage(agentSessionId, {
-            role: "user",
-            content: resumeOptions.userResponse,
-            metadata: {
-              type: "user_intent",
-              intent: "workflow.resume",
-              workflowNodeId: nodeId
-            }
-          });
-        } catch (error) {
-          console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
-        }
-      }
-    } else {
-      if (this._sessionComponent) {
-        agentSessionId = `${this.agentSessionPrefix}_${runId}_${nodeId}_${Date.now()}`;
-        try {
-          await this._sessionComponent.create({
-            title: `Agent Session: ${config.type} (${agentSessionId})`,
-            metadata: {
-              type: "agent",
-              workflowRunId: runId,
-              workflowNodeId: nodeId
-            }
-          });
-          this._currentAgentSessionId = agentSessionId;
-          if (workflowSessionId) {
-            const mapping = this.runSessionToAgentSessions.get(workflowSessionId) || [];
-            mapping.push(agentSessionId);
-            this.runSessionToAgentSessions.set(workflowSessionId, mapping);
-          }
-          this.pendingSessions.set(agentSessionId, {
-            agentSessionId,
-            nodeId,
-            runId,
-            createdAt: Date.now()
-          });
-        } catch (error) {
-          console.warn(`Failed to create agent session ${agentSessionId}:`, error);
-        }
-      }
-    }
-    try {
-      const context2 = {};
-      if (config.options?.timeout) {
-        context2.abort = new AbortController;
-      }
-      if (agentSessionId) {
-        context2.sessionId = agentSessionId;
-      }
-      if (config.options?.allowedTools) {
-        context2.allowedTools = config.options.allowedTools;
-      }
-      if (config.options?.deniedTools) {
-        context2.deniedTools = config.options.deniedTools;
-      }
-      if (config.workflowHistory) {
-        context2.workflowHistory = config.workflowHistory;
-      }
-      const result = await this.agentComponent.run(config.type || "general", config.prompt, context2);
-      if (result.error?.startsWith("__ASK_USER_ERROR__:")) {
-        const jsonStr = result.error.substring("__ASK_USER_ERROR__:".length);
-        const errorInfo = JSON.parse(jsonStr);
-        throw new AskUserError(runId, errorInfo.sessionId, errorInfo.nodeId, errorInfo.nodeType || "agent", errorInfo.query);
-      }
-      const duration = Date.now() - startTime;
-      if (agentSessionId) {
-        this.pendingSessions.delete(agentSessionId);
-      }
-      const messages = result._messages || [];
-      return {
-        output: result.finalText || result.output,
-        metadata: {
-          duration,
-          iterations: result.iterations,
-          toolCalls: result.toolCalls?.length,
-          agentSessionId
-        },
-        messages
-      };
-    } catch (error) {
-      const isAskUserError = error instanceof Error && error.name === "AskUserError";
-      if (isAskUserError) {
-        throw error;
-      }
-      const duration = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (agentSessionId) {
-        this.pendingSessions.delete(agentSessionId);
-      }
-      return {
-        output: undefined,
-        metadata: {
-          duration,
-          error: errorMessage,
-          agentSessionId
-        }
-      };
-    } finally {
-      if (!isResume) {
-        this._currentAgentSessionId = undefined;
-      }
-    }
-  }
-  async resumeAgent(agentSessionId, userResponse, config) {
-    if (this._sessionComponent) {
-      try {
-        await this._sessionComponent.addMessage(agentSessionId, {
-          role: "user",
-          content: userResponse,
-          metadata: {
-            type: "user_intent",
-            intent: "workflow.resume"
-          }
-        });
-        this.pendingSessions.delete(agentSessionId);
-        this._currentAgentSessionId = agentSessionId;
-      } catch (error) {
-        console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
-      }
-    }
-    config.agentSessionId = agentSessionId;
-    return this.run(config, { userResponse });
-  }
-  getPendingSession(agentSessionId) {
-    return this.pendingSessions.get(agentSessionId);
-  }
-  getPendingSessionsForRun(runId) {
-    return Array.from(this.pendingSessions.values()).filter((session) => session.runId === runId);
-  }
-  getAgentSessionsForWorkflowSession(workflowSessionId) {
-    return this.runSessionToAgentSessions.get(workflowSessionId) || [];
-  }
-  hasAgent(name) {
-    return this.agentComponent.getAgent(name) !== undefined;
-  }
-  listAgents() {
-    return this.agentComponent.listAgents().map((a) => a.name);
-  }
-  getAgentComponent() {
-    return this.agentComponent;
-  }
-  agentSessionPrefixes = new Map;
-}
-var init_agent_component_adapter = __esm(() => {
-  init_workflow_hil();
-});
-
-// packages/core/src/env/workflow/nodes/workflow-node.ts
+// src/env/workflow/nodes/workflow-node.ts
 class WorkflowNode {
   workflowRunner;
   type = "workflow";
@@ -3345,8 +2194,9 @@ class WorkflowNode {
     return JSON.stringify(value);
   }
 }
+var init_workflow_node = () => {};
 
-// packages/core/src/env/workflow/nodes/ask-user-node.ts
+// src/env/workflow/nodes/ask-user-node.ts
 class AskUserNode {
   type = "ask_user";
   id;
@@ -3356,9 +2206,9 @@ class AskUserNode {
     this.config = definition.config || {};
   }
   async execute(context2) {
-    const query = this.config.query || "\u786E\u8BA4\u7EE7\u7EED\u5417\uFF1F";
+    const query = this.config.query || "确认继续吗？";
     const options = this.config.options;
-    const fullQuery = options ? `${query} (\u9009\u9879: ${options.join(", ")})` : query;
+    const fullQuery = options ? `${query} (选项: ${options.join(", ")})` : query;
     await context2.eventBus.publish(createNodeInterruptEvent(context2.runId, this.id, this.type, fullQuery));
     throw new AskUserError(context2.runId, context2.sessionId, this.id, this.type, query);
   }
@@ -3370,7 +2220,7 @@ var init_ask_user_node = __esm(() => {
   init_workflow_hil();
 });
 
-// packages/core/src/env/workflow/engine/node-registry.ts
+// src/env/workflow/engine/node-registry.ts
 class NodeRegistry {
   factories = new Map;
   toolRegistry;
@@ -3460,119 +2310,23 @@ class NodeRegistry {
   }
 }
 var init_node_registry = __esm(() => {
+  init_tool_node();
+  init_skill_node();
   init_agent_node();
   init_agent_component_adapter();
+  init_workflow_node();
   init_ask_user_node();
 });
 
-// packages/core/src/env/workflow/utils/session-recovery.ts
-var exports_session_recovery = {};
-__export(exports_session_recovery, {
-  parseNodeOutputs: () => parseNodeOutputs,
-  inferNextNode: () => inferNextNode,
-  hasPendingAskUser: () => hasPendingAskUser,
-  getAgentSessionIdFromInterrupt: () => getAgentSessionIdFromInterrupt,
-  findLastInterruptMessage: () => findLastInterruptMessage,
-  findLastCallMessage: () => findLastCallMessage
-});
-function inferNextNode(messages, definition) {
-  if (messages.length === 0) {
-    return { type: "entry_node", nodeId: definition.entryNode };
-  }
-  const lastMessage = messages[messages.length - 1];
-  const metadata = lastMessage.metadata;
-  switch (metadata?.type) {
-    case "workflow.node.call":
-      return {
-        type: "resume_node",
-        nodeId: metadata.workflowNodeId,
-        agentSessionId: metadata.agentSessionId
-      };
-    case "workflow.node.interrupt":
-      return {
-        type: "ask_user",
-        nodeId: metadata.workflowNodeId,
-        agentSessionId: metadata.agentSessionId
-      };
-    case "workflow.node.result":
-      return getNextNodes(metadata.workflowNodeId, definition);
-    default:
-      const lastCall = findLastCallMessage(messages);
-      if (lastCall) {
-        const callMetadata = lastCall.metadata;
-        return {
-          type: "resume_node",
-          nodeId: callMetadata.workflowNodeId,
-          agentSessionId: callMetadata.agentSessionId
-        };
-      }
-      return { type: "entry_node", nodeId: definition.entryNode };
-  }
-}
-function getNextNodes(completedNodeId, definition) {
-  if (!definition.edges) {
-    return { type: "next_nodes", nodeIds: [] };
-  }
-  const nextNodeIds = definition.edges.filter((edge) => edge.from === completedNodeId).map((edge) => edge.to);
-  return { type: "next_nodes", nodeIds: nextNodeIds };
-}
-function findLastInterruptMessage(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.metadata?.type === "workflow.node.interrupt") {
-      return msg;
-    }
-  }
-  return null;
-}
-function findLastCallMessage(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.metadata?.type === "workflow.node.call") {
-      return msg;
-    }
-  }
-  return null;
-}
-function parseNodeOutputs(messages) {
-  const outputs = new Map;
-  let lastCallNodeId = null;
-  for (const msg of messages) {
-    const metadata = msg.metadata;
-    if (metadata?.type === "workflow.node.call") {
-      lastCallNodeId = metadata.workflowNodeId;
-    } else if (metadata?.type === "workflow.node.result" && lastCallNodeId) {
-      try {
-        outputs.set(lastCallNodeId, JSON.parse(msg.content));
-      } catch {
-        outputs.set(lastCallNodeId, msg.content);
-      }
-      lastCallNodeId = null;
-    }
-  }
-  return outputs;
-}
-function hasPendingAskUser(messages) {
-  if (messages.length === 0)
-    return false;
-  const lastMessage = messages[messages.length - 1];
-  const metadata = lastMessage.metadata;
-  return metadata?.type === "workflow.node.interrupt";
-}
-function getAgentSessionIdFromInterrupt(messages) {
-  const lastInterrupt = findLastInterruptMessage(messages);
-  if (!lastInterrupt)
-    return null;
-  const metadata = lastInterrupt.metadata;
-  return metadata?.agentSessionId || null;
-}
-
-// packages/core/src/env/workflow/engine/engine.ts
+// src/env/workflow/engine/engine.ts
 import { EventEmitter } from "events";
 var logger, WorkflowEngine;
 var init_engine = __esm(() => {
   init_event();
   init_workflow_hil();
+  init_dag_manager();
+  init_event_bus();
+  init_scheduler();
   init_executor();
   init_node_registry();
   init_logger();
@@ -3691,10 +2445,10 @@ var init_engine = __esm(() => {
         return { runId: this.getRunIdFromSessionId(sessionId), status: "failed" };
       }
       const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const { inferNextNode: inferNextNode2 } = await Promise.resolve().then(() => exports_session_recovery);
+      const { inferNextNode } = await import("./chunk-25x2pdtp.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
-      const resumePoint = inferNextNode2(messages, {
+      const resumePoint = inferNextNode(messages, {
         entryNode: entryNode !== "__default_entry__" ? entryNode : undefined,
         edges: undefined
       });
@@ -4364,7 +3118,7 @@ var init_engine = __esm(() => {
   ], WorkflowEngine.prototype, "failWorkflow", null);
 });
 
-// packages/core/src/env/workflow/engine/index.ts
+// src/env/workflow/engine/index.ts
 var exports_engine = {};
 __export(exports_engine, {
   WorkflowEngine: () => WorkflowEngine,
@@ -4375,17 +3129,12 @@ __export(exports_engine, {
   DAGManager: () => DAGManager
 });
 var init_engine2 = __esm(() => {
+  init_event_bus();
+  init_dag_manager();
+  init_scheduler();
   init_executor();
   init_engine();
   init_node_registry();
 });
-init_engine2();
 
-export {
-  WorkflowEngine,
-  Scheduler,
-  NodeRegistry,
-  Executor,
-  EventBus,
-  DAGManager
-};
+export { Traced, TracedAs, TracedLightweight, wrapFunction, init_decorator, EventBus, DAGManager, Scheduler, Executor, NodeRegistry, WorkflowEngine, exports_engine, init_engine2 as init_engine };