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

package/dist/shared/{chunk-9qzt1v1p.js → @ai-setting/roy-agent-core-qg9tcaph.js}

@@ -1,8 +1,9 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./chunk-0q6s9wm6.js";
-import"./chunk-wbkh7wat.js";
+} from "./roy-agent-core-rr9p1g43.js";
+import"./roy-agent-core-8dvbn7tw.js";
+import"./roy-agent-core-fs0mn2jk.js";
 init_agent_component_adapter();
 
 export {

package/dist/shared/{chunk-91bas8w5.js → @ai-setting/roy-agent-core-qhyerewk.js}

@@ -5,11 +5,11 @@ import {
   initDatabase,
   initializeTables,
   resetDatabase
-} from "./chunk-1pf5mfgd.js";
-import"./chunk-a9qmy3sc.js";
-import"./chunk-q9j99fsm.js";
-import"./chunk-1qwabsm0.js";
-import"./chunk-wbkh7wat.js";
+} from "./roy-agent-core-qxybm159.js";
+import"./roy-agent-core-yn761yve.js";
+import"./roy-agent-core-1k28kg7h.js";
+import"./roy-agent-core-j8zx62zr.js";
+import"./roy-agent-core-fs0mn2jk.js";
 export {
   resetDatabase,
   initializeTables,

package/dist/shared/{chunk-1pf5mfgd.js → @ai-setting/roy-agent-core-qxybm159.js}

@@ -1,12 +1,12 @@
 import {
   createLogger,
   init_logger
-} from "./chunk-a9qmy3sc.js";
+} from "./roy-agent-core-yn761yve.js";
 import {
   __require
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/workflow/storage/sqlite.ts
+// packages/core/src/env/workflow/storage/sqlite.ts
 init_logger();
 import { join } from "path";
 var logger = createLogger("workflow:sqlite");

package/dist/shared/{chunk-g6j5n3gv.js → @ai-setting/roy-agent-core-rh9dpkpw.js}

@@ -3,12 +3,12 @@ import {
   init_propagation,
   init_tracer_provider,
   propagation
-} from "./chunk-q9j99fsm.js";
+} from "./roy-agent-core-1k28kg7h.js";
 import {
   __toCommonJS
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/tool/built-in/bash.ts
+// packages/core/src/env/tool/built-in/bash.ts
 init_propagation();
 import { z } from "zod";
 import { exec } from "child_process";
@@ -156,7 +156,7 @@ var bashTool = {
   }
 };
 
-// src/env/tool/built-in/echo.ts
+// packages/core/src/env/tool/built-in/echo.ts
 var echoTool = {
   name: "echo",
   description: "Echo a message to the console. Useful for logging in workflows.",
@@ -179,7 +179,7 @@ var echoTool = {
   }
 };
 
-// src/env/tool/built-in/glob.ts
+// packages/core/src/env/tool/built-in/glob.ts
 import { z as z2 } from "zod";
 import { glob as globAsync } from "glob";
 var globTool = {
@@ -235,7 +235,7 @@ var globTool = {
   }
 };
 
-// src/env/tool/built-in/read-file.ts
+// packages/core/src/env/tool/built-in/read-file.ts
 import { z as z3 } from "zod";
 import { readFile } from "fs/promises";
 var readFileTool = {
@@ -303,7 +303,7 @@ var readFileTool = {
   }
 };
 
-// src/env/tool/built-in/write-file.ts
+// packages/core/src/env/tool/built-in/write-file.ts
 import { z as z4 } from "zod";
 import { writeFile, mkdir } from "fs/promises";
 import { dirname } from "path";
@@ -364,7 +364,7 @@ var writeFileTool = {
   }
 };
 
-// src/env/tool/built-in/edit-file.ts
+// packages/core/src/env/tool/built-in/edit-file.ts
 import { z as z5 } from "zod";
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 var editFileTool = {
@@ -435,7 +435,7 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/env/tool/built-in/grep.ts
+// packages/core/src/env/tool/built-in/grep.ts
 import { z as z6 } from "zod";
 import { readFile as readFile3 } from "fs/promises";
 import { glob as globAsync2 } from "glob";
@@ -529,7 +529,7 @@ var grepTool = {
   }
 };
 
-// src/env/tool/built-in/index.ts
+// packages/core/src/env/tool/built-in/index.ts
 function getAllBuiltInTools() {
   return [
     bashTool,

package/dist/shared/{chunk-0q6s9wm6.js → @ai-setting/roy-agent-core-rr9p1g43.js}

@@ -1,56 +1,12 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-8dvbn7tw.js";
 import {
   __esm
-} from "./chunk-wbkh7wat.js";
-
-// 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 } : {}
-  };
-}
-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
-      };
-    }
-  };
-});
+} from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/workflow/nodes/agent-component-adapter.ts
+// packages/core/src/env/workflow/nodes/agent-component-adapter.ts
 class AgentComponentAdapter {
   agentComponent;
   options;
@@ -246,4 +202,4 @@ var init_agent_component_adapter = __esm(() => {
   init_workflow_hil();
 });
 
-export { createNodeInterruptEvent, AskUserError, init_workflow_hil, AgentComponentAdapter, init_agent_component_adapter };
+export { AgentComponentAdapter, init_agent_component_adapter };

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

@@ -0,0 +1,284 @@
+import {
+  init_decorator_node
+} from "./roy-agent-core-3tnb2005.js";
+
+// packages/core/src/env/workflow/decorators/workflow.ts
+import"reflect-metadata";
+
+// packages/core/src/env/workflow/metadata/keys.ts
+var WORKFLOW_METADATA_KEY = Symbol("workflow:metadata");
+var NODE_METADATA_KEY = Symbol("workflow:node");
+var EDGE_METADATA_KEY = Symbol("workflow:edges");
+
+// packages/core/src/env/workflow/decorators/workflow.ts
+function Workflow(options) {
+  return function(target) {
+    const metadata = {
+      name: options.name,
+      version: options.version || "1.0",
+      description: options.description,
+      entry: options.entry,
+      config: options.config,
+      tags: options.tags || [],
+      author: options.author
+    };
+    Reflect.defineMetadata(WORKFLOW_METADATA_KEY, metadata, target);
+    return target;
+  };
+}
+function getWorkflowMetadata(target) {
+  return Reflect.getMetadata(WORKFLOW_METADATA_KEY, target);
+}
+// packages/core/src/env/workflow/decorators/node-as.ts
+import"reflect-metadata";
+function NodeAs(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const methodName = String(propertyKey);
+    const nodeMetadata = {
+      nodeId: options.nodeId || methodName,
+      nodeType: options.nodeType || "tool",
+      name: options.name,
+      dependsOn: normalizeDependsOn(options.dependsOn),
+      condition: options.condition,
+      retry: options.retry,
+      timeout: options.timeout,
+      config: options.config || {},
+      methodName,
+      method: descriptor.value
+    };
+    const existingNodes = Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+    const existingIndex = existingNodes.findIndex((n) => n.methodName === methodName);
+    if (existingIndex >= 0) {
+      existingNodes[existingIndex] = nodeMetadata;
+    } else {
+      existingNodes.push(nodeMetadata);
+    }
+    Reflect.defineMetadata(NODE_METADATA_KEY, existingNodes, target);
+    return descriptor;
+  };
+}
+function normalizeDependsOn(dependsOn) {
+  if (!dependsOn) {
+    return [];
+  }
+  return Array.isArray(dependsOn) ? dependsOn : [dependsOn];
+}
+function getNodeMetadatas(target) {
+  return Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+}
+// packages/core/src/env/workflow/decorators/edge.ts
+import"reflect-metadata";
+function Edge(from, to) {
+  return function(target, propertyKey, descriptor) {
+    const edge = { from, to };
+    const existingEdges = Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+    existingEdges.push(edge);
+    Reflect.defineMetadata(EDGE_METADATA_KEY, existingEdges, target);
+    return descriptor;
+  };
+}
+function WorkflowEdges(edges) {
+  return function(target) {
+    const edgeMetadatas = edges.map((edge) => ({
+      from: edge.from,
+      to: edge.to,
+      condition: edge.condition
+    }));
+    Reflect.defineMetadata(EDGE_METADATA_KEY, edgeMetadatas, target);
+    return target;
+  };
+}
+function getEdgeMetadatas(target) {
+  return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+}
+
+// packages/core/src/env/workflow/decorators/index.ts
+init_decorator_node();
+
+// packages/core/src/env/workflow/extractor/workflow-converter.ts
+import"reflect-metadata";
+class WorkflowConverter {
+  static extractWorkflowMetadata(targetClass) {
+    return getWorkflowMetadata(targetClass);
+  }
+  static extractNodeMetadatas(targetClass) {
+    return getNodeMetadatas(targetClass.prototype);
+  }
+  static extractEdgeMetadatas(targetClass) {
+    return getEdgeMetadatas(targetClass);
+  }
+  static fromClass(targetClass, instance) {
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      throw new Error("Class must be decorated with @Workflow");
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      throw new Error("At least one method must be decorated with @NodeAs");
+    }
+    const edgeMetadatas = this.extractEdgeMetadatas(targetClass);
+    const nodeMap = this.buildNodeMap(nodeMetadatas, edgeMetadatas);
+    const nodes = Array.from(nodeMap.values()).map((meta) => ({
+      id: meta.nodeId,
+      type: meta.nodeType,
+      name: meta.name,
+      config: {
+        ...meta.config,
+        _methodName: meta.methodName,
+        _instance: instance
+      },
+      depends_on: meta.dependsOn,
+      condition: meta.condition,
+      retry: meta.retry,
+      timeout: meta.timeout
+    }));
+    const entry = workflowMeta.entry || nodeMetadatas[0]?.nodeId || "unknown";
+    return {
+      name: workflowMeta.name,
+      version: workflowMeta.version || "1.0",
+      description: workflowMeta.description,
+      config: workflowMeta.config || {},
+      nodes,
+      entry,
+      outputs: [],
+      metadata: {
+        tags: workflowMeta.tags || [],
+        author: workflowMeta.author
+      }
+    };
+  }
+  static buildNodeMap(nodeMetadatas, edgeMetadatas) {
+    const nodeMap = new Map;
+    for (const nodeMeta of nodeMetadatas) {
+      nodeMap.set(nodeMeta.nodeId, { ...nodeMeta });
+    }
+    for (const edge of edgeMetadatas) {
+      const targetNode = nodeMap.get(edge.to);
+      if (targetNode) {
+        if (!targetNode.dependsOn.includes(edge.from)) {
+          targetNode.dependsOn = [...targetNode.dependsOn, edge.from];
+        }
+        if (edge.condition) {
+          if (targetNode.condition) {
+            targetNode.condition = `(${targetNode.condition}) AND (${edge.condition})`;
+          } else {
+            targetNode.condition = edge.condition;
+          }
+        }
+      }
+    }
+    return nodeMap;
+  }
+  static validateWorkflowClass(targetClass) {
+    const errors = [];
+    const warnings = [];
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      errors.push("Class must be decorated with @Workflow");
+      return { valid: false, errors, warnings };
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      errors.push("At least one method must be decorated with @NodeAs");
+      return { valid: false, errors, warnings };
+    }
+    const entry = workflowMeta.entry;
+    if (entry) {
+      const entries = Array.isArray(entry) ? entry : [entry];
+      for (const e of entries) {
+        if (!nodeMetadatas.find((n) => n.nodeId === e)) {
+          errors.push(`Entry node '${e}' not found`);
+        }
+      }
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        if (!nodeMetadatas.find((n) => n.nodeId === dep)) {
+          errors.push(`Node '${node.nodeId}' depends on non-existent node '${dep}'`);
+        }
+      }
+    }
+    if (this.hasCycle(nodeMetadatas)) {
+      errors.push("Workflow contains a cycle");
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  static hasCycle(nodeMetadatas) {
+    const visited = new Set;
+    const recStack = new Set;
+    const adjList = new Map;
+    for (const node of nodeMetadatas) {
+      adjList.set(node.nodeId, []);
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        const deps = adjList.get(dep);
+        if (deps) {
+          deps.push(node.nodeId);
+        }
+      }
+    }
+    const dfs = (nodeId) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      const neighbors = adjList.get(nodeId) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          if (dfs(neighbor)) {
+            return true;
+          }
+        } else if (recStack.has(neighbor)) {
+          return true;
+        }
+      }
+      recStack.delete(nodeId);
+      return false;
+    };
+    for (const node of nodeMetadatas) {
+      if (!visited.has(node.nodeId)) {
+        if (dfs(node.nodeId)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  static async executeNode(nodeDef, context) {
+    const instance = nodeDef.config._instance;
+    const methodName = nodeDef.config._methodName;
+    if (!instance || !methodName) {
+      return { output: undefined, error: new Error("Missing method information") };
+    }
+    const method = instance[methodName];
+    if (typeof method !== "function") {
+      return { output: undefined, error: new Error(`Method ${methodName} is not a function`) };
+    }
+    const deps = nodeDef.depends_on || [];
+    let input = context.input;
+    if (deps.length > 0) {
+      input = {};
+      for (const depId of deps) {
+        input[depId] = context.previousOutputs.get(depId);
+      }
+    }
+    try {
+      const result = await method.call(instance, input);
+      return { output: result };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+}
+// packages/core/src/env/workflow/utils/create-workflow.ts
+function createWorkflowFromClass(targetClass, options) {
+  const instance = options?.instance ?? new targetClass(...options?.constructorArgs ?? []);
+  return WorkflowConverter.fromClass(targetClass, instance);
+}
+export { Workflow, getWorkflowMetadata, NodeAs, getNodeMetadatas, Edge, WorkflowEdges, getEdgeMetadatas, WorkflowConverter, createWorkflowFromClass };