@ai-setting/roy-agent-core 1.7.49 → 1.7.51

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

@@ -0,0 +1,367 @@
+import {
+  DAGManager,
+  init_dag_manager
+} from "./roy-agent-core-8s9jd2qy.js";
+
+// src/env/workflow/utils/node-output-contracts.ts
+var VIRTUAL_OUTPUT_FIELD = "output";
+var NODE_OUTPUT_CONTRACTS = {
+  tool: {
+    fields: [],
+    closed: true,
+    description: "a tool node's stored value is its result (usually a string)",
+    suggestedField: VIRTUAL_OUTPUT_FIELD
+  },
+  python_call: {
+    fields: [],
+    closed: true,
+    description: "a pythonCall node's stored value is its JSON-parsed stdout",
+    suggestedField: VIRTUAL_OUTPUT_FIELD
+  },
+  pythonCall: {
+    fields: [],
+    closed: true,
+    description: "a pythonCall node's stored value is its JSON-parsed stdout",
+    suggestedField: VIRTUAL_OUTPUT_FIELD
+  },
+  skill: {
+    fields: [],
+    closed: true,
+    description: "a skill node's stored value is the skill's return value",
+    suggestedField: VIRTUAL_OUTPUT_FIELD
+  },
+  condition: {
+    fields: ["success", "condition"],
+    closed: true,
+    description: "a condition node's stored value is { success, condition }",
+    suggestedField: VIRTUAL_OUTPUT_FIELD,
+    canonicalField: "condition"
+  },
+  merge: {
+    fields: ["strategy", "results", "count"],
+    closed: true,
+    description: "a merge node's stored value is { strategy, results, count }",
+    suggestedField: VIRTUAL_OUTPUT_FIELD,
+    canonicalField: "results"
+  },
+  agent: {
+    fields: ["result", "metadata", "workflowHistory"],
+    canonicalField: "result",
+    closed: false,
+    description: "an agent node's stored value is { result, metadata, workflowHistory, ...<json output fields> }",
+    suggestedField: "result"
+  },
+  workflow: {
+    fields: ["result"],
+    closed: false,
+    description: "a workflow node's stored value is the child workflow's top-level output",
+    suggestedField: VIRTUAL_OUTPUT_FIELD
+  },
+  ask_user: {
+    fields: [],
+    closed: true,
+    description: "an askUser node never produces output (it always pauses)"
+  },
+  askUser: {
+    fields: [],
+    closed: true,
+    description: "an askUser node never produces output (it always pauses)"
+  }
+};
+function getNodeOutputContract(nodeType) {
+  return NODE_OUTPUT_CONTRACTS[nodeType] ?? {
+    fields: [],
+    closed: false,
+    description: `unknown node type "${nodeType}" (output shape unknown)`
+  };
+}
+function getSuggestionFieldForResultMisuse(nodeType) {
+  const contract = getNodeOutputContract(nodeType);
+  return contract.canonicalField ?? contract.suggestedField ?? VIRTUAL_OUTPUT_FIELD;
+}
+function hasClosedOutputContract(nodeType) {
+  return getNodeOutputContract(nodeType).closed;
+}
+var RESULT_INVALID_NODE_TYPES = new Set([
+  "tool",
+  "python_call",
+  "pythonCall",
+  "skill",
+  "condition",
+  "merge",
+  "ask_user",
+  "askUser"
+]);
+function getAgentDeclaredJsonFields(config) {
+  const output = config?.output;
+  const properties = output?.schema?.properties;
+  if (!properties || typeof properties !== "object")
+    return;
+  const keys = Object.keys(properties);
+  return keys.length > 0 ? keys : undefined;
+}
+
+// src/env/workflow/utils/template-contract-validator.ts
+var TEMPLATE_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
+var PURE_PATH_RE = /^[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]+|\[-?\d+\])*$/;
+var NON_NODE_SCOPES = new Set(["input", "inputs", "config", "env", "workflow", "vars", "secrets"]);
+function isPurePath(body) {
+  return PURE_PATH_RE.test(body);
+}
+function walkStrings(value, visit) {
+  if (typeof value === "string") {
+    visit(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      walkStrings(item, visit);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const v of Object.values(value))
+      walkStrings(v, visit);
+  }
+}
+function extractNodeRefs(config) {
+  const refs = [];
+  walkStrings(config, (s) => {
+    TEMPLATE_RE.lastIndex = 0;
+    let m;
+    while ((m = TEMPLATE_RE.exec(s)) !== null) {
+      const raw = m[0];
+      const body = m[1].split("|")[0].trim();
+      if (!body || /\s/.test(body) || !isPurePath(body))
+        continue;
+      if (body.startsWith("#") || body.startsWith("/"))
+        continue;
+      const parts = body.split(".");
+      let sourceNodeId;
+      let rest;
+      if (parts[0] === "nodes") {
+        if (parts.length < 2)
+          continue;
+        sourceNodeId = parts[1];
+        rest = parts.slice(2);
+      } else {
+        sourceNodeId = parts[0];
+        rest = parts.slice(1);
+      }
+      if (!sourceNodeId)
+        continue;
+      if (NON_NODE_SCOPES.has(sourceNodeId))
+        continue;
+      refs.push({ template: raw, sourceNodeId, rest });
+    }
+  });
+  return refs;
+}
+function baseSegment(seg) {
+  if (!seg)
+    return "";
+  return seg.replace(/\[-?\d+\]$/, "");
+}
+function buildGraph(nodes, edges) {
+  const byId = new Map;
+  const direct = new Map;
+  for (const n of nodes) {
+    if (!n || typeof n !== "object" || typeof n.id !== "string" || !n.id)
+      continue;
+    byId.set(n.id, n);
+    const deps = Array.isArray(n.depends_on) ? n.depends_on.filter((d) => typeof d === "string") : [];
+    direct.set(n.id, [...deps]);
+  }
+  for (const e of Array.isArray(edges) ? edges : []) {
+    if (!e || typeof e.from !== "string" || typeof e.to !== "string")
+      continue;
+    const to = direct.get(e.to);
+    if (!to)
+      continue;
+    if (!to.includes(e.from))
+      to.push(e.from);
+  }
+  const upstream = new Map;
+  for (const id of byId.keys()) {
+    const seen = new Set;
+    const stack = [...direct.get(id) ?? []];
+    while (stack.length > 0) {
+      const d = stack.pop();
+      if (seen.has(d))
+        continue;
+      seen.add(d);
+      for (const dd of direct.get(d) ?? [])
+        stack.push(dd);
+    }
+    upstream.set(id, seen);
+  }
+  return { byId, upstream };
+}
+function validateTemplateContracts(definition) {
+  if (!definition || typeof definition !== "object")
+    return [];
+  const def = definition;
+  if (!Array.isArray(def.nodes))
+    return [];
+  const nodes = def.nodes;
+  const { byId, upstream } = buildGraph(nodes, Array.isArray(def.edges) ? def.edges : []);
+  const findings = [];
+  for (const node of nodes) {
+    if (!node || typeof node !== "object" || typeof node.id !== "string" || !node.id)
+      continue;
+    const nodeId = node.id;
+    const refs = extractNodeRefs(node.config);
+    const upOfNode = upstream.get(nodeId) ?? new Set;
+    for (const ref of refs) {
+      const { template, sourceNodeId, rest } = ref;
+      const src = byId.get(sourceNodeId);
+      if (!src) {
+        findings.push({
+          severity: "error",
+          rule: "R1-node-not-found",
+          nodeId,
+          template,
+          sourceNodeId,
+          message: `Node "${nodeId}" references "${template}", but no node with id ` + `"${sourceNodeId}" exists in this workflow.`,
+          suggestion: `Remove the reference, or add a node with id "${sourceNodeId}".`
+        });
+        continue;
+      }
+      const srcType = src.type;
+      const contract = getNodeOutputContract(srcType);
+      const allowed = new Set([VIRTUAL_OUTPUT_FIELD, ...contract.fields]);
+      const first = baseSegment(rest[0]);
+      if (first === "result" && RESULT_INVALID_NODE_TYPES.has(srcType)) {
+        const suggestedField = getSuggestionFieldForResultMisuse(srcType);
+        const fixed = template.replace(new RegExp(`(nodes\\.${escapeRegExp(sourceNodeId)}|^\\{\\{${escapeRegExp(sourceNodeId)})\\.result`), `$1.${suggestedField}`);
+        findings.push({
+          severity: "error",
+          rule: "R2-result-on-non-agent",
+          nodeId,
+          template,
+          sourceNodeId,
+          sourceNodeType: srcType,
+          message: `Node "${nodeId}" references "${template}", but "${sourceNodeId}" is a ` + `"${srcType}" node — ${contract.description}. The ".result" field only ` + `exists on agent nodes; the value will silently resolve to an empty ` + `string at runtime. Use ".output" instead.`,
+          suggestion: fixed !== template ? fixed : undefined
+        });
+        continue;
+      }
+      if (first && contract.closed && !allowed.has(first)) {
+        findings.push({
+          severity: "warning",
+          rule: "R3-unknown-field-on-closed",
+          nodeId,
+          template,
+          sourceNodeId,
+          sourceNodeType: srcType,
+          message: `Node "${nodeId}" references "${template}"; "${sourceNodeId}" is a ` + `"${srcType}" node whose output is ${contract.description} — "${first}" ` + `is not one of [${[...allowed].join(", ")}]. It may resolve only if the ` + `node's output object happens to contain "${first}".`,
+          suggestion: contract.suggestedField ? template.replace(new RegExp(`\\.${escapeRegExp(first)}(?=\\.|\\[|\\}\\}|$)`), `.${contract.suggestedField}`) : undefined
+        });
+      }
+      if (srcType === "tool" && first === VIRTUAL_OUTPUT_FIELD && rest.length > 1) {
+        findings.push({
+          severity: "info",
+          rule: "R4-deep-path-into-tool",
+          nodeId,
+          template,
+          sourceNodeId,
+          sourceNodeType: srcType,
+          message: `Node "${nodeId}" references "${template}" — a deep path into a "tool" ` + `node. Tool outputs are frequently plain strings, in which case ` + `".${rest.slice(1).join(".")}" cannot be navigated. Verify the tool ` + `returns a structured object.`
+        });
+      }
+      if (srcType === "agent" && first) {
+        const declared = getAgentDeclaredJsonFields(src.config);
+        if (declared && first && !allowed.has(first) && !declared.includes(first)) {
+          findings.push({
+            severity: "warning",
+            rule: "R5-agent-schema-field",
+            nodeId,
+            template,
+            sourceNodeId,
+            sourceNodeType: srcType,
+            message: `Node "${nodeId}" references "${template}", but agent node ` + `"${sourceNodeId}" declares a JSON output schema with fields ` + `[${declared.join(", ")}]. "${first}" is not among them ` + `(nor the generic "result"/"output"/"metadata"/"workflowHistory").`
+          });
+        }
+      }
+      if (sourceNodeId !== nodeId && !upOfNode.has(sourceNodeId)) {
+        findings.push({
+          severity: "info",
+          rule: "R6-not-upstream",
+          nodeId,
+          template,
+          sourceNodeId,
+          sourceNodeType: srcType,
+          message: `Node "${nodeId}" references "${template}", but "${sourceNodeId}" is not ` + `in its upstream dependency closure. This is valid for loop back-edges ` + `(consuming the previous round's output) but otherwise may resolve to an ` + `empty value on the first execution.`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getTemplateContractErrors(definition) {
+  return validateTemplateContracts(definition).filter((f) => f.severity === "error");
+}
+function getTemplateContractWarnings(definition) {
+  return validateTemplateContracts(definition).filter((f) => f.severity === "warning");
+}
+function formatTemplateContractFindings(findings) {
+  return findings.map((f) => {
+    const head = `[template-contract:${f.rule}] Node "${f.nodeId}": ${f.message}`;
+    return f.suggestion ? `${head} — Did you mean "${f.suggestion}"?` : head;
+  });
+}
+
+// src/env/workflow/utils/validate-workflow-definition.ts
+init_dag_manager();
+function validateWorkflowDefinition(definition, options = {}) {
+  if (!definition || typeof definition !== "object") {
+    return {
+      valid: false,
+      errors: ["Workflow definition must be an object"]
+    };
+  }
+  const def = definition;
+  if (!Array.isArray(def.nodes)) {
+    return {
+      valid: false,
+      errors: ["Workflow definition must have a 'nodes' array"]
+    };
+  }
+  let structural;
+  try {
+    const dag = new DAGManager(definition, { allowCycles: false });
+    structural = dag.validate();
+  } catch (error) {
+    structural = {
+      valid: false,
+      errors: [
+        `Validation error: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+  let findings = [];
+  if (structural.valid && !options.skipTemplateContracts) {
+    try {
+      findings = validateTemplateContracts(definition);
+    } catch {
+      findings = [];
+    }
+  }
+  const contractErrors = findings.filter((f) => f.severity === "error");
+  const contractWarnings = findings.filter((f) => f.severity === "warning");
+  const contractInfos = findings.filter((f) => f.severity === "info");
+  const errors = [...structural.errors, ...formatTemplateContractFindings(contractErrors)];
+  const warnings = formatTemplateContractFindings(contractWarnings);
+  const infos = formatTemplateContractFindings(contractInfos);
+  return {
+    valid: structural.valid && contractErrors.length === 0,
+    errors,
+    ...warnings.length > 0 ? { warnings } : {},
+    ...infos.length > 0 ? { infos } : {},
+    ...findings.length > 0 ? { findings } : {}
+  };
+}
+
+export { VIRTUAL_OUTPUT_FIELD, NODE_OUTPUT_CONTRACTS, getNodeOutputContract, hasClosedOutputContract, RESULT_INVALID_NODE_TYPES, getAgentDeclaredJsonFields, validateTemplateContracts, getTemplateContractErrors, getTemplateContractWarnings, formatTemplateContractFindings, validateWorkflowDefinition };

package/dist/shared/@ai-setting/{roy-agent-core-j783tcqb.js → roy-agent-core-nde5gzta.js}

@@ -1,7 +1,7 @@
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/{roy-agent-core-e2569ptp.js → roy-agent-core-ne2t1pay.js}

@@ -1,7 +1,7 @@
 import {
   TagRepository
-} from "./roy-agent-core-j783tcqb.js";
-import"./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-nde5gzta.js";
+import"./roy-agent-core-dsevjbck.js";
 import"./roy-agent-core-8seq65bp.js";
 import"./roy-agent-core-jnszp0jq.js";
 import"./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/{roy-agent-core-k0sy76cw.js → roy-agent-core-p2r27era.js}

@@ -4,35 +4,35 @@ import {
 } from "./roy-agent-core-tbrn9wdm.js";
 import {
   getSharedEventStore
-} from "./roy-agent-core-zff8vvs5.js";
+} from "./roy-agent-core-yhsssn86.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
 import {
   builtInPrompts
-} from "./roy-agent-core-223v204d.js";
+} from "./roy-agent-core-gdsqp6j8.js";
 import {
   DEFAULT_SUBAGENT_PROMPT
-} from "./roy-agent-core-ed4tbkyj.js";
+} from "./roy-agent-core-rx16h2m1.js";
 import {
   runWithBgTaskIdAsync
 } from "./roy-agent-core-c1v263jn.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-mqaht7mm.js";
+} from "./roy-agent-core-4z3rq5gw.js";
 import {
   init_context
-} from "./roy-agent-core-emjpkx9s.js";
+} from "./roy-agent-core-k8b440n3.js";
 import {
   getCurrentTaskId,
   getEnvContext
-} from "./roy-agent-core-fm77q3tn.js";
+} from "./roy-agent-core-5apmk4qw.js";
 import {
   TracedAs,
   init_decorator,
   wrapFunction
-} from "./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger
@@ -1129,13 +1129,13 @@ class BackgroundTaskManager {
       if (!reusedSession) {
         throw new Error(`Sub session not found for resume: ${existingSubSessionId}`);
       }
-      const createdBy = reusedSession?.info?.metadata?.created_by;
+      const createdBy = reusedSession?.metadata?.created_by;
       if (createdBy && createdBy !== "subagent") {
         logger3.warn(`[BackgroundTaskManager] Session ${existingSubSessionId} was not created by a sub-agent (created_by=${createdBy}); reusing anyway`);
       }
       subSession = reusedSession;
       try {
-        const existingMeta = reusedSession?.info?.metadata || {};
+        const existingMeta = reusedSession?.metadata ?? {};
         await sessionComponent.update(existingSubSessionId, {
           metadata: {
             ...existingMeta,
@@ -1250,7 +1250,7 @@ class BackgroundTaskManager {
         throw new Error(`Sub session not found: ${task.subSessionId}`);
       }
       const taskRegistry = this.processRegistries.get(taskId);
-      const result = await this.executeWithAbort(subSession, prompt, timeoutMs, taskId, abortController?.signal, task.similarTaskIds, taskRegistry, () => abortController?.abort());
+      const result = await this.executeWithAbort(subSession, prompt, timeoutMs, taskId, abortController?.signal, task.similarTaskIds, taskRegistry, () => abortController?.abort(), task.subagentType);
       if (abortController?.signal.aborted) {
         logger3.info(`[BackgroundTaskManager] Task was aborted`, { taskId });
         return;
@@ -1416,12 +1416,16 @@ class BackgroundTaskManager {
       this.progressTimers.delete(taskId);
     }
   }
-  async executeWithAbort(subSession, prompt, timeoutMs, bgTaskId, signal, similarTaskIds, processRegistry, abortTask) {
-    const metadata = subSession.info?.metadata || {};
+  async executeWithAbort(subSession, prompt, timeoutMs, bgTaskId, signal, similarTaskIds, processRegistry, abortTask, explicitSubagentType) {
+    const metadata = subSession?.metadata ?? {};
     const taskId = metadata.task_id;
     const taskDescription = metadata.task_description || "";
     const sessionId = subSession.id;
-    const subagentType = metadata.subagent_type || "general";
+    const metaSubagentType = metadata.subagent_type;
+    const subagentType = metaSubagentType || explicitSubagentType || "general";
+    if (!metaSubagentType && !explicitSubagentType) {
+      logger3.warn(`[delegate] subagent_type unresolved (no session metadata, no explicit value) — falling back to "general". sessionId=${sessionId}`);
+    }
     const agentComponent = this.env?.getComponent?.("agent");
     const registry = agentComponent?.getRegistry?.();
     const resolved = await resolveSubAgentConfig(subagentType, { registry });

package/dist/shared/@ai-setting/{roy-agent-core-xvf97xs4.js → roy-agent-core-p8ak03s0.js}

@@ -21,17 +21,17 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-xn12d221.js";
+} from "./roy-agent-core-tdbv7ff4.js";
 import {
   LLMHookPoints,
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-mqaht7mm.js";
+} from "./roy-agent-core-4z3rq5gw.js";
 import {
   TracedAs,
   init_decorator,
   wrapFunction
-} from "./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-56j2q0w6.js → roy-agent-core-qamktze3.js}

@@ -8,7 +8,7 @@ import {
 } from "./roy-agent-core-qxnbvgwe.js";
 import {
   BaseComponent
-} from "./roy-agent-core-xn12d221.js";
+} from "./roy-agent-core-tdbv7ff4.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/{roy-agent-core-khx0h4j2.js → roy-agent-core-qcspfszy.js}

@@ -1,7 +1,10 @@
 import {
   init_global_hook_manager,
   init_hook_manager
-} from "./roy-agent-core-mqaht7mm.js";
+} from "./roy-agent-core-4z3rq5gw.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/hook/types.ts
 function createHook(meta, fn) {
@@ -13,9 +16,13 @@ function createHook(meta, fn) {
 function createPriorityHook(name, fn, priority) {
   return createHook({ name, priority }, fn);
 }
+var init_types = () => {};
 
 // src/env/hook/index.ts
-init_hook_manager();
-init_global_hook_manager();
+var init_hook = __esm(() => {
+  init_types();
+  init_hook_manager();
+  init_global_hook_manager();
+});
 
-export { createHook, createPriorityHook };
+export { createHook, createPriorityHook, init_hook };

package/dist/shared/@ai-setting/{roy-agent-core-rqyxdrxg.js → roy-agent-core-qm9jda8p.js}

@@ -1,7 +1,7 @@
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-yq45m8mm.js → roy-agent-core-rnwr39b0.js}

@@ -3,10 +3,10 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-xn12d221.js";
+} from "./roy-agent-core-tdbv7ff4.js";
 import {
   init_decorator
-} from "./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   getTracerProvider,

package/dist/shared/@ai-setting/{roy-agent-core-ed4tbkyj.js → roy-agent-core-rx16h2m1.js}

@@ -4,7 +4,7 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-bt6h398s.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger
@@ -257,10 +257,14 @@ class AgentRegistry {
         "workflow_search",
         "workflow_tag_list",
         "workflow_validate",
-        "workflow_add"
+        "workflow_add",
+        "bash",
+        "read_file",
+        "workflow_run",
+        "workflow_run_status"
       ],
       deniedTools: ["delegate_task", "stop_task"],
-      maxIterations: 30
+      maxIterations: 60
     };
     this.agents.set(name, agent);
   }

package/dist/shared/@ai-setting/{roy-agent-core-sea232w4.js → roy-agent-core-s214vmmd.js}

@@ -1,7 +1,7 @@
 import {
   exports_node_registry_helper,
   init_node_registry_helper
-} from "./roy-agent-core-yge38dkn.js";
+} from "./roy-agent-core-vrsxhw9e.js";
 import {
   askUserTool,
   createRunWorkflowTool,
@@ -13,18 +13,18 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-kazn764f.js";
+} from "./roy-agent-core-vvxb9522.js";
 import {
   WorkflowService
-} from "./roy-agent-core-wt37tszm.js";
+} from "./roy-agent-core-7evvpfwc.js";
 import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-1pjct4nj.js";
+} from "./roy-agent-core-35s1w7tc.js";
 import {
   BaseComponent
-} from "./roy-agent-core-xn12d221.js";
+} from "./roy-agent-core-tdbv7ff4.js";
 import {
   createLogger,
   init_logger
@@ -104,7 +104,7 @@ class WorkflowComponent extends BaseComponent {
       return;
     try {
       const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
-      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-cnsjr3ws.js");
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-9jzysq50.js");
       this.nodeRegistry = new NodeRegistry;
       registerDecoratorNodeType2(this.nodeRegistry);
       this.decoratorsRegistered = true;
@@ -134,14 +134,14 @@ class WorkflowComponent extends BaseComponent {
   }
   async runWorkflow(definition, input, options) {
     const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
-    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-cnsjr3ws.js");
+    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-9jzysq50.js");
     const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
     const skillComponent = this._workflowEnv?.getComponent("skill");
     let agentRunner = this.agentRunner;
     if (!agentRunner && this._workflowEnv) {
       const agentComponent = this._workflowEnv.getComponent("agent");
       if (agentComponent) {
-        const { AgentComponentAdapter } = await import("./roy-agent-core-ecb8am8s.js");
+        const { AgentComponentAdapter } = await import("./roy-agent-core-skzjs973.js");
         agentRunner = new AgentComponentAdapter(agentComponent, {}, this.sessionComponent);
       }
     }
@@ -163,7 +163,7 @@ class WorkflowComponent extends BaseComponent {
     if (this.workflowService) {
       this.workflowService = null;
       try {
-        const { closeDatabase } = await import("./roy-agent-core-e302nvzt.js");
+        const { closeDatabase } = await import("./roy-agent-core-2k4xffaa.js");
         closeDatabase();
         componentLogger.info("[WorkflowComponent] SQLite database closed");
       } catch (error) {
@@ -241,9 +241,9 @@ class WorkflowComponent extends BaseComponent {
   }
   async initSqliteService() {
     try {
-      const { getDatabase, initializeTables } = await import("./roy-agent-core-e302nvzt.js");
-      const { WorkflowRepository } = await import("./roy-agent-core-trd6my5j.js");
-      const { TagRepository } = await import("./roy-agent-core-e2569ptp.js");
+      const { getDatabase, initializeTables } = await import("./roy-agent-core-2k4xffaa.js");
+      const { WorkflowRepository } = await import("./roy-agent-core-1cv9j4dg.js");
+      const { TagRepository } = await import("./roy-agent-core-ne2t1pay.js");
       const db = getDatabase();
       initializeTables();
       const workflowRepository = new WorkflowRepository(db);
@@ -309,7 +309,7 @@ class WorkflowComponent extends BaseComponent {
     this.workflowService = null;
     this.nodeRegistry = null;
     try {
-      const { closeDatabase } = await import("./roy-agent-core-e302nvzt.js");
+      const { closeDatabase } = await import("./roy-agent-core-2k4xffaa.js");
       closeDatabase();
     } catch {}
     this._status = "stopped";