@ai-setting/roy-agent-core 1.5.44 → 1.5.45

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

@@ -0,0 +1,42 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/utils/workflow-message-metadata.ts
+function getWorkflowNodeIdFromMetadata(metadata) {
+  if (!metadata) {
+    return;
+  }
+  const nodeId = metadata.nodeId;
+  const workflowNodeId = metadata.workflowNodeId;
+  return nodeId ?? workflowNodeId;
+}
+function buildWorkflowNodeMetadata(type, nodeId, nodeType, extra) {
+  return {
+    _workflowNodeMetadata: true,
+    type,
+    nodeId,
+    workflowNodeId: nodeId,
+    workflowNodeType: nodeType,
+    ...extra
+  };
+}
+function patchAgentSessionIdOnMessage(metadata, parts, agentSessionId) {
+  const nextMetadata = {
+    ...metadata ?? {},
+    agentSessionId
+  };
+  if (!parts?.length) {
+    return { metadata: nextMetadata, parts };
+  }
+  const nextParts = parts.map((part) => {
+    if (part && typeof part === "object" && "nodeId" in part) {
+      return { ...part, agentSessionId };
+    }
+    return part;
+  });
+  return { metadata: nextMetadata, parts: nextParts };
+}
+var init_workflow_message_metadata = () => {};
+
+export { getWorkflowNodeIdFromMetadata, buildWorkflowNodeMetadata, patchAgentSessionIdOnMessage, init_workflow_message_metadata };

package/dist/shared/@ai-setting/{roy-agent-core-4jqq077c.js → roy-agent-core-6e3wz81d.js}

@@ -1,9 +1,9 @@
 import {
   createHook
-} from "./roy-agent-core-2dhd60aw.js";
+} from "./roy-agent-core-vdwvamre.js";
 import {
   HookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+} from "./roy-agent-core-rgj6hq15.js";
 
 // src/env/component.ts
 class BaseComponent {

package/dist/shared/@ai-setting/{roy-agent-core-pwkk12p4.js → roy-agent-core-6mcb7nqa.js}

@@ -138,6 +138,28 @@ class MemorySessionStore {
     session.updatedAt = Date.now();
     return msg.id;
   }
+  async updateMessage(sessionId, messageId, updates) {
+    const sessionMessages = this.messages.get(sessionId);
+    if (!sessionMessages) {
+      return false;
+    }
+    const index = sessionMessages.findIndex((m) => m.id === messageId);
+    if (index < 0) {
+      return false;
+    }
+    const current = sessionMessages[index];
+    sessionMessages[index] = {
+      ...current,
+      ...updates.content !== undefined ? { content: updates.content } : {},
+      ...updates.metadata !== undefined ? { metadata: updates.metadata } : {},
+      ...updates.parts !== undefined ? { parts: updates.parts } : {}
+    };
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.updatedAt = Date.now();
+    }
+    return true;
+  }
   async getMessages(sessionId, offset = 0, limit = 50, options) {
     let messages = this.messages.get(sessionId) ?? [];
     if (!options?.includeArchived) {
@@ -589,6 +611,44 @@ class SQLiteSessionStore {
     this.sessionsCache.set(sessionId, session);
     return msg.id;
   }
+  async updateMessage(sessionId, messageId, updates) {
+    await this.initialize();
+    const row = this.db.prepare("SELECT id FROM message WHERE id = ? AND session_id = ?").get(messageId, sessionId);
+    if (!row) {
+      return false;
+    }
+    const sets = [];
+    const values = [];
+    if (updates.content !== undefined) {
+      sets.push("content = ?");
+      values.push(updates.content);
+    }
+    if (updates.parts !== undefined) {
+      sets.push("parts = ?");
+      values.push(JSON.stringify(updates.parts));
+    }
+    if (updates.metadata !== undefined) {
+      sets.push("metadata = ?");
+      values.push(JSON.stringify(updates.metadata));
+    }
+    if (sets.length === 0) {
+      return true;
+    }
+    values.push(messageId, sessionId);
+    this.db.prepare(`UPDATE message SET ${sets.join(", ")} WHERE id = ? AND session_id = ?`).run(...values);
+    const messages = this.messagesCache.get(sessionId) ?? [];
+    const index = messages.findIndex((m) => m.id === messageId);
+    if (index >= 0) {
+      messages[index] = {
+        ...messages[index],
+        ...updates.content !== undefined ? { content: updates.content } : {},
+        ...updates.metadata !== undefined ? { metadata: updates.metadata } : {},
+        ...updates.parts !== undefined ? { parts: updates.parts } : {}
+      };
+      this.messagesCache.set(sessionId, messages);
+    }
+    return true;
+  }
   async getMessages(sessionId, offset = 0, limit = 50, options) {
     await this.initialize();
     let sql = "SELECT * FROM message WHERE session_id = ?";

package/dist/shared/@ai-setting/{roy-agent-core-9p43ap7h.js → roy-agent-core-8y804aat.js}

@@ -5,8 +5,9 @@ import {
   TaskHookPoints
 } from "./roy-agent-core-92z6t4he.js";
 import {
-  globalHookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
 import {
   createLogger,
   init_logger
@@ -73,6 +74,7 @@ function listKnownSubagentDescriptions(registry) {
 }
 
 // src/env/task/delegate/delegate-tool.ts
+init_global_hook_manager();
 var logger = createLogger("task:delegate");
 var BackgroundTaskEventTypes = {
   STARTED: "task.background.started",

package/dist/shared/@ai-setting/{roy-agent-core-r6rwsr54.js → roy-agent-core-9p604xjf.js}

@@ -17,13 +17,15 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
-  globalHookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
 import {
+  init_context,
   runWithEnvContextAsync
-} from "./roy-agent-core-z33en0cz.js";
+} from "./roy-agent-core-rm3hay00.js";
 import {
   createLogger,
   init_logger
@@ -67,6 +69,8 @@ var AGENT_CONFIG_REGISTRATION = {
 
 // src/env/agent/agent-component.ts
 init_decorator();
+init_global_hook_manager();
+init_context();
 init_workflow_hil();
 var logger = createLogger("agent:component");
 function toLLMMessage(msg) {
@@ -579,10 +583,12 @@ class AgentComponent extends BaseComponent {
           model: effectiveContext.model
         }
       });
-      this.pushMessage(hookCtx, {
-        role: "user",
-        content: query
-      });
+      if (query) {
+        this.pushMessage(hookCtx, {
+          role: "user",
+          content: query
+        });
+      }
       await this.executePluginHooks(agent, "agent:before.start", hookCtx);
       if (hookCtx._stopped) {
         return this.finalizeResult(result, hookCtx);
@@ -877,6 +883,7 @@ class AgentComponent extends BaseComponent {
       if (iteration >= agent.config.maxIterations && !result.finalText) {
         result.finalText = "Maximum iterations reached.";
       }
+      const newMessages = hookCtx.messages.slice(historyMessageCount);
       const reactContext = {
         messages: hookCtx.messages,
         sessionId: effectiveContext.sessionId,
@@ -886,6 +893,9 @@ class AgentComponent extends BaseComponent {
         ...hookCtx,
         ...reactContext
       });
+      if (hookCtx.structuredOutputExtracted) {
+        result.structuredOutput = hookCtx.structuredOutputExtracted;
+      }
       await this.executePluginHooks(agent, "agent:after.complete", hookCtx);
       if (this.aborted.get(runId) === true || hookCtx._stopped) {
         agent.status = "stopped";
@@ -913,7 +923,6 @@ class AgentComponent extends BaseComponent {
           }
         });
       }
-      let newMessages = hookCtx.messages.slice(historyMessageCount);
       logger.info(`Agent run completed: ${agentName}`, {
         iterations: result.iterations,
         hasError: !!result.error,
@@ -1030,6 +1039,14 @@ ${ctx.context.additionInfo}`
       };
     }
     try {
+      this.pushEnvEvent({
+        type: "tool.call",
+        payload: {
+          id: toolCall.id,
+          name: toolName,
+          arguments: toolCall.arguments
+        }
+      });
       const toolContext = {
         session_id: ctx.context.sessionId,
         message_id: ctx.context.messageId,
@@ -1169,6 +1186,9 @@ ${ctx.context.additionInfo}`
         if (msg.role === "system") {
           continue;
         }
+        if (msg.role === "user" && this.isEmptyMessage(msg.content)) {
+          continue;
+        }
         if (msg.role === "assistant" || msg.role === "tool") {
           if (this.isEmptyMessage(msg.content)) {
             continue;

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

@@ -7,13 +7,14 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   createHook
-} from "./roy-agent-core-2dhd60aw.js";
+} from "./roy-agent-core-vdwvamre.js";
 import {
-  globalHookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
 import {
   createLogger,
   init_logger
@@ -692,6 +693,7 @@ var PROMPT_CONFIG_REGISTRATION = {
 };
 
 // src/env/prompt/prompt-component.ts
+init_global_hook_manager();
 var logger2 = createLogger("prompt");
 
 class PromptComponent extends BaseComponent {

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

@@ -10,7 +10,7 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   createLogger,
   init_logger
@@ -21,6 +21,7 @@ import { z } from "zod";
 var McpServerLocalConfigSchema = z.object({
   type: z.literal("local"),
   command: z.array(z.string()).min(1),
+  cwd: z.string().optional(),
   environment: z.record(z.string(), z.string()).optional(),
   enabled: z.boolean().optional().default(true),
   timeout: z.number().int().positive().optional()
@@ -84,8 +85,148 @@ init_logger();
 
 // src/env/mcp/scanner.ts
 init_logger();
-import fs from "fs/promises";
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// src/env/mcp/command-resolver.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/env/mcp/npm-prefix.ts
+import fs from "fs";
+import { execSync } from "child_process";
+import os2 from "os";
 import path2 from "path";
+function pathExistsSync(p) {
+  try {
+    fs.accessSync(p, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getFallbackNpmPrefixPath() {
+  return path2.join(os2.homedir(), ".local", "share", "roy-agent", "npm-prefix");
+}
+function isUsableNpmPrefix(prefix) {
+  return pathExistsSync(path2.join(prefix, "lib")) || pathExistsSync(path2.join(prefix, "bin"));
+}
+function ensureNpmPrefixDirs(prefix) {
+  fs.mkdirSync(path2.join(prefix, "lib"), { recursive: true });
+  fs.mkdirSync(path2.join(prefix, "bin"), { recursive: true });
+}
+function ensureFallbackNpmPrefix() {
+  const fallback = getFallbackNpmPrefixPath();
+  ensureNpmPrefixDirs(fallback);
+  return fallback;
+}
+function readNpmConfigPrefix() {
+  try {
+    const prefix = execSync("npm config get prefix", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return prefix || undefined;
+  } catch {
+    return;
+  }
+}
+function resolveNpmPrefix() {
+  const candidates = [
+    process.env.NPM_CONFIG_PREFIX,
+    process.env.npm_config_prefix,
+    readNpmConfigPrefix(),
+    path2.join(os2.homedir(), ".npm-global")
+  ].filter(Boolean);
+  for (const prefix of candidates) {
+    if (isUsableNpmPrefix(prefix)) {
+      return prefix;
+    }
+  }
+  return ensureFallbackNpmPrefix();
+}
+function resolveGlobalNodeModulesPath() {
+  return path2.join(resolveNpmPrefix(), "lib", "node_modules");
+}
+function resolveGlobalBinPath() {
+  return path2.join(resolveNpmPrefix(), "bin");
+}
+
+// src/env/mcp/command-resolver.ts
+var PACKAGE_RUNNERS = new Set(["npx", "npm", "bunx", "yarn"]);
+function pathExistsSync2(p) {
+  try {
+    fs2.accessSync(p, fs2.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractPackageName(command) {
+  if (command.length < 2) {
+    return;
+  }
+  const runner = path3.basename(command[0]);
+  if (runner === "npx" || runner === "bunx") {
+    return command[1];
+  }
+  if (runner === "npm" && command[1] === "exec") {
+    const separatorIndex = command.indexOf("--");
+    if (separatorIndex >= 0) {
+      return command[separatorIndex + 1];
+    }
+    return command[2];
+  }
+  if (runner === "yarn" && command[1] === "dlx") {
+    return command[2];
+  }
+  return;
+}
+function isPackageRunnerCommand(command) {
+  if (command.length < 2) {
+    return false;
+  }
+  const runner = path3.basename(command[0]);
+  if (!PACKAGE_RUNNERS.has(runner)) {
+    return false;
+  }
+  if (runner === "npm") {
+    return command[1] === "exec";
+  }
+  if (runner === "yarn") {
+    return command[1] === "dlx";
+  }
+  return true;
+}
+function resolvePackageRunnerCommand(command, serverDir) {
+  if (!isPackageRunnerCommand(command)) {
+    return command;
+  }
+  const packageName = extractPackageName(command);
+  if (!packageName) {
+    return command;
+  }
+  const localBin = path3.join(serverDir, "node_modules", ".bin", packageName);
+  if (pathExistsSync2(localBin)) {
+    return [localBin];
+  }
+  return command;
+}
+function augmentNpmEnvForPackageRunner(command, env) {
+  if (!isPackageRunnerCommand(command)) {
+    return env;
+  }
+  const prefix = env.NPM_CONFIG_PREFIX ?? process.env.NPM_CONFIG_PREFIX ?? process.env.npm_config_prefix;
+  if (prefix && isUsableNpmPrefix(prefix)) {
+    return env;
+  }
+  return {
+    ...env,
+    NPM_CONFIG_PREFIX: ensureFallbackNpmPrefix()
+  };
+}
+
+// src/env/mcp/scanner.ts
 var logger = createLogger("mcp-scanner");
 var ENTRY_SCRIPT_CANDIDATES = [
   "server.mjs",
@@ -104,13 +245,13 @@ var ENTRY_SCRIPT_CANDIDATES = [
 function expandPath(inputPath) {
   if (inputPath.startsWith("~/")) {
     const home = process.env.HOME || process.env.USERPROFILE || "";
-    return path2.join(home, inputPath.slice(2));
+    return path4.join(home, inputPath.slice(2));
   }
-  return path2.resolve(inputPath);
+  return path4.resolve(inputPath);
 }
 async function pathExists(p) {
   try {
-    await fs.access(p);
+    await fs3.access(p);
     return true;
   } catch {
     return false;
@@ -118,7 +259,7 @@ async function pathExists(p) {
 }
 async function parseConfigJsonc(configPath) {
   try {
-    const configContent = await fs.readFile(configPath, "utf-8");
+    const configContent = await fs3.readFile(configPath, "utf-8");
     const cleaned = configContent.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
     return JSON.parse(cleaned);
   } catch (error) {
@@ -126,6 +267,12 @@ async function parseConfigJsonc(configPath) {
     return;
   }
 }
+function relativeCommandMatchesEntry(cmdPath, entryPath, serverDir) {
+  if (path4.resolve(serverDir, cmdPath) === entryPath) {
+    return true;
+  }
+  return ENTRY_SCRIPT_CANDIDATES.some((candidate) => cmdPath === candidate && entryPath === path4.join(serverDir, candidate));
+}
 function buildDefaultCommand(entryPath, directoryConfig, serverDir) {
   if (directoryConfig?.command) {
     const cmd = directoryConfig.command;
@@ -134,15 +281,14 @@ function buildDefaultCommand(entryPath, directoryConfig, serverDir) {
       return cmd;
     }
     if (cmdPath && entryPath) {
-      const resolvedConfigPath = path2.resolve(serverDir, cmdPath);
-      if (resolvedConfigPath === entryPath || cmdPath === "src/index.ts" || cmdPath === "src/index.js") {
+      if (relativeCommandMatchesEntry(cmdPath, entryPath, serverDir)) {
         return ["bun", "run", entryPath];
       }
     }
     if (entryPath) {
       return ["bun", "run", entryPath];
     }
-    return cmd;
+    return resolvePackageRunnerCommand(cmd, serverDir);
   }
   return entryPath ? ["bun", "run", entryPath] : undefined;
 }
@@ -170,10 +316,10 @@ class McpScanner {
     }
     logger.info(`[McpScanner] Scanning: ${expandedPath}`);
     try {
-      const entries = await fs.readdir(expandedPath, { withFileTypes: true });
+      const entries = await fs3.readdir(expandedPath, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path2.join(expandedPath, entry.name);
-        const stat = await fs.stat(fullPath);
+        const fullPath = path4.join(expandedPath, entry.name);
+        const stat = await fs3.stat(fullPath);
         if (!stat.isDirectory())
           continue;
         await this.discoverServer(entry.name, fullPath, mcpPath.type);
@@ -184,8 +330,8 @@ class McpScanner {
   }
   async discoverServer(name, serverDir, sourceType) {
     const entryPath = await this.findEntryScript(serverDir);
-    const configPath = path2.join(serverDir, "config.jsonc");
-    const packagePath = path2.join(serverDir, "package.json");
+    const configPath = path4.join(serverDir, "config.jsonc");
+    const packagePath = path4.join(serverDir, "package.json");
     let directoryConfig;
     if (await pathExists(configPath)) {
       directoryConfig = await parseConfigJsonc(configPath);
@@ -193,6 +339,7 @@ class McpScanner {
     const defaultCommand = buildDefaultCommand(entryPath, directoryConfig, serverDir);
     const server = {
       name,
+      serverDir,
       entryPath: entryPath || undefined,
       configPath: await pathExists(configPath) ? configPath : undefined,
       packagePath: await pathExists(packagePath) ? packagePath : undefined,
@@ -208,7 +355,7 @@ class McpScanner {
   }
   async findEntryScript(serverDir) {
     for (const candidate of ENTRY_SCRIPT_CANDIDATES) {
-      const entryPath = path2.join(serverDir, candidate);
+      const entryPath = path4.join(serverDir, candidate);
       if (await pathExists(entryPath)) {
         return entryPath;
       }
@@ -222,14 +369,14 @@ class McpScanner {
 
 // src/env/mcp/loader.ts
 init_logger();
-import fs2 from "fs/promises";
-import path3 from "path";
-import os2 from "os";
+import fs4 from "fs/promises";
+import path5 from "path";
+import os3 from "os";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 var logger2 = createLogger("mcp-loader");
-var AUTH_JSON_PATH = path3.join(os2.homedir(), ".roy-agent", "auth.json");
+var AUTH_JSON_PATH = path5.join(os3.homedir(), ".roy-agent", "auth.json");
 
 class McpLoader {
   clients = new Map;
@@ -252,6 +399,7 @@ class McpLoader {
     const localConfig = {
       type: "local",
       command,
+      ...server.serverDir ? { cwd: server.serverDir } : {},
       environment: server.directoryConfig?.environment,
       enabled: server.directoryConfig?.enabled ?? true,
       timeout: server.directoryConfig?.timeout ?? this.defaultTimeout
@@ -290,13 +438,16 @@ class McpLoader {
     let transport;
     if (config.type === "local") {
       const localConfig = config;
-      const env = { ...localConfig.environment };
+      const env = augmentNpmEnvForPackageRunner(localConfig.command, { ...localConfig.environment });
       await this.injectMinimaxEnv(env);
       transport = new StdioClientTransport({
         command: localConfig.command[0],
         args: localConfig.command.slice(1),
-        env
+        env,
+        ...localConfig.cwd ? { cwd: localConfig.cwd } : {},
+        stderr: "pipe"
       });
+      this.attachStderrDrain(name, transport);
       client = new Client({ name, version: "1.0.0" });
       await client.connect(transport);
     } else {
@@ -325,6 +476,21 @@ class McpLoader {
     this.clients.delete(name);
     logger2.info(`[McpLoader] Disconnected from ${name}`);
   }
+  attachStderrDrain(serverName, transport) {
+    const stderrStream = transport.stderr;
+    if (!stderrStream) {
+      return;
+    }
+    stderrStream.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) {
+        logger2.debug(`[McpLoader] ${serverName} stderr: ${text}`);
+      }
+    });
+    stderrStream.on("error", (error) => {
+      logger2.debug(`[McpLoader] ${serverName} stderr stream error`, { error });
+    });
+  }
   async closeTransport(transport, name) {
     try {
       const transportAny = transport;
@@ -355,7 +521,7 @@ class McpLoader {
   }
   async loadMinimaxApiKey() {
     try {
-      const content = await fs2.readFile(AUTH_JSON_PATH, "utf-8");
+      const content = await fs4.readFile(AUTH_JSON_PATH, "utf-8");
       const auth = JSON.parse(content);
       return auth.providers?.minimax?.apiKey;
     } catch (error) {
@@ -376,15 +542,15 @@ class McpLoader {
 }
 
 // src/env/mcp/mcp-config-registration.ts
-import path4 from "path";
-import os3 from "os";
+import path6 from "path";
+import os4 from "os";
 var MCP_DEFAULTS = {
   "mcp.enabled": true,
   "mcp.timeout": 30000,
   "mcp.mcpPaths": [
     {
       type: "user",
-      path: path4.join(os3.homedir(), ".config", "roy-agent", "mcp")
+      path: path6.join(os4.homedir(), ".config", "roy-agent", "mcp")
     },
     {
       type: "project",
@@ -625,4 +791,4 @@ class McpComponent extends BaseComponent {
     await this.loadServers();
   }
 }
-export { McpServerLocalConfigSchema, McpServerRemoteConfigSchema, McpServerConfigSchema, DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, getMcpPathPriority, McpScanner, McpLoader, McpComponent };
+export { McpServerLocalConfigSchema, McpServerRemoteConfigSchema, McpServerConfigSchema, DEFAULT_MCP_CONFIG, MCP_CONFIG_KEYS, getMcpPathPriority, isUsableNpmPrefix, ensureFallbackNpmPrefix, resolveNpmPrefix, resolveGlobalNodeModulesPath, resolveGlobalBinPath, resolvePackageRunnerCommand, augmentNpmEnvForPackageRunner, McpScanner, McpLoader, McpComponent };

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

@@ -15,7 +15,7 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   createLogger,
   init_logger
@@ -23,7 +23,7 @@ import {
 import {
   MemorySessionStore,
   SQLiteSessionStore
-} from "./roy-agent-core-pwkk12p4.js";
+} from "./roy-agent-core-6mcb7nqa.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";
@@ -341,6 +341,14 @@ class SessionComponent extends BaseComponent {
     const messages = await this.store?.getMessages(sessionId, options?.offset, options?.limit);
     return messages ?? [];
   }
+  async updateMessage(sessionId, messageId, updates) {
+    try {
+      return await this.store?.updateMessage(sessionId, messageId, updates) ?? false;
+    } catch (error) {
+      logger.error(`[SessionComponent] Failed to update message: ${error}`);
+      return false;
+    }
+  }
   async getMessageCount(sessionId, includeArchived) {
     return this.store?.getMessageCount(sessionId, includeArchived) ?? 0;
   }