@ai-setting/roy-agent-core 1.5.52 → 1.5.53

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

@@ -1,3 +1,6 @@
+import {
+  invoke
+} from "./roy-agent-core-4ch3ghj6.js";
 import {
   ContextError,
   ErrorCodes
@@ -23,8 +26,7 @@ import {
   init_logger
 } from "./roy-agent-core-10n2jh7p.js";
 import {
-  __legacyDecorateClassTS,
-  __require
+  __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/llm/types.ts
@@ -309,581 +311,6 @@ class LLMTransform {
     return JSON.stringify(args);
   }
 }
-// src/env/llm/invoke.ts
-init_logger();
-import { randomUUID } from "crypto";
-import { streamText, jsonSchema } from "ai";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { zodToJsonSchema } from "zod-to-json-schema";
-var logger = createLogger("llm:invoke");
-var MAX_RETRIES = 3;
-function parseModelString(model) {
-  if (!model) {
-    return { providerId: "openai", modelId: "gpt-4o" };
-  }
-  const parts = model.split("/");
-  if (parts.length >= 2) {
-    return { providerId: parts[0], modelId: parts.slice(1).join("/") };
-  }
-  return { providerId: "openai", modelId: model };
-}
-function extractUsageInfo(usage) {
-  if (!usage)
-    return;
-  if (usage.inputTokens && typeof usage.inputTokens === "object") {
-    return {
-      promptTokens: usage.inputTokens.total ?? 0,
-      completionTokens: usage.outputTokens?.total ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
-  }
-  if (typeof usage.promptTokens === "number") {
-    return {
-      promptTokens: usage.promptTokens,
-      completionTokens: usage.completionTokens ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
-  }
-  if (usage.inputTokenDetails || usage.outputTokenDetails) {
-    return {
-      promptTokens: usage.inputTokenDetails?.tokens ?? 0,
-      completionTokens: usage.outputTokenDetails?.tokens ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
-  }
-  if (usage.raw && typeof usage.raw.total_tokens === "number") {
-    return {
-      promptTokens: 0,
-      completionTokens: 0,
-      totalTokens: usage.raw.total_tokens
-    };
-  }
-  return;
-}
-function convertToSDKMessages(messages) {
-  return messages.map((msg) => {
-    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
-      const toolCallParts = msg.toolCalls.map((tc) => {
-        let input = {};
-        if (tc.function?.arguments) {
-          if (typeof tc.function.arguments === "string") {
-            try {
-              const parsed = JSON.parse(tc.function.arguments);
-              input = typeof parsed === "string" ? { _raw: parsed } : parsed;
-            } catch {
-              input = { _raw: tc.function.arguments };
-            }
-          } else {
-            input = tc.function.arguments;
-          }
-        } else if (tc.arguments) {
-          if (typeof tc.arguments === "string") {
-            try {
-              const parsed = JSON.parse(tc.arguments);
-              input = typeof parsed === "string" ? { _raw: parsed } : parsed;
-            } catch {
-              input = { _raw: tc.arguments };
-            }
-          } else {
-            input = tc.arguments;
-          }
-        }
-        return {
-          type: "tool-call",
-          toolCallId: tc.id,
-          toolName: tc.function?.name || tc.name || "unknown",
-          input
-        };
-      });
-      return {
-        role: "assistant",
-        content: toolCallParts
-      };
-    }
-    if (msg.role === "tool") {
-      if (!msg.toolCallId) {
-        logger.warn("Tool message missing toolCallId", { msg });
-      }
-      let outputValue = "";
-      const content = msg.content;
-      if (typeof content === "string") {
-        outputValue = content;
-      } else if (Array.isArray(content)) {
-        const toolResultPart = content.find((p) => p?.type === "tool-result");
-        if (toolResultPart) {
-          outputValue = typeof toolResultPart.output === "string" ? toolResultPart.output : JSON.stringify(toolResultPart.output);
-        } else {
-          outputValue = JSON.stringify(content);
-        }
-      } else {
-        outputValue = JSON.stringify(content);
-      }
-      const converted = {
-        role: "tool",
-        content: [{
-          type: "tool-result",
-          toolCallId: msg.toolCallId || "unknown",
-          toolName: msg.name || "unknown",
-          output: {
-            type: "text",
-            value: outputValue
-          }
-        }]
-      };
-      return converted;
-    }
-    return msg;
-  });
-}
-function convertToolsToSDK(tools) {
-  const result = {};
-  for (const tool of tools) {
-    const jsonSchemaObj = extractToolSchema(tool.parameters);
-    result[tool.name] = {
-      description: tool.description || "",
-      inputSchema: jsonSchema(jsonSchemaObj)
-    };
-  }
-  return result;
-}
-function extractToolSchema(parameters) {
-  if (parameters && typeof parameters === "object" && "_def" in parameters) {
-    const zodSchema = parameters;
-    const schema = zodToJsonSchema(zodSchema, "zod");
-    if ("$ref" in schema && schema.definitions) {
-      const def = schema.definitions.zod;
-      if (def && def.type === "object" && def.properties) {
-        return {
-          type: "object",
-          properties: def.properties,
-          required: def.required,
-          additionalProperties: true
-        };
-      }
-    }
-    return schema;
-  }
-  return parameters;
-}
-function generateProviderOptions(providerType, options) {
-  const result = {
-    providerOptions: {}
-  };
-  if (options.temperature !== undefined) {
-    result.temperature = options.temperature;
-  }
-  if (options.maxTokens !== undefined) {
-    result.maxTokens = options.maxTokens;
-  }
-  switch (providerType) {
-    case "anthropic":
-      break;
-    case "openai-compatible":
-      result.providerOptions.includeUsage = true;
-      break;
-  }
-  return result;
-}
-function createEnvEventEmitter(env, context) {
-  if (!env) {
-    logger.warn("[invoke] createEnvEventEmitter: env is null/undefined, streaming events will be disabled");
-    return null;
-  }
-  return (event) => {
-    try {
-      const fullType = `llm.${event.type}`;
-      logger.info(`[invoke] Pushing LLM event: ${fullType}`, {
-        hasPayload: !!event,
-        payloadType: typeof event
-      });
-      env.pushEnvEvent({
-        id: randomUUID(),
-        type: fullType,
-        timestamp: Date.now(),
-        metadata: {
-          source: "llm.invoke",
-          sessionId: context?.sessionId,
-          messageId: context?.messageId
-        },
-        payload: event
-      });
-      logger.info(`[invoke] LLM event pushed successfully: ${fullType}`);
-    } catch (err) {
-      logger.warn("Failed to push env event", { error: String(err), eventType: event.type });
-    }
-  };
-}
-function getStreamPartText(part) {
-  const value = part.text ?? part.delta ?? part.textDelta;
-  return typeof value === "string" ? value : "";
-}
-function processThinkingStream(textDelta, config, state) {
-  if (!config.enabled || !textDelta) {
-    return {
-      cleanedText: textDelta,
-      isThinkingTagOpen: state.isOpen,
-      currentThinkingContent: state.content,
-      reasoningEvents: []
-    };
-  }
-  const tags = config.tags || ["thinking"];
-  let remainingText = textDelta;
-  const reasoningEvents2 = [];
-  let isOpen2 = state.isOpen;
-  let currentContent2 = state.content;
-  for (const tag of tags) {
-    const openTag = `<${tag}>`;
-    const closeTag = `</${tag}>`;
-    let text = remainingText;
-    let result = "";
-    const openIndex = text.toLowerCase().indexOf(openTag.toLowerCase());
-    const closeIndex = text.toLowerCase().indexOf(closeTag.toLowerCase());
-    if (openIndex !== -1 && (closeIndex === -1 || openIndex < closeIndex)) {
-      const beforeOpen = text.substring(0, openIndex);
-      const afterOpen = text.substring(openIndex + openTag.length);
-      if (!isOpen2) {
-        isOpen2 = true;
-        currentContent2 = "";
-        reasoningEvents2.push("");
-      }
-      result += beforeOpen;
-      const innerCloseIndex = afterOpen.toLowerCase().indexOf(closeTag.toLowerCase());
-      if (innerCloseIndex !== -1) {
-        const thinkingContent = afterOpen.substring(0, innerCloseIndex);
-        const afterClose = afterOpen.substring(innerCloseIndex + closeTag.length);
-        currentContent2 += thinkingContent;
-        reasoningEvents2.push(currentContent2);
-        isOpen2 = false;
-        currentContent2 = "";
-        result += afterClose;
-      } else {
-        currentContent2 += afterOpen;
-        reasoningEvents2.push(currentContent2);
-        result += "";
-      }
-      remainingText = result;
-    } else if (closeIndex !== -1) {
-      const beforeClose = text.substring(0, closeIndex);
-      const afterClose = text.substring(closeIndex + closeTag.length);
-      if (isOpen2) {
-        currentContent2 += beforeClose;
-        reasoningEvents2.push(currentContent2);
-        isOpen2 = false;
-        currentContent2 = "";
-        result = afterClose;
-      } else {
-        result = text;
-      }
-      remainingText = result;
-    }
-  }
-  if (isOpen2 && remainingText === textDelta) {
-    currentContent2 += remainingText;
-    reasoningEvents2.push(currentContent2);
-    remainingText = "";
-  }
-  return {
-    cleanedText: remainingText,
-    isThinkingTagOpen: isOpen2,
-    currentThinkingContent: currentContent2,
-    reasoningEvents: reasoningEvents2
-  };
-}
-async function invoke(config, options, ctx) {
-  try {
-    const emitToEnv = createEnvEventEmitter(options.env, options.context);
-    logger.info("[invoke] Created event emitter, env available:", !!options.env, "context:", options.context);
-    const { providerId, modelId } = parseModelString(options.model || config.model);
-    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
-    if (!provider) {
-      throw new Error(`Failed to create provider for ${providerId}`);
-    }
-    const messages = convertToSDKMessages(options.messages);
-    const toolCallIds = new Set;
-    const assistantToolCalls = [];
-    const toolResultIds = [];
-    for (const msg of messages) {
-      if (msg.role === "assistant") {
-        const assistantContent = Array.isArray(msg.content) ? msg.content : [];
-        for (const part of assistantContent) {
-          if (part && typeof part === "object" && part.type === "tool-call") {
-            const tc = part.toolCall || part;
-            assistantToolCalls.push({ id: tc.id, name: tc.name || tc.function && tc.function.name });
-            toolCallIds.add(tc.id);
-          }
-        }
-      }
-      if (msg.role === "tool") {
-        const toolContent = Array.isArray(msg.content) ? msg.content : [];
-        for (const part of toolContent) {
-          if (part && typeof part === "object" && part.type === "tool-result") {
-            toolResultIds.push(part.toolCallId);
-          }
-        }
-      }
-    }
-    const missingToolResults = assistantToolCalls.filter((tc) => !toolResultIds.includes(tc.id));
-    const orphanedToolResults = toolResultIds.filter((id) => !toolCallIds.has(id));
-    if (assistantToolCalls.length > 0 || toolResultIds.length > 0) {
-      logger.debug("[invoke] ToolCallId matching analysis:", {
-        assistantToolCalls,
-        toolResultIds,
-        missingToolResults: missingToolResults.length > 0 ? missingToolResults : "none",
-        orphanedToolResults: orphanedToolResults.length > 0 ? orphanedToolResults : "none"
-      });
-    }
-    const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
-    const providerOptions = generateProviderOptions(providerId, {
-      temperature: options.temperature,
-      maxTokens: options.maxTokens
-    });
-    const model = `${providerId}/${modelId}`;
-    if (emitToEnv) {
-      logger.info("[invoke] Emitting llm.start event");
-      emitToEnv({ type: "start", metadata: { model } });
-    } else {
-      logger.warn("[invoke] emitToEnv is null, skipping llm.start event");
-    }
-    const streamTextOptions = {
-      model: provider.languageModel(modelId),
-      messages,
-      tools,
-      temperature: providerOptions.temperature,
-      maxTokens: providerOptions.maxTokens,
-      abortSignal: ctx.abort,
-      maxRetries: MAX_RETRIES,
-      streamOptions: {
-        includeUsage: true
-      },
-      allowSystemInMessages: true
-    };
-    const result = await streamText(streamTextOptions);
-    let fullContent = "";
-    let reasoningContent = "";
-    const toolCalls = [];
-    let usageInfo;
-    let isThinkingTagOpen = false;
-    let currentThinkingContent = "";
-    for await (const part of result.fullStream) {
-      const streamPart = part;
-      switch (streamPart.type) {
-        case "text-delta": {
-          const textDelta = getStreamPartText(streamPart);
-          if (!textDelta)
-            break;
-          const thinkingConfig = config.options?.thinkingInText;
-          if (thinkingConfig?.enabled) {
-            const thinkingResult = processThinkingStream(textDelta, thinkingConfig, {
-              isOpen: isThinkingTagOpen,
-              content: currentThinkingContent
-            });
-            isThinkingTagOpen = thinkingResult.isThinkingTagOpen;
-            currentThinkingContent = thinkingResult.currentThinkingContent;
-            fullContent += thinkingResult.cleanedText;
-            for (const reasoningSnapshot of thinkingResult.reasoningEvents) {
-              const delta = reasoningSnapshot.slice(reasoningContent.length);
-              reasoningContent = reasoningSnapshot;
-              if (emitToEnv && delta) {
-                emitToEnv({ type: "reasoning", content: reasoningContent, delta });
-              }
-            }
-            if (emitToEnv && thinkingResult.cleanedText) {
-              emitToEnv({ type: "text", content: fullContent, delta: thinkingResult.cleanedText });
-            }
-          } else {
-            fullContent += textDelta;
-            if (emitToEnv) {
-              emitToEnv({ type: "text", content: fullContent, delta: textDelta });
-            }
-          }
-          break;
-        }
-        case "reasoning-delta": {
-          const reasoningDelta = getStreamPartText(streamPart);
-          if (!reasoningDelta)
-            break;
-          reasoningContent += reasoningDelta;
-          if (emitToEnv) {
-            emitToEnv({ type: "reasoning", content: reasoningContent, delta: reasoningDelta });
-          }
-          break;
-        }
-        case "reasoning-end":
-          break;
-        case "tool-call": {
-          const toolInput = streamPart.input;
-          const toolCallId = streamPart.toolCallId ?? streamPart.id;
-          const toolName = streamPart.toolName;
-          toolCalls.push({
-            id: toolCallId,
-            name: toolName,
-            args: toolInput
-          });
-          break;
-        }
-        case "finish-step":
-          const stepUsage = extractUsageInfo(streamPart.usage);
-          if (stepUsage) {
-            usageInfo = stepUsage;
-          }
-          break;
-        case "error":
-          throw streamPart.error;
-        case "finish":
-          usageInfo = extractUsageInfo(streamPart.totalUsage);
-          if (!usageInfo && streamPart.usage) {
-            usageInfo = extractUsageInfo(streamPart.usage);
-          }
-          break;
-      }
-    }
-    if (emitToEnv) {
-      emitToEnv({
-        type: "completed",
-        content: fullContent,
-        metadata: {
-          model,
-          usage: usageInfo
-        }
-      });
-    }
-    if (toolCalls.length > 0) {
-      const firstToolCall = toolCalls[0];
-      return {
-        toolCallId: firstToolCall.id,
-        result: JSON.stringify({
-          content: fullContent,
-          reasoning: reasoningContent || undefined,
-          tool_calls: toolCalls.map((tc) => ({
-            id: tc.id,
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }))
-        })
-      };
-    }
-    return {
-      toolCallId: "invoke-" + Date.now(),
-      result: JSON.stringify({
-        content: fullContent,
-        reasoning: reasoningContent || undefined,
-        usage: usageInfo,
-        model
-      })
-    };
-  } catch (error) {
-    logger.error("Error during invocation", {
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : undefined
-    });
-    return {
-      toolCallId: "error-" + Date.now(),
-      result: error instanceof Error ? error.message : String(error),
-      isError: true
-    };
-  }
-}
-function createProviderInstance(providerId, apiKey, baseURL) {
-  try {
-    if (providerId === "openai") {
-      const openai = createOpenAI({
-        apiKey,
-        baseURL
-      });
-      return openai;
-    }
-    if (providerId === "anthropic") {
-      const anthropic = createAnthropic({
-        apiKey
-      });
-      return anthropic;
-    }
-    if (providerId === "google") {
-      const google = createGoogleGenerativeAI({
-        apiKey
-      });
-      return google;
-    }
-    const defaultProvider = createOpenAICompatible({
-      name: providerId,
-      apiKey,
-      baseURL: baseURL || "",
-      includeUsage: true
-    });
-    return defaultProvider;
-  } catch (error) {
-    logger.error(`Failed to create provider ${providerId}`, { error: String(error) });
-    return null;
-  }
-}
-async function invokeNonStream(config, options, ctx) {
-  const { providerId, modelId } = parseModelString(options.model || config.model);
-  const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
-  if (!provider) {
-    throw new Error(`Failed to create provider for ${providerId}`);
-  }
-  const messages = convertToSDKMessages(options.messages);
-  const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
-  const providerOptions = generateProviderOptions(providerId, {
-    temperature: options.temperature,
-    maxTokens: options.maxTokens
-  });
-  const { generateText } = await import("ai");
-  const genTextFn = generateText;
-  const result = await genTextFn({
-    model: provider.languageModel(modelId),
-    messages,
-    tools,
-    temperature: providerOptions.temperature,
-    maxTokens: providerOptions.maxTokens,
-    abortSignal: ctx.abort,
-    allowSystemInMessages: true
-  });
-  const usage = result.usage;
-  const usageInfo = usage ? {
-    promptTokens: usage.promptTokens ?? 0,
-    completionTokens: usage.completionTokens ?? 0,
-    totalTokens: usage.totalTokens ?? 0
-  } : undefined;
-  if (options.env) {
-    options.env.pushEnvEvent({
-      id: randomUUID(),
-      type: "llm.completed",
-      timestamp: Date.now(),
-      metadata: {
-        source: "llm.invokeNonStream",
-        sessionId: options.context?.sessionId,
-        messageId: options.context?.messageId
-      },
-      payload: {
-        type: "completed",
-        content: result.text,
-        metadata: {
-          model: `${providerId}/${modelId}`,
-          usage: usageInfo
-        }
-      }
-    });
-  }
-  return {
-    content: result.text,
-    finishReason: result.finishReason === "stop" ? "stop" : "tool-calls",
-    model: `${providerId}/${modelId}`,
-    usage: usageInfo
-  };
-}
-function createInvokeConfig(model, apiKey, baseURL) {
-  return {
-    model,
-    apiKey,
-    baseURL
-  };
-}
 // src/env/llm/hooks.ts
 init_global_hook_manager();
 
@@ -1020,7 +447,7 @@ class LLMHooks {
 // src/env/llm/llm.ts
 init_logger();
 init_decorator();
-var logger2 = createLogger("llm");
+var logger = createLogger("llm");
 
 class LLMComponent extends BaseComponent {
   name = "llm";
@@ -1136,24 +563,24 @@ class LLMComponent extends BaseComponent {
   }
   registerConfigWatcher(configComponent) {
     if (typeof configComponent.watch !== "function") {
-      logger2.debug("ConfigComponent does not support watch, hot reload disabled");
+      logger.debug("ConfigComponent does not support watch, hot reload disabled");
       return;
     }
     this.configWatcher = configComponent.watch("llm.*", (event) => {
       this.onConfigChange(event);
     });
-    logger2.debug("Config hot reload watcher registered for llm.*");
+    logger.debug("Config hot reload watcher registered for llm.*");
   }
   onConfigChange(event) {
-    logger2.info(`LLM config changed: ${event.key}`);
+    logger.info(`LLM config changed: ${event.key}`);
     if (event.key === "llm.providers" || event.key.startsWith("llm.providers.")) {
-      logger2.info(`LLM provider config changed, will use new config on next call`);
+      logger.info(`LLM provider config changed, will use new config on next call`);
     } else if (event.key === "llm.defaultModel") {
-      logger2.info(`LLM default model changed to: ${event.newValue}`);
+      logger.info(`LLM default model changed to: ${event.newValue}`);
     } else if (event.key === "llm.defaultProvider") {
-      logger2.info(`LLM default provider changed to: ${event.newValue}`);
+      logger.info(`LLM default provider changed to: ${event.newValue}`);
     } else {
-      logger2.debug(`LLM config updated: ${event.key}`);
+      logger.debug(`LLM config updated: ${event.key}`);
     }
   }
   async onStart() {
@@ -1338,4 +765,4 @@ class LLMComponent extends BaseComponent {
 __legacyDecorateClassTS([
   TracedAs("llm.component.invoke", { recordParams: true, recordResult: true, log: true })
 ], LLMComponent.prototype, "invoke", null);
-export { ProviderCapabilitiesSchema, ModelLimitsSchema, ProviderConfigSchema, LLMDefaultConfigSchema, LLMConfigSchema, ProviderManager, LLMTransform, parseModelString, invoke, invokeNonStream, createInvokeConfig, LLMHooks, LLMComponent };
+export { ProviderCapabilitiesSchema, ModelLimitsSchema, ProviderConfigSchema, LLMDefaultConfigSchema, LLMConfigSchema, ProviderManager, LLMTransform, LLMHooks, LLMComponent };

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

@@ -2434,16 +2434,23 @@ var init_engine = __esm(() => {
       if (!sessionState) {
         throw new Error(`Session not found: ${sessionId}`);
       }
-      const timeoutMs = timeout ?? 300000;
+      const timeoutMs = timeout ?? 1200000;
+      let timer;
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
+        timer = setTimeout(() => {
           reject(new Error(`Workflow execution timeout: ${timeoutMs}ms`));
         }, timeoutMs);
       });
-      return Promise.race([
-        sessionState.completedPromise,
-        timeoutPromise
-      ]);
+      try {
+        return await Promise.race([
+          sessionState.completedPromise,
+          timeoutPromise
+        ]);
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
     }
     async getSessionMetadata(sessionId) {
       if (!this.sessionComponent) {

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

@@ -206,12 +206,12 @@ var DelegateToolParameters = z.object({
   prompt: z.string().describe("The task for the agent to perform"),
   subagent_type: z.string().describe("The type of specialized agent to use for this task").default("general"),
   background: z.boolean().describe("Whether to run the task in background. If true, returns immediately and notifies when complete (default: false)").default(false),
-  timeout: z.number().describe("Task timeout in milliseconds. Default: 1200000 (20 minutes). If set, task will be terminated after timeout.").optional(),
+  timeout: z.number().describe("Task timeout in milliseconds. Default: 1800000 (30 minutes). If set, task will be terminated after timeout.").optional(),
   cleanup: z.enum(["delete", "keep"]).describe("Whether to delete sub session after completion. 'delete' removes the session, 'keep' retains it (default: keep)").default("keep").optional(),
   task_id: z.number().describe("Optional task ID to associate with this delegate task, for tracking in operation records").optional(),
   reason: z.string().describe("Brief reason for calling this tool (max 30 chars, e.g., 'Delegate refactor task')").optional()
 });
-var DEFAULT_TIMEOUT = 1200000;
+var DEFAULT_TIMEOUT = 1800000;
 var PROGRESS_INTERVAL = 120000;
 
 class BackgroundTaskManager {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.52",
+  "version": "1.5.53",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",