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

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

@@ -0,0 +1,266 @@
+import {
+  exports_node_registry_helper,
+  init_node_registry_helper
+} from "./roy-agent-core-1z1zv5g8.js";
+import {
+  askUserTool
+} from "./roy-agent-core-nfj6knp5.js";
+import {
+  WorkflowEngine,
+  exports_engine,
+  init_engine
+} from "./roy-agent-core-6j0zcmwk.js";
+import {
+  WorkflowService
+} from "./roy-agent-core-yt8wdh2w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+import {
+  __require,
+  __toCommonJS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/workflow-component.ts
+import"reflect-metadata";
+init_engine();
+init_logger();
+init_engine();
+init_node_registry_helper();
+var componentLogger = createLogger("workflow");
+
+class SkillRegistryAdapter {
+  skillComponent;
+  constructor(skillComponent) {
+    this.skillComponent = skillComponent;
+  }
+  getSkill(name) {
+    const entry = this.skillComponent.getSkill(name);
+    if (!entry)
+      return;
+    return {
+      name: entry.name,
+      invoke: async (input, context) => {
+        return entry.content;
+      }
+    };
+  }
+  hasSkill(name) {
+    return this.skillComponent.hasSkill(name);
+  }
+}
+
+class WorkflowComponent extends BaseComponent {
+  name = "workflow";
+  version = "1.0.0";
+  workflowService = null;
+  sessionComponent = null;
+  nodeRegistry = null;
+  decoratorsRegistered = false;
+  getService() {
+    return this.workflowService;
+  }
+  toolComponent;
+  llmComponent;
+  logTraceComponent;
+  _workflowEnv;
+  skillRegistry;
+  agentRunner;
+  async init(options) {
+    const opts = options;
+    this._status = "initializing";
+    componentLogger.info("Initializing WorkflowComponent...");
+    this.toolComponent = opts.toolComponent;
+    this.llmComponent = opts.llmComponent;
+    this.logTraceComponent = opts.logTraceComponent;
+    this._workflowEnv = opts.env;
+    this.skillRegistry = opts.skillRegistry;
+    this.agentRunner = opts.agentRunner;
+    try {
+      if (opts.autoRegisterDecorators !== false) {
+        await this.registerDecorators();
+      }
+      this._status = "ready";
+      componentLogger.info("WorkflowComponent initialized successfully");
+    } catch (error) {
+      this._status = "error";
+      componentLogger.error("Failed to initialize WorkflowComponent:", error);
+      throw error;
+    }
+  }
+  async registerDecorators() {
+    if (this.decoratorsRegistered)
+      return;
+    try {
+      const { NodeRegistry } = await import("../../packages/core/src/env/workflow/engine/index.js");
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-hyza1gm7.js");
+      this.nodeRegistry = new NodeRegistry;
+      registerDecoratorNodeType2(this.nodeRegistry);
+      this.decoratorsRegistered = true;
+      componentLogger.info("Decorator node type registered");
+    } catch (error) {
+      componentLogger.error("Failed to register decorator node type:", error);
+      throw error;
+    }
+  }
+  createService(options) {
+    const skillRegistryAdapter = options.skillRegistry ? new SkillRegistryAdapter(options.skillRegistry) : undefined;
+    const sessionComponentForEngine = options.sessionComponent;
+    const engineFactory = (workflow, opts) => {
+      const { NodeRegistry, WorkflowEngine: WorkflowEngine2 } = (init_engine(), __toCommonJS(exports_engine));
+      const registry = new NodeRegistry({
+        toolRegistry: options.toolComponent,
+        agentComponent: options.env?.getComponent("agent"),
+        skillRegistry: skillRegistryAdapter,
+        sessionComponent: sessionComponentForEngine
+      });
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = (init_node_registry_helper(), __toCommonJS(exports_node_registry_helper));
+      registerDecoratorNodeType2(registry);
+      return new WorkflowEngine2(registry, sessionComponentForEngine, options.workflowRepository);
+    };
+    this.workflowService = new WorkflowService(options.workflowRepository, engineFactory, options.sessionComponent);
+    return this.workflowService;
+  }
+  async runWorkflow(definition, input, options) {
+    const { NodeRegistry } = await import("../../packages/core/src/env/workflow/engine/index.js");
+    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-hyza1gm7.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-qg9tcaph.js");
+        agentRunner = new AgentComponentAdapter(agentComponent);
+      }
+    }
+    const registry = new NodeRegistry({
+      toolRegistry: toolComponent,
+      skillRegistry: skillComponent,
+      agentRunner
+    });
+    registerDecoratorNodeType2(registry);
+    const engine = new WorkflowEngine(registry);
+    return engine.runWorkflow(definition, { ...options, input });
+  }
+  async onStop() {
+    componentLogger.info("[WorkflowComponent] Stopping and cleaning up resources...");
+    if (this.nodeRegistry) {
+      this.nodeRegistry = null;
+    }
+    if (this.workflowService) {
+      this.workflowService = null;
+      try {
+        const { closeDatabase } = await import("./roy-agent-core-qhyerewk.js");
+        closeDatabase();
+        componentLogger.info("[WorkflowComponent] SQLite database closed");
+      } catch (error) {
+        componentLogger.warn("[WorkflowComponent] Failed to close SQLite database:", error);
+      }
+    }
+    this._status = "stopped";
+    componentLogger.info("[WorkflowComponent] Cleanup completed");
+  }
+  async start() {
+    await super.start();
+    await this.initSqliteService();
+    await this.registerAskUserTool();
+  }
+  async registerAskUserTool() {
+    try {
+      const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+      if (!toolComponent) {
+        componentLogger.warn("ToolComponent not available, cannot register ask_user tool");
+        return;
+      }
+      if (typeof toolComponent.register === "function") {
+        toolComponent.register(askUserTool);
+        componentLogger.info("ask_user tool registered to ToolComponent");
+      } else if (typeof toolComponent.registerMany === "function") {
+        toolComponent.registerMany([askUserTool]);
+        componentLogger.info("ask_user tool registered to ToolComponent");
+      } else {
+        componentLogger.warn("ToolComponent does not support tool registration");
+      }
+    } catch (error) {
+      componentLogger.warn("Failed to register ask_user tool:", error);
+    }
+  }
+  async initSqliteService() {
+    try {
+      const { getDatabase, initializeTables } = await import("./roy-agent-core-qhyerewk.js");
+      const { WorkflowRepository } = await import("./roy-agent-core-4vmcvkav.js");
+      const db = getDatabase();
+      initializeTables();
+      const workflowRepository = new WorkflowRepository(db);
+      const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+      const llmComponent = this.llmComponent || this._workflowEnv?.getComponent("llm");
+      const agentComponent = this._workflowEnv?.getComponent("agent");
+      const skillComponent = this.skillRegistry || this._workflowEnv?.getComponent("skill");
+      const sessionComponent = this._workflowEnv?.getComponent("session");
+      componentLogger.info(`initSqliteService - toolComponent: ${!!toolComponent}, llmComponent: ${!!llmComponent}, skillRegistry: ${!!skillComponent}, sessionComponent: ${!!sessionComponent}`);
+      this.createService({
+        workflowRepository,
+        toolComponent,
+        llmComponent,
+        env: this._workflowEnv,
+        skillRegistry: skillComponent,
+        sessionComponent
+      });
+      this.sessionComponent = sessionComponent;
+      await this.registerAskUserTool();
+      componentLogger.info("SQLite WorkflowService initialized successfully");
+    } catch (error) {
+      componentLogger.error("Failed to initialize SQLite WorkflowService:", error);
+      await this.createInMemoryService();
+    }
+  }
+  createInMemoryService() {
+    const workflows = new Map;
+    const workflowRepository = {
+      create: (wf) => {
+        const id = wf.id || `wf_${Date.now()}`;
+        const record = { ...wf, id, createdAt: new Date, updatedAt: new Date };
+        workflows.set(id, record);
+        return record;
+      },
+      getById: (id) => workflows.get(id) || null,
+      getByName: (name) => {
+        for (const wf of workflows.values()) {
+          if (wf.name === name)
+            return wf;
+        }
+        return null;
+      },
+      list: () => Array.from(workflows.values()),
+      update: (id, updates) => {
+        const wf = workflows.get(id);
+        if (!wf)
+          return null;
+        const updated = { ...wf, ...updates, updatedAt: new Date };
+        workflows.set(id, updated);
+        return updated;
+      },
+      delete: (id) => workflows.delete(id)
+    };
+    const sessionComponent = this._workflowEnv?.getComponent("session");
+    return this.createService({
+      workflowRepository,
+      sessionComponent
+    });
+  }
+  async stop() {
+    componentLogger.info("Stopping WorkflowComponent...");
+    this._status = "stopping";
+    this.workflowService = null;
+    this.nodeRegistry = null;
+    this._status = "stopped";
+    componentLogger.info("WorkflowComponent stopped");
+  }
+}
+
+export { WorkflowComponent };

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

@@ -0,0 +1,10 @@
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./roy-agent-core-j8zx62zr.js";
+import"./roy-agent-core-fs0mn2jk.js";
+init_span_storage();
+
+export {
+  SQLiteSpanStorage
+};

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

@@ -0,0 +1,64 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/types/workflow-hil.ts
+function createNodeInterruptEvent(runId, nodeId, nodeType, query, agentSessionId) {
+  return {
+    type: "node.interrupt",
+    run_id: runId,
+    timestamp: Date.now(),
+    node_id: nodeId,
+    node_type: nodeType,
+    query,
+    ...agentSessionId ? { agent_session_id: agentSessionId } : {}
+  };
+}
+function createWorkflowAskUserEvent(runId, sessionId, nodeId, nodeType, query) {
+  return {
+    type: "workflow.ask-user",
+    run_id: runId,
+    timestamp: Date.now(),
+    session_id: sessionId,
+    node_id: nodeId,
+    node_type: nodeType,
+    query
+  };
+}
+var AskUserError;
+var init_workflow_hil = __esm(() => {
+  AskUserError = class AskUserError extends Error {
+    runId;
+    sessionId;
+    nodeId;
+    nodeType;
+    query;
+    agentSessionId;
+    timestamp;
+    type = "ask-user";
+    name = "AskUserError";
+    constructor(runId, sessionId, nodeId, nodeType, query, agentSessionId, timestamp = Date.now()) {
+      super(`[${nodeType}:${nodeId}] Ask user: ${query}`);
+      this.runId = runId;
+      this.sessionId = sessionId;
+      this.nodeId = nodeId;
+      this.nodeType = nodeType;
+      this.query = query;
+      this.agentSessionId = agentSessionId;
+      this.timestamp = timestamp;
+    }
+    toEvent() {
+      return {
+        type: "workflow.ask-user",
+        run_id: this.runId,
+        timestamp: this.timestamp,
+        session_id: this.sessionId,
+        node_id: this.nodeId,
+        node_type: this.nodeType,
+        query: this.query
+      };
+    }
+  };
+});
+
+export { createNodeInterruptEvent, createWorkflowAskUserEvent, AskUserError, init_workflow_hil };

package/dist/{env/memory/built-in/index.js → shared/@ai-setting/roy-agent-core-8mbmrwzs.js}

@@ -1,61 +1,10 @@
-// @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/memory/built-in/record-memory.ts
 import { z } from "zod";
 var RecordMemorySchema = z.object({
-  scope: z.enum(["project", "global"]).describe("\u4F5C\u7528\u57DF: project/global"),
-  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("\u6A21\u5F0F: append(\u8FFD\u52A0)/prepend(\u63D2\u5165)/overwrite(\u8986\u76D6)/delete(\u5220\u9664)"),
-  content: z.string().optional().describe("\u8BB0\u5FC6\u5185\u5BB9"),
-  title: z.string().optional().describe("\u7AE0\u8282\u6807\u9898")
+  scope: z.enum(["project", "global"]).describe("作用域: project/global"),
+  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("模式: append(追加)/prepend(插入)/overwrite(覆盖)/delete(删除)"),
+  content: z.string().optional().describe("记忆内容"),
+  title: z.string().optional().describe("章节标题")
 });
 function createRecordMemoryTool(recordMemory, getMemoryPaths, getMemoryFile) {
   return {
@@ -76,16 +25,16 @@ function createRecordMemoryTool(recordMemory, getMemoryPaths, getMemoryFile) {
           return {
             success: false,
             output: "",
-            error: "\u672A\u914D\u7F6E memory \u8DEF\u5F84\uFF0C\u65E0\u6CD5\u8BB0\u5F55\u8BB0\u5FC6",
+            error: "未配置 memory 路径，无法记录记忆",
             metadata: { execution_time_ms: Date.now() - startTime }
           };
         }
         const actionMessages = {
-          created: "\u5DF2\u521B\u5EFA\u8BB0\u5FC6\u6587\u4EF6",
-          overwrite: "\u5DF2\u8986\u76D6\u8BB0\u5FC6\u6587\u4EF6",
-          append: "\u5DF2\u8FFD\u52A0\u5185\u5BB9\u5230\u8BB0\u5FC6\u6587\u4EF6",
-          prepend: "\u5DF2\u63D2\u5165\u5185\u5BB9\u5230\u8BB0\u5FC6\u6587\u4EF6\u5F00\u5934",
-          delete: "\u5DF2\u5220\u9664\u8BB0\u5FC6\u6587\u4EF6"
+          created: "已创建记忆文件",
+          overwrite: "已覆盖记忆文件",
+          append: "已追加内容到记忆文件",
+          prepend: "已插入内容到记忆文件开头",
+          delete: "已删除记忆文件"
         };
         return {
           success: true,
@@ -119,17 +68,17 @@ function buildDescription(getMemoryPaths, getMemoryFile) {
     "",
     "| Mode | Description |",
     "|------|-------------|",
-    "| **append** | \u8FFD\u52A0\u5185\u5BB9\u5230 ${memoryFile} \u5C3E\u90E8 |",
-    "| **prepend** | \u63D2\u5165\u5185\u5BB9\u5230 ${memoryFile} \u5F00\u5934 |",
-    "| **overwrite** | \u8986\u76D6 ${memoryFile} |",
-    "| **delete** | \u5220\u9664 ${memoryFile} |",
+    "| **append** | 追加内容到 ${memoryFile} 尾部 |",
+    "| **prepend** | 插入内容到 ${memoryFile} 开头 |",
+    "| **overwrite** | 覆盖 ${memoryFile} |",
+    "| **delete** | 删除 ${memoryFile} |",
     "",
     `## Parameters`,
     "",
-    "- **scope** (required): \u4F5C\u7528\u57DF - project \u6216 global",
-    "- **mode** (required): \u64CD\u4F5C\u6A21\u5F0F",
-    "- **content** (optional): \u8BB0\u5FC6\u5185\u5BB9",
-    "- **title** (optional): \u7AE0\u8282\u6807\u9898",
+    "- **scope** (required): 作用域 - project 或 global",
+    "- **mode** (required): 操作模式",
+    "- **content** (optional): 记忆内容",
+    "- **title** (optional): 章节标题",
     "",
     `## Memory Paths`,
     ""
@@ -149,7 +98,7 @@ function buildDescription(getMemoryPaths, getMemoryFile) {
 // packages/core/src/env/memory/built-in/recall-memory.ts
 import { z as z2 } from "zod";
 var RecallMemorySchema = z2.object({
-  scope: z2.enum(["project", "global"]).optional().describe("\u4F5C\u7528\u57DF\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u8BFB\u53D6\u6240\u6709\uFF09")
+  scope: z2.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）")
 });
 function createRecallMemoryTool(recallMemory, getMemoryPaths, getMemoryFile) {
   return {
@@ -194,7 +143,7 @@ function buildDescription2(getMemoryPaths, getMemoryFile) {
     "",
     `## Parameters`,
     "",
-    "- **scope** (optional): \u4F5C\u7528\u57DF - project \u6216 global\uFF08\u4E0D\u4F20\u5219\u8BFB\u53D6\u6240\u6709\uFF09",
+    "- **scope** (optional): 作用域 - project 或 global（不传则读取所有）",
     "",
     `## Memory Files`,
     ""
@@ -218,8 +167,5 @@ function createMemoryTools(recordMemory, recallMemory, config) {
     createRecallMemoryTool(recallMemory, config.getMemoryPaths, config.getMemoryFile)
   ];
 }
-export {
-  createMemoryTools,
-  RecordMemorySchema,
-  RecallMemorySchema
-};
+
+export { RecordMemorySchema, RecallMemorySchema, createMemoryTools };