@voltagent/core 0.1.69 → 0.1.70

package/dist/index.d.ts

@@ -4659,10 +4659,6 @@ 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
      */
@@ -4825,6 +4821,10 @@ type WorkflowStepFuncConfig<INPUT, DATA, RESULT, SUSPEND_DATA, RESUME_DATA = any
 interface WorkflowStepFunc<INPUT, DATA, RESULT, SUSPEND_DATA, RESUME_DATA = any> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT, SUSPEND_DATA, RESUME_DATA> {
     type: "func";
 }
+interface WorkflowStepWorkflow<INPUT, DATA, RESULT, SUSPEND_DATA, RESUME_DATA = any> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT, SUSPEND_DATA, RESUME_DATA> {
+    type: "workflow";
+    workflow: InternalWorkflow<INPUT, DATA, RESULT>;
+}
 type WorkflowStepTapConfig<INPUT, DATA, _RESULT, SUSPEND_DATA, RESUME_DATA = any> = InternalWorkflowStepConfig<{
     execute: InternalWorkflowFunc<INPUT, DATA, DangerouslyAllowAny, SUSPEND_DATA, RESUME_DATA>;
     inputSchema?: z.ZodTypeAny;
@@ -4860,7 +4860,21 @@ interface WorkflowStepParallelAll<INPUT, DATA, RESULT> extends InternalBaseWorkf
     type: "parallel-all";
     steps: ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>;
 }
-type WorkflowStep<INPUT, DATA, RESULT, SUSPEND_DATA = any> = WorkflowStepAgent<INPUT, DATA, RESULT> | WorkflowStepFunc<INPUT, DATA, RESULT, SUSPEND_DATA> | WorkflowStepConditionalWhen<INPUT, DATA, RESULT> | WorkflowStepParallelAll<INPUT, DATA, RESULT> | WorkflowStepTap<INPUT, DATA, RESULT, SUSPEND_DATA> | WorkflowStepParallelRace<INPUT, DATA, RESULT>;
+type WorkflowStep<INPUT, DATA, RESULT, SUSPEND_DATA = any> = WorkflowStepAgent<INPUT, DATA, RESULT> | WorkflowStepFunc<INPUT, DATA, RESULT, SUSPEND_DATA> | WorkflowStepConditionalWhen<INPUT, DATA, RESULT> | WorkflowStepParallelAll<INPUT, DATA, RESULT> | WorkflowStepTap<INPUT, DATA, RESULT, SUSPEND_DATA> | WorkflowStepParallelRace<INPUT, DATA, RESULT> | WorkflowStepWorkflow<INPUT, DATA, RESULT, SUSPEND_DATA>;
+/**
+ * Internal type to allow overriding the run method for the workflow
+ */
+interface InternalWorkflow<_INPUT, DATA, RESULT> extends Omit<Workflow<DangerouslyAllowAny, DangerouslyAllowAny>, "run"> {
+    run: (input: InternalExtractWorkflowInputData<DATA>, options?: InternalWorkflowRunOptions) => Promise<{
+        executionId: string;
+        startAt: Date;
+        endAt: Date;
+        status: "completed";
+        result: RESULT;
+    }>;
+}
+interface InternalWorkflowRunOptions extends WorkflowRunOptions {
+}
 
 /**
  * Creates an async function step for the workflow
@@ -5367,6 +5381,22 @@ declare class WorkflowChain<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema
         suspendSchema?: z.ZodTypeAny;
         resumeSchema?: z.ZodTypeAny;
     }): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, CURRENT_DATA, SUSPEND_SCHEMA, RESUME_SCHEMA>;
+    /**
+     * Add a workflow step to the workflow
+     *
+     * @example
+     * ```ts
+     * import { myWorkflow } from "./my-workflow";
+     *
+     * const workflow = createWorkflowChain(config)
+     *   .andThen(async (data) => {
+     *     const userInfo = await fetchUserInfo(data.userId);
+     *     return { userInfo };
+     *   })
+     *   .andWorkflow(myWorkflow)
+     * ```
+     */
+    andWorkflow<NEW_DATA>(workflow: InternalWorkflow<INPUT_SCHEMA, CURRENT_DATA, NEW_DATA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, NEW_DATA>;
     /**
      * Add a parallel execution step that runs multiple steps simultaneously and waits for all to complete
      *

package/dist/index.js

@@ -3366,6 +3366,28 @@ function andTap({
 }
 __name(andTap, "andTap");
 
+// src/workflow/steps/and-workflow.ts
+function andWorkflow(workflow) {
+  return {
+    type: "workflow",
+    workflow,
+    id: workflow.id,
+    name: workflow.name,
+    purpose: workflow.purpose,
+    execute: async (context) => {
+      const { result } = await workflow.run(context.data, {
+        active: context.state.active,
+        executionId: context.state.executionId,
+        conversationId: context.state.conversationId,
+        userId: context.state.userId,
+        userContext: context.state.userContext
+      });
+      return result;
+    }
+  };
+}
+__name(andWorkflow, "andWorkflow");
+
 // src/workflow/core.ts
 var import_zod = require("zod");
 
@@ -7643,6 +7665,27 @@ var WorkflowChain = class {
     this.steps.push(finalStep);
     return this;
   }
+  /**
+   * Add a workflow step to the workflow
+   *
+   * @example
+   * ```ts
+   * import { myWorkflow } from "./my-workflow";
+   *
+   * const workflow = createWorkflowChain(config)
+   *   .andThen(async (data) => {
+   *     const userInfo = await fetchUserInfo(data.userId);
+   *     return { userInfo };
+   *   })
+   *   .andWorkflow(myWorkflow)
+   * ```
+   */
+  andWorkflow(workflow) {
+    this.steps.push(
+      andWorkflow(workflow)
+    );
+    return this;
+  }
   /**
    * Add a parallel execution step that runs multiple steps simultaneously and waits for all to complete
    *
@@ -12248,10 +12291,15 @@ ${retrieverContext}`;
                 toolName: tool2.name,
                 agentId: this.id,
                 modelName: this.getModelName(),
-                error: error instanceof Error ? error.message : error
+                error
               }
             );
-            throw error;
+            const result = {
+              error: true,
+              message: error instanceof Error ? error.message : String(error),
+              stack: error instanceof Error ? error.stack : void 0
+            };
+            return result;
           }
         }
       };
@@ -12452,107 +12500,6 @@ ${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
    */
@@ -12845,7 +12792,8 @@ ${retrieverContext}`;
         ...internalOptions,
         conversationId: finalConversationId,
         historyEntryId: operationContext.historyEntry.id,
-        operationContext
+        operationContext,
+        logger: methodLogger
       });
       const promptHelper = VoltOpsClient.createPromptHelperWithFallback(
         this.id,
@@ -13011,8 +12959,12 @@ ${retrieverContext}`;
                   level: "ERROR",
                   input: null,
                   output: null,
-                  statusMessage: step.result?.error || {
-                    message: "Unknown tool error"
+                  statusMessage: {
+                    message: step.result?.message || "Unknown tool error",
+                    // Include stack trace if available (from tool wrapper)
+                    ...step.result?.stack && {
+                      stack: step.result.stack
+                    }
                   },
                   metadata: {
                     displayName: toolName,
@@ -13160,13 +13112,6 @@ ${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")
@@ -13372,7 +13317,8 @@ ${retrieverContext}`;
       historyEntryId: operationContext.historyEntry.id,
       operationContext,
       // Pass the internal forwarder to tools
-      internalStreamForwarder: internalStreamEventForwarder
+      internalStreamForwarder: internalStreamEventForwarder,
+      logger: methodLogger
     });
     const promptHelper = VoltOpsClient.createPromptHelperWithFallback(
       this.id,
@@ -13468,7 +13414,13 @@ ${retrieverContext}`;
                 level: "ERROR",
                 input: null,
                 output: null,
-                statusMessage: chunk.result?.error || { message: "Unknown tool error" },
+                statusMessage: {
+                  message: chunk.result?.message || "Unknown tool error",
+                  // Include stack trace if available (from tool wrapper)
+                  ...chunk.result?.stack && {
+                    stack: chunk.result.stack
+                  }
+                },
                 metadata: {
                   displayName: toolName,
                   id: toolName,
@@ -13671,13 +13623,6 @@ ${retrieverContext}`;
         }
       },
       onError: async (error) => {
-        if (error.toolError) {
-          await this.handleToolError(error, 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")