@upstash/workflow 0.2.11 → 0.2.13

package/{chunk-WQAJ2RSZ.mjs → chunk-XVNSBBDC.mjs}

@@ -42,11 +42,12 @@ var WORKFLOW_PROTOCOL_VERSION_HEADER = "Upstash-Workflow-Sdk-Version";
 var DEFAULT_CONTENT_TYPE = "application/json";
 var NO_CONCURRENCY = 1;
 var DEFAULT_RETRIES = 3;
-var VERSION = "v0.2.7";
+var VERSION = "v0.2.13";
 var SDK_TELEMETRY = `@upstash/workflow@${VERSION}`;
 var TELEMETRY_HEADER_SDK = "Upstash-Telemetry-Sdk";
 var TELEMETRY_HEADER_FRAMEWORK = "Upstash-Telemetry-Framework";
 var TELEMETRY_HEADER_RUNTIME = "Upstash-Telemetry-Runtime";
+var TELEMETRY_HEADER_AGENT = "Upstash-Telemetry-Agent";
 
 // src/error.ts
 import { QstashError } from "@upstash/qstash";
@@ -85,7 +86,7 @@ var formatWorkflowError = (error) => {
     message: error.message
   } : {
     error: "Error",
-    message: "An error occured while executing workflow."
+    message: `An error occured while executing workflow: '${typeof error === "string" ? error : JSON.stringify(error)}'`
   };
 };
 
@@ -101,6 +102,271 @@ var StepTypes = [
   "Invoke"
 ];
 
+// src/agents/adapters.ts
+import { tool } from "ai";
+
+// src/agents/constants.ts
+var AGENT_NAME_HEADER = "upstash-agent-name";
+var MANAGER_AGENT_PROMPT = `You are an agent orchestrating other AI Agents.
+
+These other agents have tools available to them.
+
+Given a prompt, utilize these agents to address requests.
+
+Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another.
+
+Avoid calling the same agent twice in one turn. Instead, prefer to call it once but provide everything
+you need from that agent.
+`;
+
+// src/agents/adapters.ts
+var fetchWithContextCall = async (context, agentCallParams, ...params) => {
+  const [input, init] = params;
+  try {
+    const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
+    const body = init?.body ? JSON.parse(init.body) : void 0;
+    const agentName = headers[AGENT_NAME_HEADER];
+    const stepName = agentName ? `Call Agent ${agentName}` : "Call Agent";
+    const responseInfo = await context.call(stepName, {
+      url: input.toString(),
+      method: init?.method,
+      headers,
+      body,
+      timeout: agentCallParams?.timeout,
+      retries: agentCallParams?.retries,
+      flowControl: agentCallParams?.flowControl
+    });
+    const responseHeaders = new Headers(
+      Object.entries(responseInfo.header).reduce(
+        (acc, [key, values]) => {
+          acc[key] = values.join(", ");
+          return acc;
+        },
+        {}
+      )
+    );
+    return new Response(JSON.stringify(responseInfo.body), {
+      status: responseInfo.status,
+      headers: responseHeaders
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "WorkflowAbort") {
+      throw error;
+    } else {
+      console.error("Error in fetch implementation:", error);
+      throw error;
+    }
+  }
+};
+var createWorkflowModel = ({
+  context,
+  provider,
+  providerParams,
+  agentCallParams
+}) => {
+  return provider({
+    fetch: (...params) => fetchWithContextCall(context, agentCallParams, ...params),
+    ...providerParams
+  });
+};
+var wrapTools = ({
+  context,
+  tools
+}) => {
+  return Object.fromEntries(
+    Object.entries(tools).map((toolInfo) => {
+      const [toolName, tool3] = toolInfo;
+      const executeAsStep = "executeAsStep" in tool3 ? tool3.executeAsStep : true;
+      const aiSDKTool = convertToAISDKTool(tool3);
+      const execute = aiSDKTool.execute;
+      if (execute && executeAsStep) {
+        const wrappedExecute = (...params) => {
+          return context.run(`Run tool ${toolName}`, () => execute(...params));
+        };
+        aiSDKTool.execute = wrappedExecute;
+      }
+      return [toolName, aiSDKTool];
+    })
+  );
+};
+var convertToAISDKTool = (tool3) => {
+  const isLangchainTool = "invoke" in tool3;
+  return isLangchainTool ? convertLangchainTool(tool3) : tool3;
+};
+var convertLangchainTool = (langchainTool) => {
+  return tool({
+    description: langchainTool.description,
+    parameters: langchainTool.schema,
+    execute: async (...param) => langchainTool.invoke(...param)
+  });
+};
+var WorkflowTool = class {
+  /**
+   * description of the tool
+   */
+  description;
+  /**
+   * schema of the tool
+   */
+  schema;
+  /**
+   * function to invoke the tool
+   */
+  invoke;
+  /**
+   * whether the invoke method of the tool is to be wrapped with `context.run`
+   */
+  executeAsStep;
+  /**
+   *
+   * @param description description of the tool
+   * @param schema schema of the tool
+   * @param invoke function to invoke the tool
+   * @param executeAsStep whether the invoke method of the tool is to be wrapped with `context.run`
+   */
+  constructor(params) {
+    this.description = params.description;
+    this.schema = params.schema;
+    this.invoke = params.invoke;
+    this.executeAsStep = params.executeAsStep ?? true;
+  }
+};
+
+// src/serve/serve-many.ts
+var getWorkflowId = (url) => {
+  const components = url.split("/");
+  const lastComponent = components[components.length - 1];
+  return lastComponent.split("?")[0];
+};
+var serveManyBase = ({
+  workflows,
+  getUrl,
+  serveMethod,
+  options
+}) => {
+  const workflowIds = [];
+  const workflowMap = Object.fromEntries(
+    Object.entries(workflows).map((workflow) => {
+      const workflowId = workflow[0];
+      if (workflowIds.includes(workflowId)) {
+        throw new WorkflowError(
+          `Duplicate workflow name found: '${workflowId}'. Please set different workflow names in serveMany.`
+        );
+      }
+      if (workflowId.includes("/")) {
+        throw new WorkflowError(
+          `Invalid workflow name found: '${workflowId}'. Workflow name cannot contain '/'.`
+        );
+      }
+      workflowIds.push(workflowId);
+      workflow[1].workflowId = workflowId;
+      workflow[1].options = {
+        ...options,
+        ...workflow[1].options
+      };
+      const params = [workflow[1].routeFunction, workflow[1].options];
+      const handler = serveMethod(...params);
+      return [workflowId, handler];
+    })
+  );
+  return {
+    handler: async (...params) => {
+      const url = getUrl(...params);
+      const pickedWorkflowId = getWorkflowId(url);
+      if (!pickedWorkflowId) {
+        return new Response(
+          `Unexpected request in serveMany. workflowId not set. Please update the URL of your request.`,
+          {
+            status: 404
+          }
+        );
+      }
+      const workflow = workflowMap[pickedWorkflowId];
+      if (!workflow) {
+        return new Response(
+          `No workflows in serveMany found for '${pickedWorkflowId}'. Please update the URL of your request.`,
+          {
+            status: 404
+          }
+        );
+      }
+      return await workflow(...params);
+    }
+  };
+};
+var getNewUrlFromWorkflowId = (url, workflowId) => {
+  if (!workflowId) {
+    throw new WorkflowError("You can only call workflow which has a workflowId");
+  }
+  return url.replace(/[^/]+$/, workflowId);
+};
+
+// src/context/auto-executor.ts
+import { QstashError as QstashError5 } from "@upstash/qstash";
+
+// src/qstash/headers.ts
+import { QstashError as QstashError4 } from "@upstash/qstash";
+
+// src/client/utils.ts
+import { QstashError as QstashError2 } from "@upstash/qstash";
+var makeNotifyRequest = async (requester, eventId, eventData) => {
+  const result = await requester.request({
+    path: ["v2", "notify", eventId],
+    method: "POST",
+    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
+  });
+  return result;
+};
+var makeGetWaitersRequest = async (requester, eventId) => {
+  const result = await requester.request({
+    path: ["v2", "waiters", eventId],
+    method: "GET"
+  });
+  return result;
+};
+var makeCancelRequest = async (requester, workflowRunId) => {
+  await requester.request({
+    path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  return true;
+};
+var getSteps = async (requester, workflowRunId, messageId, debug) => {
+  try {
+    const steps = await requester.request({
+      path: ["v2", "workflows", "runs", workflowRunId],
+      parseResponseAsJson: true
+    });
+    if (!messageId) {
+      await debug?.log("INFO", "ENDPOINT_START", {
+        message: `Pulled ${steps.length} steps from QStashand returned them without filtering with messageId.`
+      });
+      return { steps, workflowRunEnded: false };
+    } else {
+      const index = steps.findIndex((item) => item.messageId === messageId);
+      if (index === -1) {
+        return { steps: [], workflowRunEnded: false };
+      }
+      const filteredSteps = steps.slice(0, index + 1);
+      await debug?.log("INFO", "ENDPOINT_START", {
+        message: `Pulled ${steps.length} steps from QStash and filtered them to ${filteredSteps.length} using messageId.`
+      });
+      return { steps: filteredSteps, workflowRunEnded: false };
+    }
+  } catch (error) {
+    if (error instanceof QstashError2 && error.status === 404) {
+      await debug?.log("WARN", "ENDPOINT_START", {
+        message: "Couldn't fetch workflow run steps. This can happen if the workflow run succesfully ends before some callback is executed.",
+        error
+      });
+      return { steps: void 0, workflowRunEnded: true };
+    } else {
+      throw error;
+    }
+  }
+};
+
 // src/utils.ts
 var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
 var NANOID_LENGTH = 21;
@@ -543,85 +809,27 @@ var fromThrowable = Result.fromThrowable;
 
 // src/workflow-requests.ts
 import { QstashError as QstashError3 } from "@upstash/qstash";
-
-// src/client/utils.ts
-import { QstashError as QstashError2 } from "@upstash/qstash";
-var makeNotifyRequest = async (requester, eventId, eventData) => {
-  const result = await requester.request({
-    path: ["v2", "notify", eventId],
-    method: "POST",
-    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
-  });
-  return result;
-};
-var makeGetWaitersRequest = async (requester, eventId) => {
-  const result = await requester.request({
-    path: ["v2", "waiters", eventId],
-    method: "GET"
-  });
-  return result;
-};
-var makeCancelRequest = async (requester, workflowRunId) => {
-  await requester.request({
-    path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
-    method: "DELETE",
-    parseResponseAsJson: false
-  });
-  return true;
-};
-var getSteps = async (requester, workflowRunId, messageId, debug) => {
-  try {
-    const steps = await requester.request({
-      path: ["v2", "workflows", "runs", workflowRunId],
-      parseResponseAsJson: true
-    });
-    if (!messageId) {
-      await debug?.log("INFO", "ENDPOINT_START", {
-        message: `Pulled ${steps.length} steps from QStashand returned them without filtering with messageId.`
-      });
-      return { steps, workflowRunEnded: false };
-    } else {
-      const index = steps.findIndex((item) => item.messageId === messageId);
-      if (index === -1) {
-        return { steps: [], workflowRunEnded: false };
-      }
-      const filteredSteps = steps.slice(0, index + 1);
-      await debug?.log("INFO", "ENDPOINT_START", {
-        message: `Pulled ${steps.length} steps from QStash and filtered them to ${filteredSteps.length} using messageId.`
-      });
-      return { steps: filteredSteps, workflowRunEnded: false };
-    }
-  } catch (error) {
-    if (error instanceof QstashError2 && error.status === 404) {
-      await debug?.log("WARN", "ENDPOINT_START", {
-        message: "Couldn't fetch workflow run steps. This can happen if the workflow run succesfully ends before some callback is executed.",
-        error
-      });
-      return { steps: void 0, workflowRunEnded: true };
-    } else {
-      throw error;
-    }
-  }
-};
-
-// src/workflow-requests.ts
-var triggerFirstInvocation = async ({
-  workflowContext,
-  useJSONContent,
-  telemetry,
-  debug,
-  invokeCount
-}) => {
-  const { headers } = getHeaders({
-    initHeaderValue: "true",
-    workflowRunId: workflowContext.workflowRunId,
-    workflowUrl: workflowContext.url,
-    userHeaders: workflowContext.headers,
-    failureUrl: workflowContext.failureUrl,
-    retries: workflowContext.retries,
-    telemetry,
-    invokeCount,
-    flowControl: workflowContext.flowControl
+var triggerFirstInvocation = async ({
+  workflowContext,
+  useJSONContent,
+  telemetry,
+  debug,
+  invokeCount,
+  delay
+}) => {
+  const { headers } = getHeaders({
+    initHeaderValue: "true",
+    workflowConfig: {
+      workflowRunId: workflowContext.workflowRunId,
+      workflowUrl: workflowContext.url,
+      failureUrl: workflowContext.failureUrl,
+      retries: workflowContext.retries,
+      telemetry,
+      flowControl: workflowContext.flowControl,
+      useJSONContent: useJSONContent ?? false
+    },
+    invokeCount: invokeCount ?? 0,
+    userHeaders: workflowContext.headers
   });
   if (workflowContext.headers.get("content-type")) {
     headers["content-type"] = workflowContext.headers.get("content-type");
@@ -635,7 +843,8 @@ var triggerFirstInvocation = async ({
       headers,
       method: "POST",
       body,
-      url: workflowContext.url
+      url: workflowContext.url,
+      delay
     });
     if (result.deduplicated) {
       await debug?.log("WARN", "SUBMIT_FIRST_INVOCATION", {
@@ -791,14 +1000,16 @@ ${atob(callbackMessage.body ?? "")}`
       const userHeaders = recreateUserHeaders(request.headers);
       const { headers: requestHeaders } = getHeaders({
         initHeaderValue: "false",
-        workflowRunId,
-        workflowUrl,
+        workflowConfig: {
+          workflowRunId,
+          workflowUrl,
+          failureUrl,
+          retries,
+          telemetry,
+          flowControl
+        },
         userHeaders,
-        failureUrl,
-        retries,
-        telemetry,
-        invokeCount: Number(invokeCount),
-        flowControl
+        invokeCount: Number(invokeCount)
       });
       const callResponse = {
         status: callbackMessage.status,
@@ -844,154 +1055,6 @@ var getTelemetryHeaders = (telemetry) => {
     [TELEMETRY_HEADER_RUNTIME]: telemetry.runtime ?? "unknown"
   };
 };
-var getHeaders = ({
-  initHeaderValue,
-  workflowRunId,
-  workflowUrl,
-  userHeaders,
-  failureUrl,
-  retries,
-  step,
-  callRetries,
-  callTimeout,
-  telemetry,
-  invokeCount,
-  flowControl,
-  callFlowControl
-}) => {
-  const callHeaders = new Headers(step?.callHeaders);
-  const contentType = (callHeaders.get("content-type") ? callHeaders.get("content-type") : userHeaders?.get("Content-Type") ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
-  const baseHeaders = {
-    [WORKFLOW_INIT_HEADER]: initHeaderValue,
-    [WORKFLOW_ID_HEADER]: workflowRunId,
-    [WORKFLOW_URL_HEADER]: workflowUrl,
-    [WORKFLOW_FEATURE_HEADER]: "LazyFetch,InitialBody",
-    [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION,
-    "content-type": contentType,
-    ...telemetry ? getTelemetryHeaders(telemetry) : {}
-  };
-  if (invokeCount !== void 0 && !step?.callUrl) {
-    baseHeaders[`Upstash-Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount.toString();
-  }
-  if (!step?.callUrl) {
-    baseHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
-  }
-  if (callTimeout) {
-    baseHeaders[`Upstash-Timeout`] = callTimeout.toString();
-  }
-  if (failureUrl) {
-    baseHeaders[`Upstash-Failure-Callback-Forward-${WORKFLOW_FAILURE_HEADER}`] = "true";
-    baseHeaders[`Upstash-Failure-Callback-Forward-Upstash-Workflow-Failure-Callback`] = "true";
-    baseHeaders["Upstash-Failure-Callback-Workflow-Runid"] = workflowRunId;
-    baseHeaders["Upstash-Failure-Callback-Workflow-Init"] = "false";
-    baseHeaders["Upstash-Failure-Callback-Workflow-Url"] = workflowUrl;
-    baseHeaders["Upstash-Failure-Callback-Workflow-Calltype"] = "failureCall";
-    if (retries !== void 0) {
-      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
-    }
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      baseHeaders["Upstash-Failure-Callback-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Failure-Callback-Flow-Control-Value"] = flowControlValue;
-    }
-    if (!step?.callUrl) {
-      baseHeaders["Upstash-Failure-Callback"] = failureUrl;
-    }
-  }
-  if (step?.callUrl) {
-    baseHeaders["Upstash-Retries"] = callRetries?.toString() ?? "0";
-    baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete,InitialBody";
-    if (retries !== void 0) {
-      baseHeaders["Upstash-Callback-Retries"] = retries.toString();
-      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
-    }
-    if (callFlowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(callFlowControl);
-      baseHeaders["Upstash-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Flow-Control-Value"] = flowControlValue;
-    }
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      baseHeaders["Upstash-Callback-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Callback-Flow-Control-Value"] = flowControlValue;
-    }
-  } else {
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      baseHeaders["Upstash-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Flow-Control-Value"] = flowControlValue;
-    }
-    if (retries !== void 0) {
-      baseHeaders["Upstash-Retries"] = retries.toString();
-      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
-    }
-  }
-  if (userHeaders) {
-    for (const header of userHeaders.keys()) {
-      if (step?.callHeaders) {
-        baseHeaders[`Upstash-Callback-Forward-${header}`] = userHeaders.get(header);
-      } else {
-        baseHeaders[`Upstash-Forward-${header}`] = userHeaders.get(header);
-      }
-      baseHeaders[`Upstash-Failure-Callback-Forward-${header}`] = userHeaders.get(header);
-    }
-  }
-  if (step?.callHeaders) {
-    const forwardedHeaders = Object.fromEntries(
-      Object.entries(step.callHeaders).map(([header, value]) => [
-        `Upstash-Forward-${header}`,
-        value
-      ])
-    );
-    return {
-      headers: {
-        ...baseHeaders,
-        ...forwardedHeaders,
-        "Upstash-Callback": workflowUrl,
-        "Upstash-Callback-Workflow-RunId": workflowRunId,
-        "Upstash-Callback-Workflow-CallType": "fromCallback",
-        "Upstash-Callback-Workflow-Init": "false",
-        "Upstash-Callback-Workflow-Url": workflowUrl,
-        "Upstash-Callback-Feature-Set": "LazyFetch,InitialBody",
-        "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
-        "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
-        "Upstash-Callback-Forward-Upstash-Workflow-StepName": step.stepName,
-        "Upstash-Callback-Forward-Upstash-Workflow-StepType": step.stepType,
-        "Upstash-Callback-Forward-Upstash-Workflow-Concurrent": step.concurrent.toString(),
-        "Upstash-Callback-Forward-Upstash-Workflow-ContentType": contentType,
-        [`Upstash-Callback-Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`]: (invokeCount ?? 0).toString(),
-        "Upstash-Workflow-CallType": "toCallback"
-      }
-    };
-  }
-  if (step?.waitEventId) {
-    return {
-      headers: {
-        ...baseHeaders,
-        "Upstash-Workflow-CallType": "step"
-      },
-      timeoutHeaders: {
-        // to include user headers:
-        ...Object.fromEntries(
-          Object.entries(baseHeaders).map(([header, value]) => [header, [value]])
-        ),
-        // to include telemetry headers:
-        ...telemetry ? Object.fromEntries(
-          Object.entries(getTelemetryHeaders(telemetry)).map(([header, value]) => [
-            header,
-            [value]
-          ])
-        ) : {},
-        // note: using WORKFLOW_ID_HEADER doesn't work, because Runid -> RunId:
-        "Upstash-Workflow-Runid": [workflowRunId],
-        [WORKFLOW_INIT_HEADER]: ["false"],
-        [WORKFLOW_URL_HEADER]: [workflowUrl],
-        "Upstash-Workflow-CallType": ["step"]
-      }
-    };
-  }
-  return { headers: baseHeaders };
-};
 var verifyRequest = async (body, signature, verifier) => {
   if (!verifier) {
     return;
@@ -1017,278 +1080,6 @@ If you want to disable QStash Verification, you should clear env variables QSTAS
     );
   }
 };
-var prepareFlowControl = (flowControl) => {
-  const parallelism = flowControl.parallelism?.toString();
-  const rate = flowControl.ratePerSecond?.toString();
-  const controlValue = [
-    parallelism ? `parallelism=${parallelism}` : void 0,
-    rate ? `rate=${rate}` : void 0
-  ].filter(Boolean);
-  if (controlValue.length === 0) {
-    throw new QstashError3("Provide at least one of parallelism or ratePerSecond for flowControl");
-  }
-  return {
-    flowControlKey: flowControl.key,
-    flowControlValue: controlValue.join(", ")
-  };
-};
-
-// src/serve/serve-many.ts
-var getWorkflowId = (url) => {
-  const components = url.split("/");
-  const lastComponent = components[components.length - 1];
-  return lastComponent.split("?")[0];
-};
-var serveManyBase = ({
-  workflows,
-  getUrl,
-  serveMethod,
-  options
-}) => {
-  const workflowIds = [];
-  const workflowMap = Object.fromEntries(
-    Object.entries(workflows).map((workflow) => {
-      const workflowId = workflow[0];
-      if (workflowIds.includes(workflowId)) {
-        throw new WorkflowError(
-          `Duplicate workflow name found: '${workflowId}'. Please set different workflow names in serveMany.`
-        );
-      }
-      if (workflowId.includes("/")) {
-        throw new WorkflowError(
-          `Invalid workflow name found: '${workflowId}'. Workflow name cannot contain '/'.`
-        );
-      }
-      workflowIds.push(workflowId);
-      workflow[1].workflowId = workflowId;
-      workflow[1].options = {
-        ...options,
-        ...workflow[1].options
-      };
-      const params = [workflow[1].routeFunction, workflow[1].options];
-      const handler = serveMethod(...params);
-      return [workflowId, handler];
-    })
-  );
-  return {
-    handler: async (...params) => {
-      const url = getUrl(...params);
-      const pickedWorkflowId = getWorkflowId(url);
-      if (!pickedWorkflowId) {
-        return new Response(
-          `Unexpected request in serveMany. workflowId not set. Please update the URL of your request.`,
-          {
-            status: 404
-          }
-        );
-      }
-      const workflow = workflowMap[pickedWorkflowId];
-      if (!workflow) {
-        return new Response(
-          `No workflows in serveMany found for '${pickedWorkflowId}'. Please update the URL of your request.`,
-          {
-            status: 404
-          }
-        );
-      }
-      return await workflow(...params);
-    }
-  };
-};
-var invokeWorkflow = async ({
-  settings,
-  invokeStep,
-  context,
-  invokeCount,
-  telemetry
-}) => {
-  const {
-    body,
-    workflow,
-    headers = {},
-    workflowRunId = getWorkflowRunId(),
-    retries,
-    flowControl
-  } = settings;
-  const { workflowId } = workflow;
-  const {
-    retries: workflowRetries,
-    failureFunction,
-    failureUrl,
-    useJSONContent,
-    flowControl: workflowFlowControl
-  } = workflow.options;
-  if (!workflowId) {
-    throw new WorkflowError("You can only invoke workflow which has a workflowId");
-  }
-  const { headers: invokerHeaders } = getHeaders({
-    initHeaderValue: "false",
-    workflowRunId: context.workflowRunId,
-    workflowUrl: context.url,
-    userHeaders: context.headers,
-    failureUrl: context.failureUrl,
-    retries: context.retries,
-    telemetry,
-    invokeCount,
-    flowControl: context.flowControl
-  });
-  invokerHeaders["Upstash-Workflow-Runid"] = context.workflowRunId;
-  const newUrl = context.url.replace(/[^/]+$/, workflowId);
-  const { headers: triggerHeaders } = getHeaders({
-    initHeaderValue: "true",
-    workflowRunId,
-    workflowUrl: newUrl,
-    userHeaders: new Headers(headers),
-    retries: retries ?? workflowRetries,
-    telemetry,
-    failureUrl: failureFunction ? newUrl : failureUrl,
-    invokeCount: invokeCount + 1,
-    flowControl: flowControl ?? workflowFlowControl
-  });
-  triggerHeaders["Upstash-Workflow-Invoke"] = "true";
-  if (useJSONContent) {
-    triggerHeaders["content-type"] = "application/json";
-  }
-  const request = {
-    body: JSON.stringify(body),
-    headers: Object.fromEntries(
-      Object.entries(invokerHeaders).map((pairs) => [pairs[0], [pairs[1]]])
-    ),
-    workflowRunId: context.workflowRunId,
-    workflowUrl: context.url,
-    step: invokeStep
-  };
-  await context.qstashClient.publish({
-    headers: triggerHeaders,
-    method: "POST",
-    body: JSON.stringify(request),
-    url: newUrl
-  });
-};
-
-// src/agents/adapters.ts
-import { createOpenAI } from "@ai-sdk/openai";
-import { tool } from "ai";
-
-// src/agents/constants.ts
-var AGENT_NAME_HEADER = "upstash-agent-name";
-var MANAGER_AGENT_PROMPT = `You are an agent orchestrating other AI Agents.
-
-These other agents have tools available to them.
-
-Given a prompt, utilize these agents to address requests.
-
-Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another.
-
-Avoid calling the same agent twice in one turn. Instead, prefer to call it once but provide everything
-you need from that agent.
-`;
-
-// src/agents/adapters.ts
-var createWorkflowOpenAI = (context, config) => {
-  const { baseURL, apiKey } = config ?? {};
-  return createOpenAI({
-    baseURL,
-    apiKey,
-    compatibility: "strict",
-    fetch: async (input, init) => {
-      try {
-        const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
-        const body = init?.body ? JSON.parse(init.body) : void 0;
-        const agentName = headers[AGENT_NAME_HEADER];
-        const stepName = agentName ? `Call Agent ${agentName}` : "Call Agent";
-        const responseInfo = await context.call(stepName, {
-          url: input.toString(),
-          method: init?.method,
-          headers,
-          body
-        });
-        const responseHeaders = new Headers(
-          Object.entries(responseInfo.header).reduce(
-            (acc, [key, values]) => {
-              acc[key] = values.join(", ");
-              return acc;
-            },
-            {}
-          )
-        );
-        return new Response(JSON.stringify(responseInfo.body), {
-          status: responseInfo.status,
-          headers: responseHeaders
-        });
-      } catch (error) {
-        if (error instanceof Error && error.name === "WorkflowAbort") {
-          throw error;
-        } else {
-          console.error("Error in fetch implementation:", error);
-          throw error;
-        }
-      }
-    }
-  });
-};
-var wrapTools = ({
-  context,
-  tools
-}) => {
-  return Object.fromEntries(
-    Object.entries(tools).map((toolInfo) => {
-      const [toolName, tool3] = toolInfo;
-      const executeAsStep = "executeAsStep" in tool3 ? tool3.executeAsStep : true;
-      const aiSDKTool = convertToAISDKTool(tool3);
-      const execute = aiSDKTool.execute;
-      if (execute && executeAsStep) {
-        const wrappedExecute = (...params) => {
-          return context.run(`Run tool ${toolName}`, () => execute(...params));
-        };
-        aiSDKTool.execute = wrappedExecute;
-      }
-      return [toolName, aiSDKTool];
-    })
-  );
-};
-var convertToAISDKTool = (tool3) => {
-  const isLangchainTool = "invoke" in tool3;
-  return isLangchainTool ? convertLangchainTool(tool3) : tool3;
-};
-var convertLangchainTool = (langchainTool) => {
-  return tool({
-    description: langchainTool.description,
-    parameters: langchainTool.schema,
-    execute: async (...param) => langchainTool.invoke(...param)
-  });
-};
-var WorkflowTool = class {
-  /**
-   * description of the tool
-   */
-  description;
-  /**
-   * schema of the tool
-   */
-  schema;
-  /**
-   * function to invoke the tool
-   */
-  invoke;
-  /**
-   * whether the invoke method of the tool is to be wrapped with `context.run`
-   */
-  executeAsStep;
-  /**
-   *
-   * @param description description of the tool
-   * @param schema schema of the tool
-   * @param invoke function to invoke the tool
-   * @param executeAsStep whether the invoke method of the tool is to be wrapped with `context.run`
-   */
-  constructor(params) {
-    this.description = params.description;
-    this.schema = params.schema;
-    this.invoke = params.invoke;
-    this.executeAsStep = params.executeAsStep ?? true;
-  }
-};
 
 // src/context/steps.ts
 var BaseLazyStep = class _BaseLazyStep {
@@ -1299,6 +1090,11 @@ var BaseLazyStep = class _BaseLazyStep {
         "A workflow step name cannot be undefined or an empty string. Please provide a name for your workflow step."
       );
     }
+    if (typeof stepName !== "string") {
+      console.warn(
+        "Workflow Warning: A workflow step name must be a string. In a future release, this will throw an error."
+      );
+    }
     this.stepName = stepName;
   }
   /**
@@ -1348,6 +1144,40 @@ var BaseLazyStep = class _BaseLazyStep {
       return stepOut;
     }
   }
+  getBody({ step }) {
+    step.out = JSON.stringify(step.out);
+    return JSON.stringify(step);
+  }
+  getHeaders({ context, telemetry, invokeCount, step }) {
+    return getHeaders({
+      initHeaderValue: "false",
+      workflowConfig: {
+        workflowRunId: context.workflowRunId,
+        workflowUrl: context.url,
+        failureUrl: context.failureUrl,
+        retries: context.retries,
+        useJSONContent: false,
+        telemetry,
+        flowControl: context.flowControl
+      },
+      userHeaders: context.headers,
+      invokeCount,
+      stepInfo: {
+        step,
+        lazyStep: this
+      }
+    });
+  }
+  async submitStep({ context, body, headers }) {
+    return await context.qstashClient.batch([
+      {
+        body,
+        headers,
+        method: "POST",
+        url: context.url
+      }
+    ]);
+  }
 };
 var LazyFunctionStep = class extends BaseLazyStep {
   stepFunction;
@@ -1407,6 +1237,17 @@ var LazySleepStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  async submitStep({ context, body, headers, isParallel }) {
+    return await context.qstashClient.batch([
+      {
+        body,
+        headers,
+        method: "POST",
+        url: context.url,
+        delay: isParallel ? void 0 : this.sleep
+      }
+    ]);
+  }
 };
 var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
@@ -1438,6 +1279,17 @@ var LazySleepUntilStep = class extends BaseLazyStep {
   safeParseOut() {
     return void 0;
   }
+  async submitStep({ context, body, headers, isParallel }) {
+    return await context.qstashClient.batch([
+      {
+        body,
+        headers,
+        method: "POST",
+        url: context.url,
+        notBefore: isParallel ? void 0 : this.sleepUntil
+      }
+    ]);
+  }
 };
 var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
   url;
@@ -1521,6 +1373,58 @@ var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
     }
     return false;
   };
+  getBody({ step }) {
+    if (!step.callUrl) {
+      throw new WorkflowError("Incompatible step received in LazyCallStep.getBody");
+    }
+    return JSON.stringify(step.callBody);
+  }
+  getHeaders({ context, telemetry, invokeCount, step }) {
+    const { headers, contentType } = super.getHeaders({ context, telemetry, invokeCount, step });
+    headers["Upstash-Retries"] = this.retries.toString();
+    headers[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete,InitialBody";
+    if (this.flowControl) {
+      const { flowControlKey, flowControlValue } = prepareFlowControl(this.flowControl);
+      headers["Upstash-Flow-Control-Key"] = flowControlKey;
+      headers["Upstash-Flow-Control-Value"] = flowControlValue;
+    }
+    if (this.timeout) {
+      headers["Upstash-Timeout"] = this.timeout.toString();
+    }
+    const forwardedHeaders = Object.fromEntries(
+      Object.entries(this.headers).map(([header, value]) => [`Upstash-Forward-${header}`, value])
+    );
+    return {
+      headers: {
+        ...headers,
+        ...forwardedHeaders,
+        "Upstash-Callback": context.url,
+        "Upstash-Callback-Workflow-RunId": context.workflowRunId,
+        "Upstash-Callback-Workflow-CallType": "fromCallback",
+        "Upstash-Callback-Workflow-Init": "false",
+        "Upstash-Callback-Workflow-Url": context.url,
+        "Upstash-Callback-Feature-Set": "LazyFetch,InitialBody",
+        "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
+        "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
+        "Upstash-Callback-Forward-Upstash-Workflow-StepName": this.stepName,
+        "Upstash-Callback-Forward-Upstash-Workflow-StepType": this.stepType,
+        "Upstash-Callback-Forward-Upstash-Workflow-Concurrent": step.concurrent.toString(),
+        "Upstash-Callback-Forward-Upstash-Workflow-ContentType": contentType,
+        "Upstash-Workflow-CallType": "toCallback"
+      },
+      contentType
+    };
+  }
+  async submitStep({ context, headers }) {
+    return await context.qstashClient.batch([
+      {
+        headers,
+        body: JSON.stringify(this.body),
+        method: this.method,
+        url: this.url
+      }
+    ]);
+  }
 };
 var LazyWaitForEventStep = class extends BaseLazyStep {
   eventId;
@@ -1560,6 +1464,57 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       eventData: BaseLazyStep.tryParsing(result.eventData)
     };
   }
+  getHeaders({ context, telemetry, invokeCount, step }) {
+    const headers = super.getHeaders({ context, telemetry, invokeCount, step });
+    headers.headers["Upstash-Workflow-CallType"] = "step";
+    return headers;
+  }
+  getBody({ context, step, headers, telemetry }) {
+    if (!step.waitEventId) {
+      throw new WorkflowError("Incompatible step received in LazyWaitForEventStep.getBody");
+    }
+    const timeoutHeaders = {
+      // to include user headers:
+      ...Object.fromEntries(Object.entries(headers).map(([header, value]) => [header, [value]])),
+      // to include telemetry headers:
+      ...telemetry ? Object.fromEntries(
+        Object.entries(getTelemetryHeaders(telemetry)).map(([header, value]) => [
+          header,
+          [value]
+        ])
+      ) : {},
+      // note: using WORKFLOW_ID_HEADER doesn't work, because Runid -> RunId:
+      "Upstash-Workflow-Runid": [context.workflowRunId],
+      [WORKFLOW_INIT_HEADER]: ["false"],
+      [WORKFLOW_URL_HEADER]: [context.url],
+      "Upstash-Workflow-CallType": ["step"]
+    };
+    const waitBody = {
+      url: context.url,
+      timeout: step.timeout,
+      timeoutBody: void 0,
+      timeoutUrl: context.url,
+      timeoutHeaders,
+      step: {
+        stepId: step.stepId,
+        stepType: "Wait",
+        stepName: step.stepName,
+        concurrent: step.concurrent,
+        targetStep: step.targetStep
+      }
+    };
+    return JSON.stringify(waitBody);
+  }
+  async submitStep({ context, body, headers }) {
+    const result = await context.qstashClient.http.request({
+      path: ["v2", "wait", this.eventId],
+      body,
+      headers,
+      method: "POST",
+      parseResponseAsJson: false
+    });
+    return [result];
+  }
 };
 var LazyNotifyStep = class extends LazyFunctionStep {
   stepType = "Notify";
@@ -1585,6 +1540,10 @@ var LazyInvokeStep = class extends BaseLazyStep {
   stepType = "Invoke";
   params;
   allowUndefinedOut = false;
+  /**
+   * workflow id of the invoked workflow
+   */
+  workflowId;
   constructor(stepName, {
     workflow,
     body,
@@ -1602,6 +1561,11 @@ var LazyInvokeStep = class extends BaseLazyStep {
       retries,
       flowControl
     };
+    const { workflowId } = workflow;
+    if (!workflowId) {
+      throw new WorkflowError("You can only invoke workflow which has a workflowId");
+    }
+    this.workflowId = workflowId;
   }
   getPlanStep(concurrent, targetStep) {
     return {
@@ -1631,10 +1595,348 @@ var LazyInvokeStep = class extends BaseLazyStep {
       body: BaseLazyStep.tryParsing(result.body)
     };
   }
+  getBody({ context, step, telemetry, invokeCount }) {
+    const { headers: invokerHeaders } = getHeaders({
+      initHeaderValue: "false",
+      workflowConfig: {
+        workflowRunId: context.workflowRunId,
+        workflowUrl: context.url,
+        failureUrl: context.failureUrl,
+        retries: context.retries,
+        telemetry,
+        flowControl: context.flowControl,
+        useJSONContent: false
+      },
+      userHeaders: context.headers,
+      invokeCount
+    });
+    invokerHeaders["Upstash-Workflow-Runid"] = context.workflowRunId;
+    const request = {
+      body: JSON.stringify(this.params.body),
+      headers: Object.fromEntries(
+        Object.entries(invokerHeaders).map((pairs) => [pairs[0], [pairs[1]]])
+      ),
+      workflowRunId: context.workflowRunId,
+      workflowUrl: context.url,
+      step
+    };
+    return JSON.stringify(request);
+  }
+  getHeaders({ context, telemetry, invokeCount }) {
+    const {
+      workflow,
+      headers = {},
+      workflowRunId = getWorkflowRunId(),
+      retries,
+      flowControl
+    } = this.params;
+    const newUrl = context.url.replace(/[^/]+$/, this.workflowId);
+    const {
+      retries: workflowRetries,
+      failureFunction,
+      failureUrl,
+      useJSONContent,
+      flowControl: workflowFlowControl
+    } = workflow.options;
+    const { headers: triggerHeaders, contentType } = getHeaders({
+      initHeaderValue: "true",
+      workflowConfig: {
+        workflowRunId,
+        workflowUrl: newUrl,
+        retries: retries ?? workflowRetries,
+        telemetry,
+        failureUrl: failureFunction ? newUrl : failureUrl,
+        flowControl: flowControl ?? workflowFlowControl,
+        useJSONContent: useJSONContent ?? false
+      },
+      invokeCount: invokeCount + 1,
+      userHeaders: new Headers(headers)
+    });
+    triggerHeaders["Upstash-Workflow-Invoke"] = "true";
+    return { headers: triggerHeaders, contentType };
+  }
+  async submitStep({ context, body, headers }) {
+    const newUrl = context.url.replace(/[^/]+$/, this.workflowId);
+    const result = await context.qstashClient.publish({
+      headers,
+      method: "POST",
+      body,
+      url: newUrl
+    });
+    return [result];
+  }
+};
+
+// src/qstash/headers.ts
+var WorkflowHeaders = class {
+  userHeaders;
+  workflowConfig;
+  invokeCount;
+  initHeaderValue;
+  stepInfo;
+  headers;
+  constructor({
+    userHeaders,
+    workflowConfig,
+    invokeCount,
+    initHeaderValue,
+    stepInfo
+  }) {
+    this.userHeaders = userHeaders;
+    this.workflowConfig = workflowConfig;
+    this.invokeCount = invokeCount;
+    this.initHeaderValue = initHeaderValue;
+    this.stepInfo = stepInfo;
+    this.headers = {
+      rawHeaders: {},
+      workflowHeaders: {},
+      failureHeaders: {}
+    };
+  }
+  getHeaders() {
+    this.addBaseHeaders();
+    this.addRetries();
+    this.addFlowControl();
+    this.addUserHeaders();
+    this.addInvokeCount();
+    this.addFailureUrl();
+    const contentType = this.addContentType();
+    return this.prefixHeaders(contentType);
+  }
+  addBaseHeaders() {
+    this.headers.rawHeaders = {
+      ...this.headers.rawHeaders,
+      [WORKFLOW_INIT_HEADER]: this.initHeaderValue,
+      [WORKFLOW_ID_HEADER]: this.workflowConfig.workflowRunId,
+      [WORKFLOW_URL_HEADER]: this.workflowConfig.workflowUrl,
+      [WORKFLOW_FEATURE_HEADER]: "LazyFetch,InitialBody",
+      [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION,
+      ...this.workflowConfig.telemetry ? getTelemetryHeaders(this.workflowConfig.telemetry) : {},
+      ...this.workflowConfig.telemetry && this.stepInfo?.lazyStep instanceof LazyCallStep && this.stepInfo.lazyStep.headers[AGENT_NAME_HEADER] ? { [TELEMETRY_HEADER_AGENT]: "true" } : {}
+    };
+    if (this.stepInfo?.lazyStep.stepType !== "Call") {
+      this.headers.rawHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
+    }
+  }
+  addInvokeCount() {
+    if (this.invokeCount === void 0 || this.invokeCount === 0) {
+      return;
+    }
+    const invokeCount = this.invokeCount.toString();
+    this.headers.workflowHeaders[`Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount;
+    if (this.workflowConfig.failureUrl) {
+      this.headers.failureHeaders[`Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount;
+    }
+    if (this.stepInfo?.lazyStep instanceof LazyCallStep) {
+      this.headers.rawHeaders[`Upstash-Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount;
+    }
+  }
+  addRetries() {
+    if (this.workflowConfig.retries === void 0 || this.workflowConfig.retries === DEFAULT_RETRIES) {
+      return;
+    }
+    const retries = this.workflowConfig.retries.toString();
+    this.headers.workflowHeaders["Retries"] = retries;
+    if (this.workflowConfig.failureUrl) {
+      this.headers.failureHeaders["Retries"] = retries;
+    }
+  }
+  addFlowControl() {
+    if (!this.workflowConfig.flowControl) {
+      return;
+    }
+    const { flowControlKey, flowControlValue } = prepareFlowControl(
+      this.workflowConfig.flowControl
+    );
+    this.headers.workflowHeaders["Flow-Control-Key"] = flowControlKey;
+    this.headers.workflowHeaders["Flow-Control-Value"] = flowControlValue;
+    if (this.workflowConfig.failureUrl) {
+      this.headers.failureHeaders["Flow-Control-Key"] = flowControlKey;
+      this.headers.failureHeaders["Flow-Control-Value"] = flowControlValue;
+    }
+  }
+  addUserHeaders() {
+    for (const [key, value] of this.userHeaders.entries()) {
+      const forwardKey = `Forward-${key}`;
+      this.headers.workflowHeaders[forwardKey] = value;
+      if (this.workflowConfig.failureUrl) {
+        this.headers.failureHeaders[forwardKey] = value;
+      }
+    }
+  }
+  addFailureUrl() {
+    if (!this.workflowConfig.failureUrl) {
+      return;
+    }
+    this.headers.workflowHeaders["Failure-Callback"] = this.workflowConfig.failureUrl;
+    this.headers.failureHeaders[`Forward-${WORKFLOW_FAILURE_HEADER}`] = "true";
+    this.headers.failureHeaders[`Forward-Upstash-Workflow-Failure-Callback`] = "true";
+    this.headers.failureHeaders["Workflow-Runid"] = this.workflowConfig.workflowRunId;
+    this.headers.failureHeaders["Workflow-Init"] = "false";
+    this.headers.failureHeaders["Workflow-Url"] = this.workflowConfig.workflowUrl;
+    this.headers.failureHeaders["Workflow-Calltype"] = "failureCall";
+    this.headers.failureHeaders["Feature-Set"] = "LazyFetch,InitialBody";
+    if (this.workflowConfig.retries !== void 0 && this.workflowConfig.retries !== DEFAULT_RETRIES) {
+      this.headers.failureHeaders["Retries"] = this.workflowConfig.retries.toString();
+    }
+  }
+  addContentType() {
+    if (this.workflowConfig.useJSONContent) {
+      this.headers.rawHeaders["content-type"] = "application/json";
+      return "application/json";
+    }
+    const callHeaders = new Headers(
+      this.stepInfo?.lazyStep instanceof LazyCallStep ? this.stepInfo.lazyStep.headers : {}
+    );
+    const contentType = (callHeaders.get("content-type") ? callHeaders.get("content-type") : this.userHeaders?.get("Content-Type") ? this.userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
+    this.headers.rawHeaders["content-type"] = contentType;
+    return contentType;
+  }
+  prefixHeaders(contentType) {
+    const { rawHeaders, workflowHeaders, failureHeaders } = this.headers;
+    const isCall = this.stepInfo?.lazyStep.stepType === "Call";
+    return {
+      headers: {
+        ...rawHeaders,
+        ...addPrefixToHeaders(workflowHeaders, isCall ? "Upstash-Callback-" : "Upstash-"),
+        ...addPrefixToHeaders(failureHeaders, "Upstash-Failure-Callback-"),
+        ...isCall ? addPrefixToHeaders(failureHeaders, "Upstash-Callback-Failure-Callback-") : {}
+      },
+      contentType
+    };
+  }
+};
+function addPrefixToHeaders(headers, prefix) {
+  const prefixedHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    prefixedHeaders[`${prefix}${key}`] = value;
+  }
+  return prefixedHeaders;
+}
+var prepareFlowControl = (flowControl) => {
+  const parallelism = flowControl.parallelism?.toString();
+  const rate = (flowControl.rate ?? flowControl.ratePerSecond)?.toString();
+  const period = typeof flowControl.period === "number" ? `${flowControl.period}s` : flowControl.period;
+  const controlValue = [
+    parallelism ? `parallelism=${parallelism}` : void 0,
+    rate ? `rate=${rate}` : void 0,
+    period ? `period=${period}` : void 0
+  ].filter(Boolean);
+  if (controlValue.length === 0) {
+    throw new QstashError4("Provide at least one of parallelism or ratePerSecond for flowControl");
+  }
+  return {
+    flowControlKey: flowControl.key,
+    flowControlValue: controlValue.join(", ")
+  };
+};
+var getHeaders = (params) => {
+  const workflowHeaders = new WorkflowHeaders(params);
+  return workflowHeaders.getHeaders();
+};
+
+// src/qstash/submit-steps.ts
+var submitParallelSteps = async ({
+  context,
+  steps,
+  initialStepCount,
+  invokeCount,
+  telemetry,
+  debug
+}) => {
+  const planSteps = steps.map(
+    (step, index) => step.getPlanStep(steps.length, initialStepCount + index)
+  );
+  await debug?.log("SUBMIT", "SUBMIT_STEP", {
+    length: planSteps.length,
+    steps: planSteps
+  });
+  const result = await context.qstashClient.batch(
+    planSteps.map((planStep) => {
+      const { headers } = getHeaders({
+        initHeaderValue: "false",
+        workflowConfig: {
+          workflowRunId: context.workflowRunId,
+          workflowUrl: context.url,
+          failureUrl: context.failureUrl,
+          retries: context.retries,
+          flowControl: context.flowControl,
+          telemetry
+        },
+        userHeaders: context.headers,
+        invokeCount
+      });
+      return {
+        headers,
+        method: "POST",
+        url: context.url,
+        body: JSON.stringify(planStep),
+        notBefore: planStep.sleepUntil,
+        delay: planStep.sleepFor
+      };
+    })
+  );
+  await debug?.log("INFO", "SUBMIT_STEP", {
+    messageIds: result.map((message) => {
+      return {
+        message: message.messageId
+      };
+    })
+  });
+  throw new WorkflowAbort(planSteps[0].stepName, planSteps[0]);
+};
+var submitSingleStep = async ({
+  context,
+  lazyStep,
+  stepId,
+  invokeCount,
+  concurrency,
+  telemetry,
+  debug
+}) => {
+  const resultStep = await lazyStep.getResultStep(concurrency, stepId);
+  await debug?.log("INFO", "RUN_SINGLE", {
+    fromRequest: false,
+    step: resultStep,
+    stepCount: stepId
+  });
+  const { headers } = lazyStep.getHeaders({
+    context,
+    step: resultStep,
+    invokeCount,
+    telemetry
+  });
+  const body = lazyStep.getBody({
+    context,
+    step: resultStep,
+    headers,
+    invokeCount,
+    telemetry
+  });
+  await debug?.log("SUBMIT", "SUBMIT_STEP", {
+    length: 1,
+    steps: [resultStep]
+  });
+  const submitResult = await lazyStep.submitStep({
+    context,
+    body,
+    headers,
+    isParallel: concurrency !== NO_CONCURRENCY,
+    invokeCount,
+    step: resultStep,
+    telemetry
+  });
+  await debug?.log("INFO", "SUBMIT_STEP", {
+    messageIds: submitResult.map((message) => {
+      return {
+        message: message.messageId
+      };
+    })
+  });
+  return resultStep;
 };
 
 // src/context/auto-executor.ts
-import { QstashError as QstashError4 } from "@upstash/qstash";
 var AutoExecutor = class _AutoExecutor {
   context;
   promises = /* @__PURE__ */ new WeakMap();
@@ -1738,14 +2040,16 @@ var AutoExecutor = class _AutoExecutor {
       });
       return lazyStep.parseOut(step.out);
     }
-    const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
-    await this.debug?.log("INFO", "RUN_SINGLE", {
-      fromRequest: false,
-      step: resultStep,
-      stepCount: this.stepCount
+    const resultStep = await submitSingleStep({
+      context: this.context,
+      lazyStep,
+      stepId: this.stepCount,
+      invokeCount: this.invokeCount,
+      concurrency: 1,
+      telemetry: this.telemetry,
+      debug: this.debug
     });
-    await this.submitStepsToQStash([resultStep], [lazyStep]);
-    return resultStep.out;
+    throw new WorkflowAbort(lazyStep.stepName, resultStep);
   }
   /**
    * Runs steps in parallel.
@@ -1773,10 +2077,14 @@ var AutoExecutor = class _AutoExecutor {
     });
     switch (parallelCallState) {
       case "first": {
-        const planSteps = parallelSteps.map(
-          (parallelStep, index) => parallelStep.getPlanStep(parallelSteps.length, initialStepCount + index)
-        );
-        await this.submitStepsToQStash(planSteps, parallelSteps);
+        await submitParallelSteps({
+          context: this.context,
+          steps: parallelSteps,
+          initialStepCount,
+          invokeCount: this.invokeCount,
+          telemetry: this.telemetry,
+          debug: this.debug
+        });
         break;
       }
       case "partial": {
@@ -1790,13 +2098,18 @@ var AutoExecutor = class _AutoExecutor {
         validateStep(parallelSteps[stepIndex], planStep);
         try {
           const parallelStep = parallelSteps[stepIndex];
-          const resultStep = await parallelStep.getResultStep(
-            parallelSteps.length,
-            planStep.targetStep
-          );
-          await this.submitStepsToQStash([resultStep], [parallelStep]);
+          const resultStep = await submitSingleStep({
+            context: this.context,
+            lazyStep: parallelStep,
+            stepId: planStep.targetStep,
+            invokeCount: this.invokeCount,
+            concurrency: parallelSteps.length,
+            telemetry: this.telemetry,
+            debug: this.debug
+          });
+          throw new WorkflowAbort(parallelStep.stepName, resultStep);
         } catch (error) {
-          if (error instanceof WorkflowAbort || error instanceof QstashError4 && error.status === 400) {
+          if (error instanceof WorkflowAbort || error instanceof QstashError5 && error.status === 400) {
             throw error;
           }
           throw new WorkflowError(
@@ -1852,128 +2165,6 @@ var AutoExecutor = class _AutoExecutor {
       return "discard";
     }
   }
-  /**
-   * sends the steps to QStash as batch
-   *
-   * @param steps steps to send
-   */
-  async submitStepsToQStash(steps, lazySteps) {
-    if (steps.length === 0) {
-      throw new WorkflowError(
-        `Unable to submit steps to QStash. Provided list is empty. Current step: ${this.stepCount}`
-      );
-    }
-    await this.debug?.log("SUBMIT", "SUBMIT_STEP", {
-      length: steps.length,
-      steps
-    });
-    if (steps[0].waitEventId && steps.length === 1) {
-      const waitStep = steps[0];
-      const { headers, timeoutHeaders } = getHeaders({
-        initHeaderValue: "false",
-        workflowRunId: this.context.workflowRunId,
-        workflowUrl: this.context.url,
-        userHeaders: this.context.headers,
-        step: waitStep,
-        failureUrl: this.context.failureUrl,
-        retries: this.context.retries,
-        telemetry: this.telemetry,
-        invokeCount: this.invokeCount,
-        flowControl: this.context.flowControl
-      });
-      const waitBody = {
-        url: this.context.url,
-        timeout: waitStep.timeout,
-        timeoutBody: void 0,
-        timeoutUrl: this.context.url,
-        timeoutHeaders,
-        step: {
-          stepId: waitStep.stepId,
-          stepType: "Wait",
-          stepName: waitStep.stepName,
-          concurrent: waitStep.concurrent,
-          targetStep: waitStep.targetStep
-        }
-      };
-      await this.context.qstashClient.http.request({
-        path: ["v2", "wait", waitStep.waitEventId],
-        body: JSON.stringify(waitBody),
-        headers,
-        method: "POST",
-        parseResponseAsJson: false
-      });
-      throw new WorkflowAbort(waitStep.stepName, waitStep);
-    }
-    if (steps.length === 1 && lazySteps[0] instanceof LazyInvokeStep) {
-      const invokeStep = steps[0];
-      const lazyInvokeStep = lazySteps[0];
-      await invokeWorkflow({
-        settings: lazyInvokeStep.params,
-        invokeStep,
-        context: this.context,
-        invokeCount: this.invokeCount,
-        telemetry: this.telemetry
-      });
-      throw new WorkflowAbort(invokeStep.stepName, invokeStep);
-    }
-    const result = await this.context.qstashClient.batch(
-      steps.map((singleStep, index) => {
-        const lazyStep = lazySteps[index];
-        const { headers } = getHeaders({
-          initHeaderValue: "false",
-          workflowRunId: this.context.workflowRunId,
-          workflowUrl: this.context.url,
-          userHeaders: this.context.headers,
-          step: singleStep,
-          failureUrl: this.context.failureUrl,
-          retries: this.context.retries,
-          callRetries: lazyStep instanceof LazyCallStep ? lazyStep.retries : void 0,
-          callTimeout: lazyStep instanceof LazyCallStep ? lazyStep.timeout : void 0,
-          telemetry: this.telemetry,
-          invokeCount: this.invokeCount,
-          flowControl: this.context.flowControl,
-          callFlowControl: lazyStep instanceof LazyCallStep ? lazyStep.flowControl : void 0
-        });
-        const willWait = singleStep.concurrent === NO_CONCURRENCY || singleStep.stepId === 0;
-        singleStep.out = JSON.stringify(singleStep.out);
-        return singleStep.callUrl && lazyStep instanceof LazyCallStep ? (
-          // if the step is a third party call, we call the third party
-          // url (singleStep.callUrl) and pass information about the workflow
-          // in the headers (handled in getHeaders). QStash makes the request
-          // to callUrl and returns the result to Workflow endpoint.
-          // handleThirdPartyCallResult method sends the result of the third
-          // party call to QStash.
-          {
-            headers,
-            method: singleStep.callMethod,
-            body: JSON.stringify(singleStep.callBody),
-            url: singleStep.callUrl
-          }
-        ) : (
-          // if the step is not a third party call, we use workflow
-          // endpoint (context.url) as URL when calling QStash. QStash
-          // calls us back with the updated steps list.
-          {
-            headers,
-            method: "POST",
-            body: JSON.stringify(singleStep),
-            url: this.context.url,
-            notBefore: willWait ? singleStep.sleepUntil : void 0,
-            delay: willWait ? singleStep.sleepFor : void 0
-          }
-        );
-      })
-    );
-    const _result = result;
-    await this.debug?.log("INFO", "SUBMIT_STEP", {
-      messageIds: _result.map((message) => {
-        return {
-          message: message.messageId
-        };
-      })
-    });
-    throw new WorkflowAbort(steps[0].stepName, steps[0]);
-  }
   /**
    * Get the promise by executing the lazt steps list. If there is a single
    * step, we call `runSingle`. Otherwise `runParallel` is called.
@@ -2169,6 +2360,9 @@ var WorkflowApi = class extends BaseWorkflowApi {
   }
 };
 
+// src/agents/index.ts
+import { createOpenAI } from "@ai-sdk/openai";
+
 // src/agents/agent.ts
 import { z } from "zod";
 import { generateText, tool as tool2, ToolExecutionError } from "ai";
@@ -2373,10 +2567,16 @@ var WorkflowAgents = class {
    */
   openai(...params) {
     const [model, settings] = params;
-    const { baseURL, apiKey, ...otherSettings } = settings ?? {};
-    const openai2 = createWorkflowOpenAI(this.context, { baseURL, apiKey });
-    return openai2(model, otherSettings);
+    const { baseURL, apiKey, callSettings, ...otherSettings } = settings ?? {};
+    const openaiModel = this.AISDKModel({
+      context: this.context,
+      provider: createOpenAI,
+      providerParams: { baseURL, apiKey, compatibility: "strict" },
+      agentCallParams: callSettings
+    });
+    return openaiModel(model, otherSettings);
   }
+  AISDKModel = createWorkflowModel;
 };
 
 // src/context/context.ts
@@ -2600,60 +2800,42 @@ var WorkflowContext = class {
     }
     await this.addStep(new LazySleepUntilStep(stepName, time));
   }
-  /**
-   * Makes a third party call through QStash in order to make a
-   * network call without consuming any runtime.
-   *
-   * ```ts
-   * const { status, body } = await context.call<string>(
-   *   "post call step",
-   *   {
-   *     url: "https://www.some-endpoint.com/api",
-   *     method: "POST",
-   *     body: "my-payload"
-   *   }
-   * );
-   * ```
-   *
-   * tries to parse the result of the request as JSON. If it's
-   * not a JSON which can be parsed, simply returns the response
-   * body as it is.
-   *
-   * @param stepName
-   * @param url url to call
-   * @param method call method. "GET" by default.
-   * @param body call body
-   * @param headers call headers
-   * @param retries number of call retries. 0 by default
-   * @param timeout max duration to wait for the endpoint to respond. in seconds.
-   * @returns call result as {
-   *     status: number;
-   *     body: unknown;
-   *     header: Record<string, string[]>
-   *   }
-   */
   async call(stepName, settings) {
-    const {
-      url,
-      method = "GET",
-      body: requestBody,
-      headers = {},
-      retries = 0,
-      timeout,
-      flowControl
-    } = settings;
-    return await this.addStep(
-      new LazyCallStep(
+    let callStep;
+    if ("workflow" in settings) {
+      const url = getNewUrlFromWorkflowId(this.url, settings.workflow.workflowId);
+      callStep = new LazyCallStep(
+        stepName,
+        url,
+        "POST",
+        settings.body,
+        settings.headers || {},
+        settings.retries || 0,
+        settings.timeout,
+        settings.flowControl ?? settings.workflow.options.flowControl
+      );
+    } else {
+      const {
+        url,
+        method = "GET",
+        body,
+        headers = {},
+        retries = 0,
+        timeout,
+        flowControl
+      } = settings;
+      callStep = new LazyCallStep(
         stepName,
         url,
         method,
-        requestBody,
+        body,
         headers,
         retries,
         timeout,
         flowControl
-      )
-    );
+      );
+    }
+    return await this.addStep(callStep);
   }
   /**
    * Pauses workflow execution until a specific event occurs or a timeout is reached.
@@ -3099,6 +3281,7 @@ var processOptions = (options) => {
     retries: DEFAULT_RETRIES,
     useJSONContent: false,
     disableTelemetry: false,
+    onError: console.error,
     ...options
   };
 };
@@ -3148,7 +3331,8 @@ var serveBase = (routeFunction, telemetry, options) => {
     retries,
     useJSONContent,
     disableTelemetry,
-    flowControl
+    flowControl,
+    onError
   } = processOptions(options);
   telemetry = disableTelemetry ? void 0 : telemetry;
   const debug = WorkflowLogger.getLogger(verbose);
@@ -3277,8 +3461,19 @@ var serveBase = (routeFunction, telemetry, options) => {
     try {
       return await handler(request);
     } catch (error) {
-      console.error(error);
-      return new Response(JSON.stringify(formatWorkflowError(error)), {
+      const formattedError = formatWorkflowError(error);
+      try {
+        onError?.(error);
+      } catch (onErrorError) {
+        const formattedOnErrorError = formatWorkflowError(onErrorError);
+        const errorMessage = `Error while running onError callback: '${formattedOnErrorError.message}'.
+Original error: '${formattedError.message}'`;
+        console.error(errorMessage);
+        return new Response(errorMessage, {
+          status: 500
+        });
+      }
+      return new Response(JSON.stringify(formattedError), {
         status: 500
       });
     }
@@ -3308,8 +3503,8 @@ export {
   getWorkflowRunId,
   StepTypes,
   triggerFirstInvocation,
-  serveManyBase,
   WorkflowTool,
+  serveManyBase,
   WorkflowContext,
   WorkflowLogger,
   serveBase,