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

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

@@ -0,0 +1,1631 @@
+// @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/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(context) {
+  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
+  const spanId = padLeft(context.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, context) {
+      carrier[TRACEPARENT_HEADER] = serialize(context);
+    },
+    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_types = __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(context) {
+    this.currentContext = context;
+  }
+  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(context) {
+    this.globalContext = context;
+  }
+  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_types();
+});
+
+// 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 context = tracer.getCurrentContext();
+      if (context?.traceId) {
+        traceIdStr = `[traceId=${context.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);
+    }
+  }
+  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);
+  }
+}
+function createLogger(prefix) {
+  if (!loggerCache.has(prefix)) {
+    loggerCache.set(prefix, new Logger(prefix));
+  }
+  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
+  };
+  loggerCache = new Map;
+});
+
+// packages/core/src/env/log-trace/decorator.ts
+function Traced(options) {
+  return function(target, propertyKey, descriptor) {
+    const originalFn = descriptor.value;
+    const spanName = options?.name || propertyKey;
+    descriptor.value = wrapFunction(originalFn, spanName, {
+      recordParams: options?.recordParams ?? true,
+      recordResult: options?.recordResult ?? false,
+      recordError: options?.recordError ?? true,
+      log: options?.log ?? false,
+      maxLogSize: options?.maxLogSize,
+      paramFilter: options?.paramFilter
+    });
+    return descriptor;
+  };
+}
+function TracedAs(name, options) {
+  return Traced({ name, ...options });
+}
+function TracedLightweight(options) {
+  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
+}
+function wrapFunction(fn, name, options) {
+  const shouldLog = options?.log ?? false;
+  const getMaxLogSize = () => {
+    if (options?.maxLogSize !== undefined) {
+      return options.maxLogSize;
+    }
+    const configMaxOutput = getMaxOutput();
+    return configMaxOutput !== undefined ? configMaxOutput : 500;
+  };
+  const truncate = (obj) => {
+    if (obj === undefined)
+      return;
+    if (obj === null)
+      return null;
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    if (maxLogSize > 0 && str.length > maxLogSize) {
+      return str.slice(0, maxLogSize) + " [TRUNCATED]";
+    }
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  };
+  const truncateString = (obj) => {
+    if (obj === undefined)
+      return "undefined";
+    if (obj === null)
+      return "null";
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
+  };
+  const TRACE_LOG_PREFIX = "[TRACE]";
+  const getCallerLocation = () => {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 15;
+    const err = new Error;
+    Error.captureStackTrace(err, getCallerLocation);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
+        continue;
+      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+      if (match) {
+        const filePath = match[1];
+        if (!filePath || filePath === "native")
+          continue;
+        const relativePath = simplifyFilePath(filePath);
+        return `${relativePath}:${match[2]}`;
+      }
+    }
+    return "";
+  };
+  const logFn = (event, argsOrData, callerLocation) => {
+    if (!shouldLog)
+      return;
+    const logger = createLogger("traced:" + name);
+    const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
+    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
+    const originalFnLocation = callerLocation || getCallerLocation();
+    const logMessage = (msg, data) => {
+      if (data !== undefined) {
+        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
+      } else {
+        logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
+      }
+    };
+    if (event === "enter") {
+      logMessage("enter", argsOrData);
+    } else if (event === "quit") {
+      logMessage("quit", options?.recordResult ? argsOrData : undefined);
+    } else {
+      logMessage("error", argsOrData);
+    }
+  };
+  return function(...args) {
+    const tracer = getTracerProvider().getTracer("roy-tracer");
+    const attributes = {};
+    if (options?.recordParams !== false) {
+      if (options?.paramFilter) {
+        attributes["params"] = truncate(options.paramFilter(args));
+      } else {
+        attributes["params"] = truncate(args);
+      }
+    }
+    const callerLocation = getCallerLocation();
+    logFn("enter", args, callerLocation);
+    const span = tracer.startSpan(name, { attributes });
+    try {
+      const result = fn.call(this, ...args);
+      if (result && typeof result === "object" && typeof result.then === "function") {
+        return result.then((resolved) => {
+          span.setAttribute("result", JSON.stringify(truncate(resolved)));
+          span.end(resolved);
+          logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
+          return resolved;
+        }, (rejected) => {
+          span.setAttribute("error", String(rejected));
+          span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
+          logFn("error", rejected.message, callerLocation);
+          throw rejected;
+        });
+      }
+      span.setAttribute("result", JSON.stringify(truncate(result)));
+      span.end(result);
+      logFn("quit", options?.recordResult ? result : undefined, callerLocation);
+      return result;
+    } catch (error) {
+      span.setAttribute("error", String(error));
+      span.end(undefined, error instanceof Error ? error : new Error(String(error)));
+      logFn("error", error.message, callerLocation);
+      throw error;
+    }
+  };
+}
+var init_decorator = __esm(() => {
+  init_tracer_provider();
+  init_logger();
+});
+
+// packages/core/src/env/workflow/utils/template-resolver.ts
+class TemplateResolver {
+  input;
+  previousOutputs;
+  constructor(options = {}) {
+    this.input = options.input ?? {};
+    this.previousOutputs = options.previousOutputs ?? new Map;
+  }
+  static fromContext(context) {
+    return new TemplateResolver({
+      input: context.input,
+      previousOutputs: context.previousOutputs
+    });
+  }
+  resolveValue(input) {
+    if (input === null || input === undefined) {
+      return input;
+    }
+    if (typeof input === "string") {
+      const pureTemplate = this.extractPureTemplate(input);
+      if (pureTemplate) {
+        return this.resolvePureTemplate(pureTemplate);
+      }
+      return this.resolveString(input);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.resolveValue(item));
+    }
+    if (typeof input === "object") {
+      const resolved = {};
+      for (const [key, value] of Object.entries(input)) {
+        resolved[key] = this.resolveValue(value);
+      }
+      return resolved;
+    }
+    return input;
+  }
+  extractPureTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && trimmed.length > 4) {
+      const content = trimmed.slice(2, -2).trim();
+      if (!content.includes("{{") && !content.includes("}}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  resolvePureTemplate(templateContent) {
+    const value = this.resolveTemplateContent(templateContent);
+    return value;
+  }
+  resolveTemplateContent(templateContent) {
+    const trimmed = templateContent.trim();
+    if (trimmed.startsWith("input.")) {
+      return this.getNestedValue(this.input, trimmed.slice(6));
+    }
+    if (trimmed.startsWith("nodes.")) {
+      return this.resolveNodePath(trimmed.slice(6));
+    }
+    if (trimmed !== "input" && trimmed !== "nodes") {
+      const segments = trimmed.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      return this.resolveNodePath(`${nodeId}${restPath ? "." + restPath : ""}`);
+    }
+    return;
+  }
+  resolveString(template) {
+    if (!template || typeof template !== "string") {
+      return template;
+    }
+    let resolved = template;
+    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.getNestedValue(this.input, path);
+      return this.stringify(value, match);
+    });
+    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.resolveNodePath(path);
+      return this.stringify(value, match);
+    });
+    resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_-]*)(?:\.([^}]+))?\}\}/g, (match, nodeId, path) => {
+      if (nodeId === "input") {
+        return match;
+      }
+      if (nodeId === "nodes") {
+        return match;
+      }
+      const value = this.resolveNodePath(`${nodeId}${path ? "." + path : ""}`);
+      return this.stringify(value, match);
+    });
+    return resolved;
+  }
+  resolveNodePath(path) {
+    const segments = path.split(".");
+    const nodeId = segments[0];
+    if (!nodeId) {
+      return;
+    }
+    let value = this.previousOutputs.get(nodeId);
+    if (value === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        value = this.previousOutputs.get(normalizedUnderscore);
+      }
+      if (value === undefined && normalizedHyphen !== nodeId) {
+        value = this.previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (value === undefined) {
+      return;
+    }
+    if (segments.length === 1) {
+      if (value && typeof value === "object" && "result" in value && !("nodes" in value)) {
+        value = value.result;
+      }
+      return value;
+    }
+    const secondSegment = segments[1];
+    if (secondSegment === "result" || secondSegment === "output") {
+      if (value && typeof value === "object" && "result" in value) {
+        value = value.result;
+        if (segments.length === 2) {
+          return value;
+        }
+        for (let i = 2;i < segments.length; i++) {
+          if (value === null || value === undefined) {
+            return;
+          }
+          value = value[segments[i]];
+        }
+        return value;
+      }
+    }
+    for (let i = 1;i < segments.length; i++) {
+      if (value === null || value === undefined) {
+        return;
+      }
+      value = value[segments[i]];
+    }
+    return value;
+  }
+  getNestedValue(obj, path) {
+    if (!obj || !path) {
+      return;
+    }
+    const segments = path.split(".");
+    let current = obj;
+    for (const segment of segments) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      if (typeof current !== "object") {
+        return;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  stringify(value, originalTemplate) {
+    if (value === undefined) {
+      return originalTemplate;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value === null) {
+      return "null";
+    }
+    return JSON.stringify(value);
+  }
+  containsTemplates(str) {
+    if (typeof str !== "string") {
+      return false;
+    }
+    return /\{\{[^}]+\}\}/.test(str);
+  }
+  extractTemplates(str) {
+    if (typeof str !== "string") {
+      return [];
+    }
+    const matches = str.match(/\{\{[^}]+\}\}/g);
+    return matches ?? [];
+  }
+}
+function resolveTemplates(input, context) {
+  const resolver = TemplateResolver.fromContext(context);
+  return resolver.resolveValue(input);
+}
+function resolveTemplateString(template, context) {
+  const resolver = TemplateResolver.fromContext(context);
+  return resolver.resolveString(template);
+}
+// packages/core/src/env/workflow/utils/recovery-validator.ts
+init_decorator();
+
+// packages/core/src/env/workflow/utils/validation-rules.ts
+var ValidationErrorType;
+((ValidationErrorType2) => {
+  ValidationErrorType2["MISSING_VARIABLE"] = "MISSING_VARIABLE";
+  ValidationErrorType2["INCOMPLETE_PARALLEL"] = "INCOMPLETE_PARALLEL";
+  ValidationErrorType2["AMBIGUOUS_BRANCH"] = "AMBIGUOUS_BRANCH";
+  ValidationErrorType2["LOOP_STATE_LOST"] = "LOOP_STATE_LOST";
+  ValidationErrorType2["NESTED_WORKFLOW_INVALID"] = "NESTED_WORKFLOW_INVALID";
+  ValidationErrorType2["NODE_STATE_INCONSISTENT"] = "NODE_STATE_INCONSISTENT";
+  ValidationErrorType2["MISSING_DEPENDENCY"] = "MISSING_DEPENDENCY";
+})(ValidationErrorType ||= {});
+var SuggestedAction;
+((SuggestedAction2) => {
+  SuggestedAction2["RE_RUN"] = "RE_RUN";
+  SuggestedAction2["CONFIRM"] = "CONFIRM";
+  SuggestedAction2["SKIP"] = "SKIP";
+  SuggestedAction2["PROVIDE_VALUE"] = "PROVIDE_VALUE";
+  SuggestedAction2["IGNORE"] = "IGNORE";
+})(SuggestedAction ||= {});
+
+// packages/core/src/env/workflow/utils/execution-state.ts
+init_decorator();
+class ExecutionStateBuilder {
+  build(messages, definition) {
+    const state = {
+      completedNodes: new Set,
+      inProgressNodes: new Set,
+      pendingNodes: new Set,
+      nodeOutputs: new Map,
+      nodeInputs: new Map,
+      variables: new Map,
+      loopCounts: new Map
+    };
+    this.parseMessages(messages, state);
+    this.buildPendingNodes(definition, state);
+    return state;
+  }
+  parseMessages(messages, state) {
+    let lastCallNodeId = null;
+    let lastCallInput = null;
+    for (const msg of messages) {
+      const metadata = msg.metadata;
+      const msgType = metadata?.type;
+      switch (msgType) {
+        case "workflow.node.call": {
+          const nodeId = metadata?.workflowNodeId;
+          if (nodeId) {
+            lastCallNodeId = nodeId;
+            lastCallInput = this.extractInput(msg);
+            state.inProgressNodes.add(nodeId);
+            state.nodeInputs.set(nodeId, lastCallInput);
+          }
+          break;
+        }
+        case "workflow.node.result": {
+          if (lastCallNodeId) {
+            state.inProgressNodes.delete(lastCallNodeId);
+            state.completedNodes.add(lastCallNodeId);
+            const output = this.extractOutput(msg);
+            state.nodeOutputs.set(lastCallNodeId, output);
+            this.extractVariables(output, state);
+            lastCallNodeId = null;
+            lastCallInput = null;
+          }
+          break;
+        }
+        case "workflow.node.interrupt": {
+          if (lastCallNodeId) {
+            state.inProgressNodes.add(lastCallNodeId);
+          }
+          break;
+        }
+        case "workflow.node.resume": {
+          if (lastCallNodeId) {
+            state.inProgressNodes.add(lastCallNodeId);
+          }
+          break;
+        }
+      }
+    }
+  }
+  buildPendingNodes(definition, state) {
+    const nodeIds = new Set((definition.nodes || []).map((n) => n.id));
+    const allNodeIds = Array.from(nodeIds);
+    const entryNodes = this.getEntryNodes(definition);
+    for (const entryNode of entryNodes) {
+      if (!state.completedNodes.has(entryNode)) {
+        this.markPendingFromNode(entryNode, definition, state);
+      }
+    }
+    for (const completedId of state.completedNodes) {
+      const children = this.getDirectChildren(completedId, definition);
+      for (const childId of children) {
+        if (!state.completedNodes.has(childId) && !state.inProgressNodes.has(childId)) {
+          state.pendingNodes.add(childId);
+        }
+      }
+    }
+  }
+  getEntryNodes(definition) {
+    const entry = definition.entry;
+    if (!entry) {
+      return [];
+    }
+    if (Array.isArray(entry)) {
+      return entry;
+    }
+    return [entry];
+  }
+  markPendingFromNode(startNodeId, definition, state) {
+    const visited = new Set;
+    const queue = [startNodeId];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      if (visited.has(nodeId)) {
+        continue;
+      }
+      visited.add(nodeId);
+      if (!state.completedNodes.has(nodeId)) {
+        state.pendingNodes.add(nodeId);
+      }
+      const children = this.getDirectChildren(nodeId, definition);
+      for (const childId of children) {
+        if (!visited.has(childId)) {
+          queue.push(childId);
+        }
+      }
+    }
+  }
+  getDirectChildren(nodeId, definition) {
+    const edges = definition.edges || definition.connections || [];
+    return edges.filter((edge) => edge.source === nodeId || edge.from === nodeId).map((edge) => edge.target || edge.to);
+  }
+  extractInput(msg) {
+    try {
+      return JSON.parse(msg.content);
+    } catch {
+      return msg.content;
+    }
+  }
+  extractOutput(msg) {
+    try {
+      return JSON.parse(msg.content);
+    } catch {
+      return msg.content;
+    }
+  }
+  extractVariables(output, state) {
+    if (!output || typeof output !== "object") {
+      return;
+    }
+    const outputObj = output;
+    for (const [key, value] of Object.entries(outputObj)) {
+      if (key.startsWith("_") || key.startsWith("$")) {
+        continue;
+      }
+      if (!state.variables.has(key)) {
+        state.variables.set(key, value);
+      }
+    }
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("recovery.builder.build", { recordParams: true, recordResult: true, log: true })
+], ExecutionStateBuilder.prototype, "build", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.builder.parseMessages", { recordParams: true, recordResult: true, log: true })
+], ExecutionStateBuilder.prototype, "parseMessages", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.builder.buildPendingNodes", { recordParams: true, recordResult: true, log: true })
+], ExecutionStateBuilder.prototype, "buildPendingNodes", null);
+
+// packages/core/src/env/workflow/utils/recovery-validator.ts
+class RecoveryValidator {
+  stateBuilder;
+  constructor() {
+    this.stateBuilder = new ExecutionStateBuilder;
+  }
+  async validate(messages, definition) {
+    const state = this.stateBuilder.build(messages, definition);
+    const errors = [];
+    const warnings = [];
+    errors.push(...this.validateStateIntegrity(state, definition));
+    errors.push(...this.validateParallelBranches(state, definition));
+    errors.push(...this.validateConditionBranches(state, definition));
+    errors.push(...this.validateLoopState(state, definition));
+    errors.push(...this.validateNestedWorkflows(state, definition));
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  async generatePlan(messages, definition) {
+    const state = this.stateBuilder.build(messages, definition);
+    const validationResult = await this.validate(messages, definition);
+    const pendingNodes = Array.from(state.pendingNodes);
+    const completedNodes = Array.from(state.completedNodes);
+    const resumePoint = this.determineResumePoint(state, definition);
+    const summary = this.generateSummary(state, validationResult);
+    return {
+      canResume: validationResult.isValid,
+      resumePoint,
+      completedNodes,
+      pendingNodes,
+      skippedNodes: [],
+      validationErrors: validationResult.errors,
+      summary
+    };
+  }
+  validateStateIntegrity(state, definition) {
+    const errors = [];
+    for (const nodeId of state.pendingNodes) {
+      const node = definition.nodes?.find((n) => n.id === nodeId);
+      if (!node?.config)
+        continue;
+      const variableRefs = this.extractVariableRefs(node.config);
+      for (const varRef of variableRefs) {
+        if (!state.nodeOutputs.has(varRef) && !state.variables.has(varRef)) {
+          errors.push({
+            type: "MISSING_VARIABLE" /* MISSING_VARIABLE */,
+            nodeId,
+            description: `\u53D8\u91CF ${varRef} \u4E0D\u5B58\u5728\uFF0C\u9700\u8981\u91CD\u65B0\u8FD0\u884C`,
+            suggestedAction: "RE_RUN" /* RE_RUN */,
+            context: { variable: varRef, nodeConfig: node.config }
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  validateParallelBranches(state, definition) {
+    const errors = [];
+    const parallelGroups = this.identifyParallelGroups(definition);
+    for (const group of parallelGroups) {
+      const completedInGroup = group.filter((id) => state.completedNodes.has(id));
+      const inProgressInGroup = group.filter((id) => state.inProgressNodes.has(id));
+      if (inProgressInGroup.length > 0 || completedInGroup.length < group.length) {
+        const mergeNode = this.findMergeNodeForParallel(group, definition);
+        if (mergeNode && !state.completedNodes.has(mergeNode)) {
+          const incomplete = group.filter((id) => !state.completedNodes.has(id));
+          errors.push({
+            type: "INCOMPLETE_PARALLEL" /* INCOMPLETE_PARALLEL */,
+            nodeId: mergeNode,
+            description: `\u5E76\u884C\u5206\u652F ${incomplete.join(", ")} \u672A\u5B8C\u6210`,
+            suggestedAction: "RE_RUN" /* RE_RUN */,
+            context: { incompleteBranches: incomplete, mergeNode }
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  validateConditionBranches(state, definition) {
+    const errors = [];
+    const edges = definition.edges || definition.connections || [];
+    const conditionalEdges = edges.filter((e) => e.condition);
+    for (const edge of conditionalEdges) {
+      const conditionVars = this.extractVariableRefs(edge.condition);
+      for (const varRef of conditionVars) {
+        if (!state.nodeOutputs.has(varRef) && !state.variables.has(varRef)) {
+          errors.push({
+            type: "AMBIGUOUS_BRANCH" /* AMBIGUOUS_BRANCH */,
+            nodeId: edge.target || edge.to,
+            description: `\u6761\u4EF6\u5206\u652F\u65E0\u6CD5\u786E\u5B9A\uFF1A\u53D8\u91CF ${varRef} \u4E0D\u5B58\u5728`,
+            suggestedAction: "CONFIRM" /* CONFIRM */,
+            context: { variable: varRef, condition: edge.condition }
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  validateLoopState(state, definition) {
+    const errors = [];
+    const loops = this.identifyLoops(definition);
+    for (const loop of loops) {
+      const loopCounter = `loop_count_${loop.header}`;
+      if (!state.nodeOutputs.has(loopCounter) && state.pendingNodes.has(loop.header)) {
+        errors.push({
+          type: "LOOP_STATE_LOST" /* LOOP_STATE_LOST */,
+          nodeId: loop.header,
+          description: `\u5FAA\u73AF\u72B6\u6001\u4E22\u5931\uFF0C\u5FAA\u73AF\u8BA1\u6570\u5668 ${loopCounter} \u4E0D\u5B58\u5728`,
+          suggestedAction: "RE_RUN" /* RE_RUN */,
+          context: { loopHeader: loop.header }
+        });
+      }
+    }
+    return errors;
+  }
+  validateNestedWorkflows(state, definition) {
+    const errors = [];
+    const workflowNodes = (definition.nodes || []).filter((n) => n.type === "workflow");
+    for (const node of workflowNodes) {
+      const nodeOutput = state.nodeOutputs.get(node.id);
+      const subSessionId = nodeOutput?.sessionId;
+      if (subSessionId && state.pendingNodes.has(node.id)) {}
+    }
+    return errors;
+  }
+  extractVariableRefs(obj) {
+    const refs = [];
+    if (!obj)
+      return refs;
+    const str = JSON.stringify(obj);
+    const regex = /\{\{([^}]+)\}\}/g;
+    let match;
+    while ((match = regex.exec(str)) !== null) {
+      refs.push(match[1].trim());
+    }
+    return refs;
+  }
+  identifyParallelGroups(definition) {
+    const groups = [];
+    const sources = new Map;
+    const edges = definition.edges || definition.connections || [];
+    for (const edge of edges) {
+      const source = edge.source || edge.from;
+      const target = edge.target || edge.to;
+      const targets = sources.get(source) || [];
+      targets.push(target);
+      sources.set(source, targets);
+    }
+    for (const [_source, targets] of sources) {
+      if (targets.length > 1) {
+        groups.push(targets);
+      }
+    }
+    return groups;
+  }
+  findMergeNodeForParallel(parallelIds, definition) {
+    const edges = definition.edges || definition.connections || [];
+    for (const edge of edges) {
+      const target = edge.target || edge.to;
+      const source = edge.source || edge.from;
+      const allSourcesFromParallel = parallelIds.includes(source);
+      const hasIncomingFromParallel = parallelIds.some((id) => edges.some((e) => (e.source || e.from) === id && (e.target || e.to) === target));
+      if (allSourcesFromParallel && hasIncomingFromParallel) {
+        return target;
+      }
+    }
+    return null;
+  }
+  identifyLoops(definition) {
+    const loops = [];
+    const visited = new Set;
+    const recStack = new Set;
+    const edges = definition.edges || definition.connections || [];
+    const getChildren = (nodeId) => {
+      return edges.filter((e) => (e.source || e.from) === nodeId).map((e) => e.target || e.to);
+    };
+    const dfs = (nodeId, path) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      const outgoing = getChildren(nodeId);
+      for (const childId of outgoing) {
+        if (!visited.has(childId)) {
+          dfs(childId, [...path, childId]);
+        } else if (recStack.has(childId)) {
+          const loopStart = path.indexOf(childId);
+          if (loopStart !== -1) {
+            loops.push({
+              header: childId,
+              body: path.slice(loopStart)
+            });
+          }
+        }
+      }
+      recStack.delete(nodeId);
+    };
+    for (const node of definition.nodes || []) {
+      if (!visited.has(node.id)) {
+        dfs(node.id, [node.id]);
+      }
+    }
+    return loops;
+  }
+  determineResumePoint(state, definition) {
+    const inProgress = Array.from(state.inProgressNodes);
+    if (inProgress.length > 0) {
+      return inProgress[0];
+    }
+    const pending = Array.from(state.pendingNodes);
+    if (pending.length > 0) {
+      return pending[0];
+    }
+    const entry = definition.entry;
+    if (Array.isArray(entry)) {
+      return entry[0] || "";
+    }
+    return entry || "";
+  }
+  generateSummary(state, result) {
+    if (result.isValid) {
+      return `\u6062\u590D\u9A8C\u8BC1\u901A\u8FC7\u3002\u5DF2\u5B8C\u6210 ${state.completedNodes.size} \u4E2A\u8282\u70B9\uFF0C\u5F85\u6267\u884C ${state.pendingNodes.size} \u4E2A\u8282\u70B9\u3002`;
+    }
+    const errorTypes = result.errors.map((e) => e.type).join(", ");
+    return `\u6062\u590D\u9A8C\u8BC1\u5931\u8D25\uFF1A${errorTypes}\u3002${result.errors.length} \u4E2A\u9519\u8BEF\u9700\u8981\u5904\u7406\u3002`;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validate", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validate", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.generate.plan", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "generatePlan", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateStateIntegrity", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateStateIntegrity", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateParallel", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateParallelBranches", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateCondition", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateConditionBranches", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateLoop", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateLoopState", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateNested", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateNestedWorkflows", null);
+export {
+  resolveTemplates,
+  resolveTemplateString,
+  ValidationErrorType,
+  TemplateResolver,
+  SuggestedAction,
+  RecoveryValidator,
+  ExecutionStateBuilder
+};