@upstash/workflow 0.2.22-rc → 0.3.0-rc

package/solidjs.js

@@ -25,7 +25,95 @@ __export(solidjs_exports, {
 module.exports = __toCommonJS(solidjs_exports);
 
 // src/client/utils.ts
+var import_qstash2 = require("@upstash/qstash");
+
+// src/error.ts
 var import_qstash = require("@upstash/qstash");
+var WorkflowError = class extends import_qstash.QstashError {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowError";
+  }
+};
+var WorkflowAbort = class extends Error {
+  stepInfo;
+  stepName;
+  /**
+   * whether workflow is to be canceled on abort
+   */
+  cancelWorkflow;
+  /**
+   *
+   * @param stepName name of the aborting step
+   * @param stepInfo step information
+   * @param cancelWorkflow
+   */
+  constructor(stepName, stepInfo, cancelWorkflow = false) {
+    super(
+      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
+    );
+    this.name = "WorkflowAbort";
+    this.stepName = stepName;
+    this.stepInfo = stepInfo;
+    this.cancelWorkflow = cancelWorkflow;
+  }
+};
+var WorkflowNonRetryableError = class extends WorkflowAbort {
+  /**
+   * @param message error message to be displayed
+   */
+  constructor(message) {
+    super("fail", void 0, false);
+    this.name = "WorkflowNonRetryableError";
+    if (message) this.message = message;
+  }
+};
+var WorkflowRetryAfterError = class extends WorkflowAbort {
+  retryAfter;
+  /**
+   * @param retryAfter time in seconds after which the workflow should be retried
+   * @param message error message to be displayed
+   */
+  constructor(message, retryAfter) {
+    super("retry", void 0, false);
+    this.name = "WorkflowRetryAfterError";
+    this.retryAfter = retryAfter;
+    if (message) this.message = message;
+  }
+};
+var formatWorkflowError = (error) => {
+  return error instanceof Error ? {
+    error: error.name,
+    message: error.message,
+    stack: error.stack
+  } : {
+    error: "Error",
+    message: `An error occured while executing workflow: '${typeof error === "string" ? error : JSON.stringify(error)}'`
+  };
+};
+function getConstructorName(obj) {
+  if (obj === null || obj === void 0) {
+    return null;
+  }
+  const ctor = obj.constructor;
+  if (!ctor || ctor.name === "Object") {
+    return null;
+  }
+  return ctor.name;
+}
+function getConstructorNames(obj) {
+  const proto = Object.getPrototypeOf(obj);
+  const name = getConstructorName(proto);
+  if (name === null) {
+    return [];
+  }
+  return [name, ...getConstructorNames(proto)];
+}
+function isInstanceOf(v, ctor) {
+  return getConstructorNames(v).includes(ctor.name);
+}
+
+// src/client/utils.ts
 var makeNotifyRequest = async (requester, eventId, eventData) => {
   const result = await requester.request({
     path: ["v2", "notify", eventId],
@@ -65,7 +153,7 @@ var getSteps = async (requester, workflowRunId, messageId, debug) => {
       return { steps: filteredSteps, workflowRunEnded: false };
     }
   } catch (error) {
-    if (error instanceof import_qstash.QstashError && error.status === 404) {
+    if (isInstanceOf(error, import_qstash2.QstashError) && 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
@@ -90,64 +178,11 @@ 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.21";
+var VERSION = "v0.3.0-rc";
 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
-var import_qstash2 = require("@upstash/qstash");
-var WorkflowError = class extends import_qstash2.QstashError {
-  constructor(message) {
-    super(message);
-    this.name = "WorkflowError";
-  }
-};
-var WorkflowAbort = class extends Error {
-  stepInfo;
-  stepName;
-  /**
-   * whether workflow is to be canceled on abort
-   */
-  cancelWorkflow;
-  /**
-   *
-   * @param stepName name of the aborting step
-   * @param stepInfo step information
-   * @param cancelWorkflow
-   */
-  constructor(stepName, stepInfo, cancelWorkflow = false) {
-    super(
-      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
-    );
-    this.name = "WorkflowAbort";
-    this.stepName = stepName;
-    this.stepInfo = stepInfo;
-    this.cancelWorkflow = cancelWorkflow;
-  }
-};
-var WorkflowNonRetryableError = class extends WorkflowAbort {
-  /**
-   * @param message error message to be displayed
-   */
-  constructor(message) {
-    super("fail", void 0, false);
-    this.name = "WorkflowNonRetryableError";
-    if (message) this.message = message;
-  }
-};
-var formatWorkflowError = (error) => {
-  return error instanceof Error ? {
-    error: error.name,
-    message: error.message,
-    stack: error.stack
-  } : {
-    error: "Error",
-    message: `An error occured while executing workflow: '${typeof error === "string" ? error : JSON.stringify(error)}'`
-  };
-};
 
 // src/context/auto-executor.ts
 var import_qstash5 = require("@upstash/qstash");
@@ -520,9 +555,9 @@ var Ok = class {
   }
   safeUnwrap() {
     const value = this.value;
-    return function* () {
+    return (function* () {
       return value;
-    }();
+    })();
   }
   _unsafeUnwrap(_) {
     return this.value;
@@ -581,10 +616,10 @@ var Err = class {
   }
   safeUnwrap() {
     const error = this.error;
-    return function* () {
+    return (function* () {
       yield err(error);
       throw new Error("Do not use this generator out of `safeTry`");
-    }();
+    })();
   }
   _unsafeUnwrap(config) {
     throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
@@ -708,17 +743,17 @@ var triggerRouteFunction = async ({
     return ok("workflow-finished");
   } catch (error) {
     const error_ = error;
-    if (error instanceof import_qstash3.QstashError && error.status === 400) {
+    if (isInstanceOf(error, import_qstash3.QstashError) && error.status === 400) {
       await debug?.log("WARN", "RESPONSE_WORKFLOW", {
         message: `tried to append to a cancelled workflow. exiting without publishing.`,
         name: error.name,
         errorMessage: error.message
       });
       return ok("workflow-was-finished");
-    } else if (!(error_ instanceof WorkflowAbort)) {
-      return err(error_);
-    } else if (error_ instanceof WorkflowNonRetryableError) {
+    } else if (isInstanceOf(error_, WorkflowNonRetryableError) || isInstanceOf(error_, WorkflowRetryAfterError)) {
       return ok(error_);
+    } else if (!isInstanceOf(error_, WorkflowAbort)) {
+      return err(error_);
     } else if (error_.cancelWorkflow) {
       await onCancel();
       return ok("workflow-finished");
@@ -1551,20 +1586,6 @@ var LazyInvokeStep = class extends BaseLazyStep {
   }
 };
 
-// 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/qstash/headers.ts
 var WorkflowHeaders = class {
   userHeaders;
@@ -1613,8 +1634,7 @@ var WorkflowHeaders = class {
       [WORKFLOW_URL_HEADER]: this.workflowConfig.workflowUrl,
       [WORKFLOW_FEATURE_HEADER]: "LazyFetch,InitialBody,WF_DetectTrigger" + (this.keepTriggerConfig ? ",WF_TriggerOnConfig" : ""),
       [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" } : {}
+      ...this.workflowConfig.telemetry ? getTelemetryHeaders(this.workflowConfig.telemetry) : {}
     };
     if (this.stepInfo?.lazyStep.stepType !== "Call") {
       this.headers.rawHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
@@ -2025,7 +2045,7 @@ var AutoExecutor = class _AutoExecutor {
           });
           throw new WorkflowAbort(parallelStep.stepName, resultStep);
         } catch (error) {
-          if (error instanceof WorkflowAbort || error instanceof import_qstash5.QstashError && error.status === 400) {
+          if (isInstanceOf(error, WorkflowAbort) || isInstanceOf(error, import_qstash5.QstashError) && error.status === 400) {
             throw error;
           }
           throw new WorkflowError(
@@ -2132,7 +2152,7 @@ var validateParallelSteps = (lazySteps, stepsFromRequest) => {
       validateStep(lazySteps[index], stepFromRequest);
     }
   } catch (error) {
-    if (error instanceof WorkflowError) {
+    if (isInstanceOf(error, WorkflowError)) {
       const lazyStepNames = lazySteps.map((lazyStep) => lazyStep.stepName);
       const lazyStepTypes = lazySteps.map((lazyStep) => lazyStep.stepType);
       const requestStepNames = stepsFromRequest.map((step) => step.stepName);
@@ -2277,309 +2297,6 @@ var WorkflowApi = class extends BaseWorkflowApi {
   }
 };
 
-// src/agents/index.ts
-var import_openai2 = require("@ai-sdk/openai");
-
-// src/agents/adapters.ts
-var import_ai = require("ai");
-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,
-      retryDelay: agentCallParams?.retryDelay,
-      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 (0, import_ai.tool)({
-    description: langchainTool.description,
-    parameters: langchainTool.schema,
-    execute: async (...param) => langchainTool.invoke(...param)
-  });
-};
-
-// src/agents/agent.ts
-var import_zod = require("zod");
-var import_ai2 = require("ai");
-
-// src/serve/utils.ts
-var isDisabledWorkflowContext = (context) => {
-  return "disabled" in context;
-};
-
-// src/agents/agent.ts
-var Agent = class {
-  name;
-  tools;
-  maxSteps;
-  background;
-  model;
-  temparature;
-  context;
-  constructor({ tools, maxSteps, background, name, model, temparature = 0.1 }, context) {
-    this.name = name;
-    this.tools = tools ?? {};
-    this.maxSteps = maxSteps;
-    this.background = background;
-    this.model = model;
-    this.temparature = temparature;
-    this.context = context;
-  }
-  /**
-   * Trigger the agent by passing a prompt
-   *
-   * @param prompt task to assign to the agent
-   * @returns Response as `{ text: string }`
-   */
-  async call({ prompt }) {
-    try {
-      if (isDisabledWorkflowContext(this.context)) {
-        await this.context.sleep("abort", 0);
-      }
-      const result = await (0, import_ai2.generateText)({
-        model: this.model,
-        tools: this.tools,
-        maxSteps: this.maxSteps,
-        system: this.background,
-        prompt,
-        headers: {
-          [AGENT_NAME_HEADER]: this.name
-        },
-        temperature: this.temparature
-      });
-      return { text: result.text };
-    } catch (error) {
-      if (error instanceof import_ai2.ToolExecutionError) {
-        if (error.cause instanceof Error && error.cause.name === "WorkflowAbort") {
-          throw error.cause;
-        } else if (error.cause instanceof import_ai2.ToolExecutionError && error.cause.cause instanceof Error && error.cause.cause.name === "WorkflowAbort") {
-          throw error.cause.cause;
-        } else {
-          throw error;
-        }
-      } else {
-        throw error;
-      }
-    }
-  }
-  /**
-   * Convert the agent to a tool which can be used by other agents.
-   *
-   * @returns the agent as a tool
-   */
-  asTool() {
-    const toolDescriptions = Object.values(this.tools).map((tool3) => tool3.description).join("\n");
-    return (0, import_ai2.tool)({
-      parameters: import_zod.z.object({ prompt: import_zod.z.string() }),
-      execute: async ({ prompt }) => {
-        return await this.call({ prompt });
-      },
-      description: `An AI Agent with the following background: ${this.background}Has access to the following tools: ${toolDescriptions}`
-    });
-  }
-};
-var ManagerAgent = class extends Agent {
-  agents;
-  /**
-   * A manager agent which coordinates agents available to it to achieve a
-   * given task
-   *
-   * @param name Name of the agent
-   * @param background Background of the agent. If not passed, default will be used.
-   * @param model LLM model to use
-   * @param agents: List of agents available to the agent
-   * @param maxSteps number of times the manager agent can call the LLM at most.
-   *   If the agent abruptly stops execution after calling other agents, you may
-   *   need to increase maxSteps
-   */
-  constructor({
-    agents,
-    background = MANAGER_AGENT_PROMPT,
-    model,
-    maxSteps,
-    name = "manager llm"
-  }, context) {
-    super(
-      {
-        background,
-        maxSteps,
-        tools: Object.fromEntries(agents.map((agent) => [agent.name, agent.asTool()])),
-        name,
-        model
-      },
-      context
-    );
-    this.agents = agents;
-  }
-};
-
-// src/agents/task.ts
-var Task = class {
-  context;
-  taskParameters;
-  constructor({
-    context,
-    taskParameters
-  }) {
-    this.context = context;
-    this.taskParameters = taskParameters;
-  }
-  /**
-   * Run the agents to complete the task
-   *
-   * @returns Result of the task as { text: string }
-   */
-  async run() {
-    const { prompt, ...otherParams } = this.taskParameters;
-    if ("agent" in otherParams) {
-      const agent = otherParams.agent;
-      const result = await agent.call({
-        prompt
-      });
-      return { text: result.text };
-    } else {
-      const { agents, maxSteps, model, background } = otherParams;
-      const managerAgent = new ManagerAgent(
-        {
-          model,
-          maxSteps,
-          agents,
-          name: "Manager LLM",
-          background
-        },
-        this.context
-      );
-      const result = await managerAgent.call({ prompt });
-      return { text: result.text };
-    }
-  }
-};
-
-// src/agents/index.ts
-var WorkflowAgents = class {
-  context;
-  constructor({ context }) {
-    this.context = context;
-  }
-  /**
-   * Defines an agent
-   *
-   * ```ts
-   * const researcherAgent = context.agents.agent({
-   *   model,
-   *   name: 'academic',
-   *   maxSteps: 2,
-   *   tools: {
-   *     wikiTool: new WikipediaQueryRun({
-   *       topKResults: 1,
-   *       maxDocContentLength: 500,
-   *     })
-   *   },
-   *   background:
-   *     'You are researcher agent with access to Wikipedia. ' +
-   *     'Utilize Wikipedia as much as possible for correct information',
-   * });
-   * ```
-   *
-   * @param params agent parameters
-   * @returns
-   */
-  agent(params) {
-    const wrappedTools = wrapTools({ context: this.context, tools: params.tools });
-    return new Agent(
-      {
-        ...params,
-        tools: wrappedTools
-      },
-      this.context
-    );
-  }
-  task(taskParameters) {
-    return new Task({ context: this.context, taskParameters });
-  }
-  /**
-   * creates an openai model for agents
-   */
-  openai(...params) {
-    const [model, settings] = params;
-    const { baseURL, apiKey, callSettings, ...otherSettings } = settings ?? {};
-    const openaiModel = this.AISDKModel({
-      context: this.context,
-      provider: import_openai2.createOpenAI,
-      providerParams: { baseURL, apiKey, compatibility: "strict" },
-      agentCallParams: callSettings
-    });
-    return openaiModel(model, otherSettings);
-  }
-  AISDKModel = createWorkflowModel;
-};
-
 // src/serve/serve-many.ts
 var getNewUrlFromWorkflowId = (url, workflowId) => {
   if (!workflowId) {
@@ -2821,7 +2538,7 @@ var WorkflowContext = class {
    * @returns result of the step function
    */
   async run(stepName, stepFunction) {
-    const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
+    const wrappedStepFunction = (() => this.executor.wrapStep(stepName, stepFunction));
     return await this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
   }
   /**
@@ -2992,11 +2709,6 @@ var WorkflowContext = class {
       context: this
     });
   }
-  get agents() {
-    return new WorkflowAgents({
-      context: this
-    });
-  }
 };
 
 // src/logger.ts
@@ -3100,7 +2812,7 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
     try {
       await routeFunction(disabledContext);
     } catch (error) {
-      if (error instanceof WorkflowAbort && error.stepName === this.disabledMessage || error instanceof WorkflowNonRetryableError) {
+      if (isInstanceOf(error, WorkflowAbort) && error.stepName === this.disabledMessage || isInstanceOf(error, WorkflowNonRetryableError) || isInstanceOf(error, WorkflowRetryAfterError)) {
         return ok("step-found");
       }
       console.warn(
@@ -3353,13 +3065,24 @@ var processOptions = (options) => {
           },
           status: 489
         });
-      } else if (detailedFinishCondition?.condition === "failure-callback") {
-        return new Response(detailedFinishCondition.result ?? void 0, {
-          status: 200,
+      } else if (detailedFinishCondition?.condition === "retry-after-error") {
+        return new Response(JSON.stringify(formatWorkflowError(detailedFinishCondition.result)), {
           headers: {
+            "Retry-After": detailedFinishCondition.result.retryAfter.toString(),
             [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION
-          }
+          },
+          status: 429
         });
+      } else if (detailedFinishCondition?.condition === "failure-callback") {
+        return new Response(
+          JSON.stringify({ result: detailedFinishCondition.result ?? void 0 }),
+          {
+            status: 200,
+            headers: {
+              [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION
+            }
+          }
+        );
       }
       return new Response(JSON.stringify({ workflowRunId }), {
         status: 200,
@@ -3569,12 +3292,18 @@ var serveBase = (routeFunction, telemetry, options) => {
         },
         debug
       });
-      if (result.isOk() && result.value instanceof WorkflowNonRetryableError) {
+      if (result.isOk() && isInstanceOf(result.value, WorkflowNonRetryableError)) {
         return onStepFinish(workflowRunId, result.value, {
           condition: "non-retryable-error",
           result: result.value
         });
       }
+      if (result.isOk() && isInstanceOf(result.value, WorkflowRetryAfterError)) {
+        return onStepFinish(workflowRunId, result.value, {
+          condition: "retry-after-error",
+          result: result.value
+        });
+      }
       if (result.isErr()) {
         await debug?.log("ERROR", "ERROR", { error: result.error.message });
         throw result.error;
@@ -3605,7 +3334,7 @@ var serveBase = (routeFunction, telemetry, options) => {
         const errorMessage = `Error while running onError callback: '${formattedOnErrorError.message}'.
 Original error: '${formattedError.message}'`;
         console.error(errorMessage);
-        return new Response(errorMessage, {
+        return new Response(JSON.stringify({ error: errorMessage }), {
           status: 500,
           headers: {
             [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION

package/solidjs.mjs

@@ -1,7 +1,7 @@
 import {
   SDK_TELEMETRY,
   serveBase
-} from "./chunk-CAQSUCHB.mjs";
+} from "./chunk-AGYYZKP7.mjs";
 
 // platforms/solidjs.ts
 var serve = (routeFunction, options) => {

package/svelte.d.mts

@@ -1,11 +1,9 @@
 import * as _sveltejs_kit from '@sveltejs/kit';
 import { RequestHandler } from '@sveltejs/kit';
-import { R as RouteFunction, n as PublicServeOptions, y as InvokableWorkflow } from './types-Q3dM0UlR.mjs';
-import { s as serveManyBase } from './serve-many-BNusWYgt.mjs';
+import { R as RouteFunction, n as PublicServeOptions, y as InvokableWorkflow } from './types-DESkn7K9.mjs';
+import { s as serveManyBase } from './serve-many-DEwKPF6H.mjs';
 import '@upstash/qstash';
 import 'zod';
-import 'ai';
-import '@ai-sdk/openai';
 
 type RequireEnv<T> = T & {
     env: PublicServeOptions["env"];
@@ -22,9 +20,9 @@ type RequireEnv<T> = T & {
 declare const serve: <TInitialPayload = unknown, TResult = unknown>(routeFunction: RouteFunction<TInitialPayload, TResult>, options: RequireEnv<PublicServeOptions<TInitialPayload>>) => {
     POST: RequestHandler;
 };
-declare const createWorkflow: <TInitialPayload, TResult>(routeFunction: RouteFunction<TInitialPayload, TResult>, options: RequireEnv<PublicServeOptions<TInitialPayload>>) => InvokableWorkflow<TInitialPayload, TResult>;
+declare const createWorkflow: <TInitialPayload, TResult>(...params: Parameters<typeof serve<TInitialPayload, TResult>>) => InvokableWorkflow<TInitialPayload, TResult>;
 declare const serveMany: (workflows: Parameters<typeof serveManyBase>[0]["workflows"], options?: Parameters<typeof serveManyBase>[0]["options"]) => {
-    POST: (event: _sveltejs_kit.RequestEvent<Partial<Record<string, string>>, string | null>) => Promise<any>;
+    POST: (event: _sveltejs_kit.RequestEvent<Record<string, string>, string | null>) => Promise<any>;
 };
 
 export { createWorkflow, serve, serveMany };