@ai-setting/roy-agent-core 1.5.37 → 1.5.41

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

@@ -0,0 +1,147 @@
+import {
+  BaseComponent
+} from "./roy-agent-core-4jqq077c.js";
+import {
+  globalHookManager
+} from "./roy-agent-core-jqy2mdyq.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-10n2jh7p.js";
+
+// src/env/plugin/plugin-component.ts
+init_logger();
+
+class PluginComponent extends BaseComponent {
+  name = "plugin";
+  version = "1.0.0";
+  registry = new Map;
+  componentCache = new Map;
+  logger = createLogger("plugin");
+  configComponent;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for PluginComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    this.setStatus("running");
+    this.logger.info("[PluginComponent] Initialized");
+  }
+  register(plugin) {
+    if (this.registry.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    const env = this.createPluginEnv(plugin);
+    try {
+      const result = plugin.init(env);
+      if (result instanceof Promise) {
+        result.then(() => {
+          this.registry.set(plugin.name, plugin);
+          this.logger.info(`Registered plugin: ${plugin.name}`);
+        }).catch((err) => {
+          this.logger.error(`Failed to init plugin ${plugin.name}: ${err}`);
+          throw err;
+        });
+      } else {
+        this.registry.set(plugin.name, plugin);
+        this.logger.info(`Registered plugin: ${plugin.name}`);
+      }
+    } catch (err) {
+      this.logger.error(`Failed to init plugin ${plugin.name}: ${err}`);
+      throw err;
+    }
+  }
+  unregister(name) {
+    const plugin = this.registry.get(name);
+    if (!plugin) {
+      return false;
+    }
+    try {
+      plugin.dispose();
+      this.registry.delete(name);
+      this.logger.info(`Unregistered plugin: ${name}`);
+      return true;
+    } catch (err) {
+      this.logger.error(`Failed to dispose plugin ${name}: ${err}`);
+      return false;
+    }
+  }
+  get(name) {
+    return this.registry.get(name);
+  }
+  list() {
+    return Array.from(this.registry.values());
+  }
+  has(name) {
+    return this.registry.has(name);
+  }
+  getConfig(name) {
+    return this.configComponent?.get(`plugin.${name}`);
+  }
+  registerAll(plugins) {
+    for (const plugin of plugins) {
+      this.register(plugin);
+    }
+  }
+  async stop() {
+    this.setStatus("stopping");
+    this.logger.info("[PluginComponent] Stopping...");
+    for (const [name, plugin] of this.registry) {
+      try {
+        const result = plugin.dispose();
+        if (result instanceof Promise) {
+          await result;
+        }
+        this.logger.debug(`Disposed plugin: ${name}`);
+      } catch (err) {
+        this.logger.error(`Failed to dispose plugin ${name}: ${err}`);
+      }
+    }
+    this.registry.clear();
+    this.componentCache.clear();
+    this.setStatus("stopped");
+    this.logger.info("[PluginComponent] Stopped");
+  }
+  createPluginEnv(plugin) {
+    const self = this;
+    return {
+      getComponent(name) {
+        return self.env?.getComponent(name);
+      },
+      registerAgent(config) {
+        const agentComponent = self.env?.getComponent("agent");
+        if (agentComponent) {
+          agentComponent.registerAgent(config.name, config);
+          self.logger.debug(`Registered agent: ${config.name} (for plugin: ${plugin.name})`);
+        } else {
+          self.logger.warn(`Cannot register agent ${config.name}: AgentComponent not available`);
+        }
+      },
+      registerTool(tool) {
+        const toolComponent = self.env?.getComponent("tool");
+        if (toolComponent) {
+          toolComponent.register(tool);
+          self.logger.debug(`Registered tool: ${tool.name} (for plugin: ${plugin.name})`);
+        } else {
+          self.logger.warn(`Cannot register tool ${tool.name}: ToolComponent not available`);
+        }
+      },
+      registerHook(hook) {
+        globalHookManager.register(hook.point, {
+          name: `${plugin.name}:${hook.point}`,
+          priority: hook.priority ?? plugin.priority,
+          execute: hook.handler
+        });
+        self.logger.debug(`Registered hook: ${hook.point} (for plugin: ${plugin.name})`);
+      },
+      logger: createLogger(`plugin:${plugin.name}`)
+    };
+  }
+}
+
+export { PluginComponent };

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

@@ -1,29 +1,29 @@
+import {
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
-import {
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
+} from "./roy-agent-core-4jqq077c.js";
 import {
   createLogger,
   init_logger,
   setConfigComponent,
   setQuietMode
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
   getTracerProvider,
   init_propagation,
   init_tracer_provider,
   init_types,
   propagation
-} from "./roy-agent-core-xs5rsgat.js";
+} from "./roy-agent-core-58k274fg.js";
 import {
   SQLiteSpanStorage,
   init_span_storage
-} from "./roy-agent-core-psv4v63c.js";
+} from "./roy-agent-core-c6592r3c.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -8,15 +8,15 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
+} from "./roy-agent-core-4jqq077c.js";
 import {
   ToolHookPoints,
   globalHookManager
-} from "./roy-agent-core-86gphny5.js";
+} from "./roy-agent-core-jqy2mdyq.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/{roy-agent-core-3jywqmdd.js → roy-agent-core-e9fdm13a.js}

@@ -1,34 +1,25 @@
+import {
+  BasePlugin
+} from "./roy-agent-core-az13yzmc.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-92z6t4he.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  getEnvContextOrEmpty
+} from "./roy-agent-core-z33en0cz.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
+  __legacyDecorateClassTS,
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/task/plugins/task-plugin.ts
-class TaskPlugin {
-  config;
-  constructor(config = {}) {
-    this.config = { enabled: true, priority: 0, ...config };
-  }
-  getHookPoints() {
-    return this.hooks.map((h) => h.point);
-  }
-  getPriorityForHook(hookPoint) {
-    const hook = this.hooks.find((h) => h.point === hookPoint);
-    return hook?.priority ?? this.config.priority ?? 0;
-  }
-  isEnabled() {
-    return this.config.enabled ?? true;
-  }
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-  }
-}
 // src/env/task/plugins/task-tag-plugin.ts
 init_logger();
 
@@ -200,42 +191,49 @@ async function parseExtractorOutput(output) {
 }
 
 // src/env/task/plugins/task-tag-plugin.ts
-var logger = createLogger("task:plugin:tag");
+var logger = createLogger("plugin:task-tag");
 
-class TaskTagPlugin extends TaskPlugin {
-  name = "TaskTagPlugin";
-  hooks = [
-    { point: TaskHookPoints.DELEGATE_BEFORE, priority: 20 },
-    { point: TaskHookPoints.OPERATION_AFTER_CREATE, priority: 10 }
-  ];
+class TaskTagPlugin extends BasePlugin {
+  name = "task-tag";
+  version = "1.0.0";
+  description = "Inject similar task information into delegate prompt and extract workflow on task completion";
+  env;
   taskComponent = null;
   agentComponent = null;
-  constructor(config = {}) {
-    super({ enabled: true, priority: 0, ...config });
+  tagService = null;
+  constructor() {
+    super();
   }
-  static getRequiredAgents() {
-    return [createWorkflowExtractorAgent()];
-  }
-  setComponents(_llmComponent, taskComponent) {
-    this.taskComponent = taskComponent;
-    if (taskComponent?.env) {
-      this.agentComponent = taskComponent.env.getComponent("agent");
+  init(env) {
+    this.env = env;
+    this.taskComponent = env.getComponent("task");
+    if (this.taskComponent && typeof this.taskComponent.getTagService === "function") {
+      this.tagService = this.taskComponent.getTagService();
     }
+    this.agentComponent = env.getComponent("agent");
+    env.registerHook({
+      point: TaskHookPoints.DELEGATE_BEFORE,
+      priority: 20,
+      handler: this.onDelegateBefore.bind(this)
+    });
+    env.registerHook({
+      point: TaskHookPoints.OPERATION_AFTER_CREATE,
+      priority: 10,
+      handler: this.onOperationAfterCreate.bind(this)
+    });
+    env.registerAgent(createWorkflowExtractorAgent());
+    logger.info("[TaskTagPlugin] Initialized");
   }
-  async execute(ctx) {
-    if (!this.config.enabled)
-      return;
-    switch (ctx.hookPoint) {
-      case TaskHookPoints.DELEGATE_BEFORE:
-        await this.onDelegateBefore(ctx);
-        break;
-      case TaskHookPoints.OPERATION_AFTER_CREATE:
-        await this.onOperationAfterCreate(ctx);
-        break;
-    }
+  dispose() {
+    this.env = null;
+    this.taskComponent = null;
+    this.agentComponent = null;
+    this.tagService = null;
+    logger.info("[TaskTagPlugin] Disposed");
   }
   async onDelegateBefore(ctx) {
-    const { taskId, tagService, prompt } = ctx.data;
+    const data = ctx.data;
+    const { taskId, prompt } = data;
     if (!taskId || !this.taskComponent) {
       return;
     }
@@ -246,15 +244,14 @@ class TaskTagPlugin extends TaskPlugin {
       const keywords = this.extractKeywords(currentTask);
       if (keywords.length === 0)
         return;
-      const tagServiceForSearch = tagService;
-      const similarTasks = await tagServiceForSearch?.findSimilarTasksByKeywords?.(keywords, {
+      const similarTasks = await this.tagService?.findSimilarTasksByKeywords?.(keywords, {
         limit: 5,
         excludeTaskId: taskId
       }) ?? [];
       if (similarTasks.length === 0)
         return;
       const hint = this.formatSimilarTasks(similarTasks);
-      ctx.data.prompt = `${hint}
+      data.prompt = `${hint}
 
 ---
 
@@ -314,7 +311,7 @@ ${prompt}`;
         return;
       const operations = await this.taskComponent?.listOperations({ taskId }) ?? [];
       const allSessionIds = [...new Set([sessionId, ...operations.map((op) => op.sessionId).filter(Boolean)])];
-      const sessionComponent = this.taskComponent?.env?.getComponent("session");
+      const sessionComponent = this.env.getComponent("session");
       const allMessages = [];
       for (const sid of allSessionIds) {
         try {
@@ -355,23 +352,24 @@ ${prompt}`;
         actionTitle: `Workflow extracted: ${workflow.name}`,
         actionDescription: workflow.id
       });
-      logger.info(`Workflow extracted: ${workflow.id}`);
+      logger.info(`[TaskTagPlugin] Workflow extracted: ${workflow.id}`);
     } catch (error) {
-      logger.warn(`Workflow extraction failed: ${error}`);
+      logger.warn(`[TaskTagPlugin] Workflow extraction failed: ${error}`);
     }
   }
+  _workflowRepo = null;
   async getWorkflowRepository() {
-    const workflowComponent = this.taskComponent?.env?.getComponent("workflow");
+    const workflowComponent = this.env.getComponent("workflow");
     if (workflowComponent?.workflowService?.workflowRepository) {
       return workflowComponent.workflowService.workflowRepository;
     }
     if (!this._workflowRepo) {
       try {
-        const sqlite = await import("./roy-agent-core-wft9ra24.js");
+        const sqlite = await import("./roy-agent-core-zwp3jp02.js");
         this.ensureDataDir();
         const db = sqlite.getDatabase();
         sqlite.initializeTables();
-        const { WorkflowRepository } = await import("./roy-agent-core-bcbqy27c.js");
+        const { WorkflowRepository } = await import("./roy-agent-core-ty33mnr7.js");
         this._workflowRepo = new WorkflowRepository(db);
         return this._workflowRepo;
       } catch {
@@ -382,12 +380,268 @@ ${prompt}`;
   }
   ensureDataDir() {
     const { join } = __require("path");
-    const { mkdirSync, existsSync } = __require("fs");
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    const dataDir = join(home, ".local", "share", "roy-agent");
-    if (!existsSync(dataDir))
-      mkdirSync(dataDir, { recursive: true });
+    const dataDir = join(process.env.XDG_DATA_HOME || join(process.env.HOME || "", ".local/share"), "roy-agent");
+    __require("fs").mkdirSync(dataDir, { recursive: true });
   }
-  _workflowRepo = null;
 }
-export { TaskPlugin, WORKFLOW_EXTRACTOR_PROMPT, createWorkflowExtractorAgent, formatExtractorInput, formatExtractorInputFromDescription, parseExtractorOutput, TaskTagPlugin };
+// src/env/task/plugins/lark-cli-task-notify-plugin.ts
+init_decorator();
+init_logger();
+import { spawn } from "child_process";
+var logger2 = createLogger("lark-cli:task-notify");
+function isTaskNotifyDebugEnabled() {
+  return process.env.ROY_TASK_NOTIFY_DEBUG === "1" || process.env.ROY_TRACE_DEBUG === "1";
+}
+var NotifyType;
+((NotifyType2) => {
+  NotifyType2["TASK_CREATED"] = "task_created";
+  NotifyType2["TASK_COMPLETED"] = "task_completed";
+  NotifyType2["TASK_UPDATED"] = "task_updated";
+  NotifyType2["TASK_FAILED"] = "task_failed";
+})(NotifyType ||= {});
+
+class LarkCliTaskNotifyHook {
+  name;
+  priority;
+  description;
+  pluginName;
+  sourceId;
+  config;
+  constructor(config = {}) {
+    this.name = config.pluginName || "LarkCliTaskNotifyHook";
+    this.priority = config.priority ?? 5;
+    this.description = "LarkCli 任务通知 Hook";
+    this.pluginName = config.pluginName;
+    this.sourceId = config.sourceId;
+    this.config = {
+      enabled: true,
+      priority: 5,
+      notifyTypes: ["task_completed" /* TASK_COMPLETED */],
+      ...config
+    };
+  }
+  async execute(ctx) {
+    if (!this.config.enabled) {
+      return;
+    }
+    const env = getEnvContextOrEmpty();
+    if (this.pluginName && this.sourceId) {
+      const key = `${this.sourceId}:${this.pluginName}`;
+      if (env.pluginEnabled && env.pluginEnabled[key] !== true) {
+        logger2.debug(`Plugin not enabled for source: ${key}`);
+        return;
+      }
+    }
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.AFTER_CREATE:
+        await this.onAfterCreate(ctx);
+        break;
+      case TaskHookPoints.AFTER_UPDATE:
+        await this.onAfterUpdate(ctx);
+        break;
+    }
+  }
+  async onAfterCreate(ctx) {
+    const { task } = ctx.data;
+    if (!this.shouldNotify("task_created" /* TASK_CREATED */))
+      return;
+    await this.sendNotify({
+      type: "task_created" /* TASK_CREATED */,
+      title: `\uD83D\uDCDD 任务已创建`,
+      content: this.formatTaskCreated(task)
+    });
+  }
+  async onAfterUpdate(ctx) {
+    const hookCtx = ctx.data;
+    const innerData = hookCtx.data;
+    if (!innerData) {
+      return;
+    }
+    const { task, changes } = innerData;
+    if (!task) {
+      return;
+    }
+    let notifyType;
+    let notifyChanges = changes || {};
+    if (changes?.status === "completed" || changes?.progress === 100) {
+      notifyType = "task_completed" /* TASK_COMPLETED */;
+    } else if (changes?.status) {
+      notifyType = "task_updated" /* TASK_UPDATED */;
+    } else if (task.status === "completed" || task.progress === 100) {
+      notifyType = "task_completed" /* TASK_COMPLETED */;
+      notifyChanges = { status: task.status, progress: task.progress };
+    } else if (changes && Object.keys(changes).length > 0) {
+      notifyType = "task_updated" /* TASK_UPDATED */;
+    } else {
+      return;
+    }
+    if (!this.shouldNotify(notifyType)) {
+      return;
+    }
+    await this.sendNotify({
+      type: notifyType,
+      title: this.getNotifyTitle(notifyType),
+      content: this.formatTaskUpdate(task, notifyChanges),
+      _hookContext: ctx
+    });
+  }
+  async sendNotify(options) {
+    const { type, title, content, _hookContext } = options;
+    const env = getEnvContextOrEmpty();
+    let replyChannel = env.replyChannel;
+    const envContextFromMetadata = env.metadata?.envContext;
+    if (!replyChannel && envContextFromMetadata) {
+      replyChannel = envContextFromMetadata.replyChannel;
+    }
+    if (!replyChannel && _hookContext?.metadata?.envContext) {
+      replyChannel = _hookContext.metadata.envContext.replyChannel;
+    }
+    const chatId = replyChannel?.chatId;
+    const messageId = replyChannel?.messageId;
+    if (!chatId && !messageId) {
+      logger2.debug(`No replyChannel available for ${type}`);
+      return;
+    }
+    const message = `${title}
+
+${content}`;
+    try {
+      if (isTaskNotifyDebugEnabled()) {
+        logger2.debug(`Sending message - messageId: ${messageId}`);
+      }
+      await this.sendLarkMessage({
+        chatId,
+        messageId,
+        content: message
+      });
+      logger2.info(`Notification sent: ${type}`);
+    } catch (error) {
+      logger2.error(`Failed to send notification: ${error}`);
+    }
+  }
+  sendLarkMessage(options) {
+    return new Promise((resolve, reject) => {
+      const { chatId, messageId, content } = options;
+      let args;
+      if (messageId) {
+        args = [
+          "im",
+          "+messages-reply",
+          "--message-id",
+          messageId,
+          "--markdown",
+          content,
+          "--as",
+          "bot"
+        ];
+      } else {
+        args = [
+          "im",
+          "+messages-send",
+          "--chat-id",
+          chatId,
+          "--markdown",
+          content
+        ];
+      }
+      const proc = spawn("lark-cli", args, {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          logger2.debug(`lark-cli output: ${stdout}`);
+          resolve();
+        } else {
+          reject(new Error(`lark-cli exited with code ${code}: ${stderr}`));
+        }
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  shouldNotify(type) {
+    const { notifyTypes } = this.config;
+    if (notifyTypes && notifyTypes.length === 0)
+      return true;
+    if (notifyTypes)
+      return notifyTypes.includes(type);
+    return type === "task_completed" /* TASK_COMPLETED */;
+  }
+  getNotifyTitle(type) {
+    const template = this.config.templates?.[type];
+    if (template)
+      return template;
+    switch (type) {
+      case "task_created" /* TASK_CREATED */:
+        return "\uD83D\uDCDD 任务已创建";
+      case "task_completed" /* TASK_COMPLETED */:
+        return "✅ 任务已完成";
+      case "task_updated" /* TASK_UPDATED */:
+        return "\uD83D\uDCCB 任务已更新";
+      case "task_failed" /* TASK_FAILED */:
+        return "❌ 任务执行失败";
+      default:
+        return "\uD83D\uDCEC 任务通知";
+    }
+  }
+  formatTaskCreated(task) {
+    const lines = [];
+    if (task.title) {
+      lines.push(`- **标题**: ${task.title}`);
+    }
+    if (task.description) {
+      const desc = task.description.substring(0, 100) + (task.description.length > 100 ? "..." : "");
+      lines.push(`- **描述**: ${desc}`);
+    }
+    if (task.priority) {
+      lines.push(`- **优先级**: ${task.priority}`);
+    }
+    return lines.join(`
+`);
+  }
+  formatTaskUpdate(task, changes) {
+    const lines = [];
+    if (task.title) {
+      lines.push(`- **标题**: ${task.title}`);
+    }
+    lines.push(`- **ID**: ${task.id}`);
+    if (changes?.status) {
+      lines.push(`- **状态**: ${changes.status}`);
+    }
+    if (changes?.progress !== undefined) {
+      lines.push(`- **进度**: ${changes.progress}%`);
+    }
+    if (changes?.current_status) {
+      lines.push(`- **当前状态**: ${changes.current_status}`);
+    }
+    const changeKeys = Object.keys(changes || {}).filter((k) => !["status", "progress", "current_status"].includes(k));
+    if (changeKeys.length > 0) {
+      lines.push(`- **变更**: ${changeKeys.join(", ")}`);
+    }
+    return lines.join(`
+`);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.execute")
+], LarkCliTaskNotifyHook.prototype, "execute", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.sendNotify")
+], LarkCliTaskNotifyHook.prototype, "sendNotify", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.sendLarkMessage")
+], LarkCliTaskNotifyHook.prototype, "sendLarkMessage", null);
+function createLarkCliTaskNotifyHook(config = {}) {
+  return new LarkCliTaskNotifyHook(config);
+}
+export { WORKFLOW_EXTRACTOR_PROMPT, createWorkflowExtractorAgent, formatExtractorInput, formatExtractorInputFromDescription, parseExtractorOutput, TaskTagPlugin, NotifyType, LarkCliTaskNotifyHook, createLarkCliTaskNotifyHook };

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

@@ -2,17 +2,17 @@ import {
   ContextError,
   ErrorCodes
 } from "./roy-agent-core-ctdhjv68.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-zgypchmt.js";
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-4jqq077c.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -6,11 +6,11 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
+} from "./roy-agent-core-4jqq077c.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 
 // src/env/memory/types.ts
 import { z } from "zod";