@voltagent/core 0.1.65 → 0.1.67

package/dist/index.d.ts

@@ -130,7 +130,7 @@ declare class ToolManager {
     /**
      * Prepare tools for text generation (includes tools from toolkits).
      */
-    prepareToolsForGeneration(dynamicTools?: BaseTool[]): BaseTool[];
+    prepareToolsForGeneration(dynamicTools?: (BaseTool | Toolkit)[]): BaseTool[];
     /**
      * Get agent's tools (including those in toolkits) for API exposure.
      */
@@ -4600,6 +4600,10 @@ declare class Agent<TProvider extends {
      * Add step to history immediately and to conversation steps
      */
     private addStepToHistory;
+    /**
+     * Handle tool execution errors by creating appropriate events and steps
+     */
+    private handleToolError;
     /**
      * Update history entry
      */

package/dist/index.js

@@ -5060,22 +5060,27 @@ var LibSQLStorage = class {
       if (conditions.length > 0) {
         sql += ` WHERE ${conditions.join(" AND ")}`;
       }
-      sql += " ORDER BY m.created_at ASC";
       if (limit && limit > 0) {
-        sql += " LIMIT ?";
+        sql += " ORDER BY m.created_at DESC LIMIT ?";
         args.push(limit);
+      } else {
+        sql += " ORDER BY m.created_at ASC";
       }
       const result = await this.client.execute({
         sql,
         args
       });
-      return result.rows.map((row) => ({
+      const messages = result.rows.map((row) => ({
         id: row.message_id,
         role: row.role,
         content: row.content,
         type: row.type,
         createdAt: row.created_at
       }));
+      if (limit && limit > 0) {
+        return messages.reverse();
+      }
+      return messages;
     } catch (error) {
       this.debug("Error getting messages:", error);
       throw new Error("Failed to get messages from LibSQL database");
@@ -7978,7 +7983,7 @@ var InMemoryStorage = class {
       );
     }
     filteredMessages.sort((a, b) => {
-      return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
     });
     if (limit && limit > 0 && filteredMessages.length > limit) {
       filteredMessages = filteredMessages.slice(-limit);
@@ -9459,16 +9464,10 @@ var ToolManager = class {
   prepareToolsForGeneration(dynamicTools) {
     let toolsToUse = this.getTools();
     if (dynamicTools?.length) {
-      const validDynamicTools = dynamicTools.filter(
-        (dt) => dt?.name && dt?.parameters && typeof dt?.execute === "function"
-        // Apply optional chaining
-      );
-      if (validDynamicTools.length !== dynamicTools.length) {
-        this.logger.warn(
-          "[ToolManager] Some dynamic tools provided to prepareToolsForGeneration were invalid and ignored."
-        );
-      }
-      toolsToUse = [...toolsToUse, ...validDynamicTools];
+      const tempManager = new ToolManager([], this.logger);
+      tempManager.addItems(dynamicTools);
+      const dynamicToolsList = tempManager.getTools();
+      toolsToUse = [...toolsToUse, ...dynamicToolsList];
     }
     return toolsToUse;
   }
@@ -12160,6 +12159,25 @@ ${retrieverContext}`;
     const baseTools = this.toolManager.prepareToolsForGeneration(
       allTools.length > 0 ? allTools : void 0
     );
+    if (this.dynamicTools && resolvedTools.length > 0) {
+      const allToolsForUpdate = baseTools.map((tool2) => ({
+        name: tool2.name,
+        description: tool2.description,
+        parameters: tool2.parameters ? zodSchemaToJsonUI(tool2.parameters) : void 0
+      }));
+      if (historyEntryId && this.historyManager) {
+        const updatedAgentSnapshot = this.getFullState();
+        this.historyManager.updateEntry(historyEntryId, {
+          metadata: {
+            agentSnapshot: {
+              ...updatedAgentSnapshot,
+              tools: allToolsForUpdate
+              // Include resolved tools in the snapshot
+            }
+          }
+        });
+      }
+    }
     if (!operationContext) {
       this.logger.warn(
         "Missing operationContext in prepareTextOptions. Tool execution context might be incomplete.",
@@ -12415,6 +12433,107 @@ ${retrieverContext}`;
     };
     context.conversationSteps.push(finalStep);
   }
+  /**
+   * Handle tool execution errors by creating appropriate events and steps
+   */
+  async handleToolError(error, operationContext, options) {
+    if (!error.toolError) {
+      return;
+    }
+    const { userId, conversationId, internalOptions } = options;
+    const { toolCallId, toolName } = error.toolError;
+    try {
+      const toolStartInfo = operationContext.userContext.get(`tool_${toolCallId}`) || { eventId: void 0, startTime: (/* @__PURE__ */ new Date()).toISOString() };
+      const toolErrorEvent = {
+        id: crypto.randomUUID(),
+        name: "tool:error",
+        type: "tool",
+        startTime: toolStartInfo.startTime,
+        endTime: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "error",
+        level: "ERROR",
+        input: null,
+        output: null,
+        statusMessage: {
+          message: error.message,
+          code: error.code,
+          ...error.toolError && { toolError: error.toolError }
+        },
+        metadata: {
+          displayName: toolName,
+          id: toolName,
+          agentId: this.id
+        },
+        traceId: operationContext.historyEntry.id,
+        parentEventId: toolStartInfo.eventId
+      };
+      this.publishTimelineEvent(operationContext, toolErrorEvent);
+      const toolErrorStep = {
+        id: toolCallId,
+        type: "tool_result",
+        name: toolName,
+        result: {
+          error
+        },
+        content: JSON.stringify([
+          {
+            type: "tool-result",
+            toolCallId,
+            toolName,
+            result: {
+              error: {
+                message: error.message,
+                code: error.code
+              }
+            }
+          }
+        ]),
+        role: "assistant"
+      };
+      this.addStepToHistory(toolErrorStep, operationContext);
+      if (userId) {
+        const onStepFinish = this.memoryManager.createStepFinishHandler(
+          operationContext,
+          userId,
+          conversationId
+        );
+        await onStepFinish(toolErrorStep);
+      }
+      const tool2 = this.toolManager.getToolByName(toolName);
+      if (tool2 && internalOptions) {
+        await this.getMergedHooks(internalOptions).onToolEnd?.({
+          agent: this,
+          tool: tool2,
+          output: void 0,
+          error,
+          context: operationContext
+        });
+      }
+      const methodLogger = operationContext.logger || this.logger;
+      methodLogger.error(
+        buildAgentLogMessage(this.name, "toolCall" /* TOOL_CALL */, `Tool ${toolName} failed`),
+        {
+          event: LogEvents.TOOL_EXECUTION_FAILED,
+          toolName,
+          toolCallId,
+          error: {
+            message: error.message,
+            code: error.code
+          }
+        }
+      );
+    } catch (updateError) {
+      const methodLogger = operationContext.logger || this.logger;
+      methodLogger.error(
+        `Failed to update tool event to error status for ${toolName} (${toolCallId})`,
+        {
+          toolName,
+          toolCallId,
+          error: updateError
+        }
+      );
+    }
+  }
   /**
    * Update history entry
    */
@@ -13022,6 +13141,13 @@ ${retrieverContext}`;
       return extendedResponse;
     } catch (error) {
       const voltagentError = error;
+      if (voltagentError.toolError) {
+        await this.handleToolError(voltagentError, operationContext, {
+          userId,
+          conversationId: finalConversationId,
+          internalOptions
+        });
+      }
       const agentErrorStartInfo = {
         startTime: operationContext.userContext.get("agent_start_time") || (/* @__PURE__ */ new Date()).toISOString(),
         eventId: operationContext.userContext.get("agent_start_event_id")
@@ -13527,53 +13653,11 @@ ${retrieverContext}`;
       },
       onError: async (error) => {
         if (error.toolError) {
-          const { toolCallId, toolName } = error.toolError;
-          try {
-            const toolStartInfo = operationContext.userContext.get(`tool_${toolCallId}`) || { eventId: void 0, startTime: (/* @__PURE__ */ new Date()).toISOString() };
-            const toolErrorEvent = {
-              id: crypto.randomUUID(),
-              name: "tool:error",
-              type: "tool",
-              startTime: toolStartInfo.startTime,
-              endTime: (/* @__PURE__ */ new Date()).toISOString(),
-              status: "error",
-              level: "ERROR",
-              input: null,
-              output: null,
-              statusMessage: {
-                message: error.message,
-                code: error.code,
-                ...error.toolError && { toolError: error.toolError }
-              },
-              metadata: {
-                displayName: toolName,
-                id: toolName,
-                agentId: this.id
-              },
-              traceId: operationContext.historyEntry.id,
-              parentEventId: toolStartInfo.eventId
-            };
-            this.publishTimelineEvent(operationContext, toolErrorEvent);
-          } catch (updateError) {
-            methodLogger.error(
-              `Failed to update tool event to error status for ${toolName} (${toolCallId})`,
-              {
-                toolName,
-                toolCallId,
-                error: updateError
-              }
-            );
-          }
-          const tool2 = this.toolManager.getToolByName(toolName);
-          if (tool2) {
-            await this.getMergedHooks(internalOptions).onToolEnd?.({
-              agent: this,
-              tool: tool2,
-              output: void 0,
-              error,
-              context: operationContext
-            });
-          }
+          await this.handleToolError(error, operationContext, {
+            userId,
+            conversationId: finalConversationId,
+            internalOptions
+          });
         }
         const agentErrorStartInfo = {
           startTime: operationContext.userContext.get("agent_start_time") || (/* @__PURE__ */ new Date()).toISOString(),
@@ -14183,19 +14267,6 @@ ${retrieverContext}`;
         }
       },
       onError: async (error) => {
-        if (error.toolError) {
-          const { toolName } = error.toolError;
-          const tool2 = this.toolManager.getToolByName(toolName);
-          if (tool2) {
-            await this.getMergedHooks(internalOptions).onToolEnd?.({
-              agent: this,
-              tool: tool2,
-              output: void 0,
-              error,
-              context: operationContext
-            });
-          }
-        }
         const agentErrorStartInfo = {
           startTime: operationContext.userContext.get("agent_start_time") || (/* @__PURE__ */ new Date()).toISOString(),
           eventId: operationContext.userContext.get("agent_start_event_id")