queuebear 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -2,7 +2,6 @@
  * Base HTTP client for QueueBear API requests
  */
 interface BaseClientOptions {
-    baseUrl: string;
     apiKey: string;
     projectId: string;
 }
@@ -14,7 +13,6 @@ type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
  * Base client providing shared HTTP functionality
  */
 declare class BaseClient {
-    protected baseUrl: string;
     protected apiKey: string;
     protected projectId: string;
     constructor(options: BaseClientOptions);
@@ -51,7 +49,7 @@ type StepType = "run" | "sleep" | "call" | "continuation" | "wait_event";
  * Workflow run information returned by client.getStatus()
  */
 interface WorkflowRun {
-    runId: string;
+    id: string;
     workflowId: string;
     workflowUrl: string;
     status: WorkflowRunStatus;
@@ -83,7 +81,7 @@ interface WorkflowStep {
  * Response from client.trigger()
  */
 interface TriggerResponse {
-    runId: string;
+    id: string;
 }
 /**
  * Response from client.getStatus() - includes run details and steps
@@ -113,7 +111,6 @@ interface StepRetryOptions {
  * Options for serve() function
  */
 interface ServeOptions {
-    baseUrl?: string;
     retries?: number;
     signingSecret?: string;
 }
@@ -781,7 +778,7 @@ declare class WorkflowsAPI extends BaseClient {
      *
      * @example
      * ```typescript
-     * const { runId } = await qb.workflows.trigger(
+     * const { id } = await qb.workflows.trigger(
      *   "user-onboarding",
      *   "https://your-app.com/api/workflows/onboarding",
      *   { userId: "123", email: "user@example.com" },
@@ -825,12 +822,12 @@ declare class WorkflowsAPI extends BaseClient {
      * @example
      * ```typescript
      * const result = await qb.workflows.retry(runId);
-     * console.log(result.runId);
+     * console.log(result.id);
      * console.log(result.resumed); // true
      * ```
      */
     retry(runId: string): Promise<{
-        runId: string;
+        id: string;
         resumed: boolean;
     }>;
     /**
@@ -919,8 +916,6 @@ declare class WorkflowsAPI extends BaseClient {
  * QueueBear client options
  */
 interface QueueBearOptions {
-    /** Base URL of your QueueBear instance */
-    baseUrl: string;
     /** API key (qb_live_* or qb_test_*) */
     apiKey: string;
     /** Project ID */
@@ -937,7 +932,6 @@ interface QueueBearOptions {
  * import { QueueBear, serve } from "@queuebear/workflow";
  *
  * const qb = new QueueBear({
- *   baseUrl: "https://your-queuebear-instance.com",
  *   apiKey: "qb_live_xxx",
  *   projectId: "proj_xxx",
  * });
@@ -1109,6 +1103,22 @@ declare class WorkflowPausedError extends Error {
     reason: string;
     constructor(reason: string);
 }
+/**
+ * Error thrown when parallel execution has failures
+ */
+declare class ParallelExecutionError extends Error {
+    errors: Array<{
+        index: number;
+        stepName: string;
+        error: Error;
+    }>;
+    constructor(message: string, errors: Array<{
+        index: number;
+        stepName: string;
+        error: Error;
+    }>);
+    get failedStepCount(): number;
+}
 /**
  * Context options for creating a new WorkflowContext
  */
@@ -1116,26 +1126,17 @@ interface WorkflowContextOptions<T> {
     runId: string;
     runToken: string;
     input: T;
-    baseUrl: string;
     authHeader: string;
 }
 /**
  * WorkflowContext provides methods for executing workflow steps
  */
-declare class WorkflowContext<T> {
+interface WorkflowContext<T> {
     readonly runId: string;
     readonly input: T;
-    private runToken;
-    private baseUrl;
-    private authHeader;
-    private stepIndex;
-    constructor(options: WorkflowContextOptions<T>);
     /**
      * Execute a step with caching
      * Step names must be unique within a workflow run
-     * @param stepName - Unique name for this step
-     * @param fn - Function to execute
-     * @param options - Optional retry configuration
      */
     run<R>(stepName: string, fn: () => Promise<R>, options?: StepRetryOptions): Promise<R>;
     /**
@@ -1158,44 +1159,26 @@ declare class WorkflowContext<T> {
     call<R>(stepName: string, config: CallConfig): Promise<R>;
     /**
      * Wait for an external event
-     * @param stepName - Unique step name
-     * @param eventName - Name of the event to wait for
-     * @param options - Optional event key and timeout
      */
-    waitForEvent<T = unknown>(stepName: string, eventName: string, options?: WaitForEventOptions): Promise<T>;
+    waitForEvent<E = unknown>(stepName: string, eventName: string, options?: WaitForEventOptions): Promise<E>;
     /**
      * Send a fire-and-forget notification event
-     * @param eventName - Name of the event to send
-     * @param payload - Optional payload to include
      */
     notify(eventName: string, payload?: unknown): Promise<void>;
     /**
      * Execute multiple steps in parallel
-     * @param steps - Array of step definitions with name and function
      */
-    parallel<T extends readonly unknown[]>(steps: {
-        [K in keyof T]: {
+    parallel<R extends readonly unknown[]>(steps: {
+        [K in keyof R]: {
             name: string;
-            fn: () => Promise<T[K]>;
+            fn: () => Promise<R[K]>;
         };
-    }): Promise<T>;
+    }): Promise<R>;
 }
 /**
- * Error thrown when parallel execution has failures
+ * Create a workflow context for executing workflow steps
  */
-declare class ParallelExecutionError extends Error {
-    errors: Array<{
-        index: number;
-        stepName: string;
-        error: Error;
-    }>;
-    constructor(message: string, errors: Array<{
-        index: number;
-        stepName: string;
-        error: Error;
-    }>);
-    get failedStepCount(): number;
-}
+declare function createWorkflowContext<T>(options: WorkflowContextOptions<T>): WorkflowContext<T>;
 
 /**
  * Workflow handler function type
@@ -1206,4 +1189,4 @@ type WorkflowHandler<TInput = unknown, TOutput = unknown> = (context: WorkflowCo
  */
 declare function serve<TInput = unknown, TOutput = unknown>(handler: WorkflowHandler<TInput, TOutput>, options?: ServeOptions): (request: Request) => Promise<Response>;
 
-export { type CallConfig, type CancelMessageResponse, type CompletedStep, type CreateScheduleOptions, type CreateScheduleResponse, DLQAPI, type DLQEntry, type DLQEntrySummary, type DeleteDLQResponse, type DeleteScheduleResponse, type DeliveryLog, type LastResponse, type ListDLQOptions, type ListDLQResponse, type ListMessagesOptions, type ListMessagesResponse, type ListRunsOptions, type ListRunsResponse, type ListSchedulesOptions, type ListSchedulesResponse, type Message, type MessageMethod, type MessageStatus, type MessageSummary, MessagesAPI, type Pagination, ParallelExecutionError, type ParallelStepDefinition, type PauseScheduleResponse, type PublishOptions, type PublishResponse, type PurgeDLQResponse, QueueBear, QueueBearError, type QueueBearOptions, type ResumeScheduleResponse, type RetryDLQResponse, type Schedule, type ScheduleSummary, SchedulesAPI, type SendEventOptions, type SendEventResponse, type ServeOptions, type StatusResponse, type StepRetryOptions, type StepType, type TriggerOptions, type TriggerResponse, type WaitForEventOptions, WorkflowContext, type WorkflowContextOptions, type WorkflowHandler, WorkflowPausedError, type WorkflowRun, type WorkflowRunStatus, type WorkflowStep, WorkflowsAPI, serve };
+export { type CallConfig, type CancelMessageResponse, type CompletedStep, type CreateScheduleOptions, type CreateScheduleResponse, DLQAPI, type DLQEntry, type DLQEntrySummary, type DeleteDLQResponse, type DeleteScheduleResponse, type DeliveryLog, type LastResponse, type ListDLQOptions, type ListDLQResponse, type ListMessagesOptions, type ListMessagesResponse, type ListRunsOptions, type ListRunsResponse, type ListSchedulesOptions, type ListSchedulesResponse, type Message, type MessageMethod, type MessageStatus, type MessageSummary, MessagesAPI, type Pagination, ParallelExecutionError, type ParallelStepDefinition, type PauseScheduleResponse, type PublishOptions, type PublishResponse, type PurgeDLQResponse, QueueBear, QueueBearError, type QueueBearOptions, type ResumeScheduleResponse, type RetryDLQResponse, type Schedule, type ScheduleSummary, SchedulesAPI, type SendEventOptions, type SendEventResponse, type ServeOptions, type StatusResponse, type StepRetryOptions, type StepType, type TriggerOptions, type TriggerResponse, type WaitForEventOptions, type WorkflowContext, type WorkflowContextOptions, type WorkflowHandler, WorkflowPausedError, type WorkflowRun, type WorkflowRunStatus, type WorkflowStep, WorkflowsAPI, createWorkflowContext, serve };

package/dist/index.js

@@ -1,10 +1,8 @@
 // src/api/base.ts
 var BaseClient = class {
-  baseUrl;
   apiKey;
   projectId;
   constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.apiKey = options.apiKey;
     this.projectId = options.projectId;
   }
@@ -12,7 +10,9 @@ var BaseClient = class {
    * Build the full URL for a project-scoped endpoint
    */
   buildUrl(path, queryParams) {
-    const url = new URL(`${this.baseUrl}/v1/projects/${this.projectId}${path}`);
+    const url = new URL(
+      `https://api.queuebear.com/v1/projects/${this.projectId}${path}`
+    );
     if (queryParams) {
       for (const [key, value] of Object.entries(queryParams)) {
         if (value !== void 0) {
@@ -80,36 +80,36 @@ var MessagesAPI = class extends BaseClient {
    * ```
    */
   async publish(destination, body, options) {
-    const headers = {
-      "Content-Type": "application/json"
+    const requestBody = {
+      destination,
+      body
     };
     if (options?.delay) {
-      headers["queuebear-delay"] = options.delay;
+      requestBody.delay = options.delay;
     }
     if (options?.retries !== void 0) {
-      headers["queuebear-retries"] = String(options.retries);
+      requestBody.retries = options.retries;
     }
     if (options?.method) {
-      headers["queuebear-method"] = options.method;
+      requestBody.method = options.method;
     }
     if (options?.callbackUrl) {
-      headers["queuebear-callback"] = options.callbackUrl;
+      requestBody.callbackUrl = options.callbackUrl;
     }
     if (options?.failureCallbackUrl) {
-      headers["queuebear-failure-callback"] = options.failureCallbackUrl;
+      requestBody.failureCallbackUrl = options.failureCallbackUrl;
     }
     if (options?.deduplicationId) {
-      headers["queuebear-deduplication-id"] = options.deduplicationId;
+      requestBody.deduplicationId = options.deduplicationId;
     }
     if (options?.headers) {
-      for (const [key, value] of Object.entries(options.headers)) {
-        headers[`queuebear-forward-${key}`] = value;
-      }
+      requestBody.headers = options.headers;
     }
-    const encodedDestination = encodeURIComponent(destination);
-    return this.request("POST", `/publish/${encodedDestination}`, {
-      body,
-      headers
+    return this.request("POST", "/publish", {
+      body: requestBody,
+      headers: {
+        "Content-Type": "application/json"
+      }
     });
   }
   /**
@@ -468,7 +468,7 @@ var WorkflowsAPI = class extends BaseClient {
    *
    * @example
    * ```typescript
-   * const { runId } = await qb.workflows.trigger(
+   * const { id } = await qb.workflows.trigger(
    *   "user-onboarding",
    *   "https://your-app.com/api/workflows/onboarding",
    *   { userId: "123", email: "user@example.com" },
@@ -526,7 +526,7 @@ var WorkflowsAPI = class extends BaseClient {
    * @example
    * ```typescript
    * const result = await qb.workflows.retry(runId);
-   * console.log(result.runId);
+   * console.log(result.id);
    * console.log(result.resumed); // true
    * ```
    */
@@ -646,8 +646,8 @@ var WorkflowsAPI = class extends BaseClient {
    */
   async triggerAndWait(workflowId, workflowUrl, input, options) {
     const { pollIntervalMs, timeoutMs, ...triggerOptions } = options || {};
-    const { runId } = await this.trigger(workflowId, workflowUrl, input, triggerOptions);
-    return this.waitForCompletion(runId, { pollIntervalMs, timeoutMs });
+    const { id } = await this.trigger(workflowId, workflowUrl, input, triggerOptions);
+    return this.waitForCompletion(id, { pollIntervalMs, timeoutMs });
   }
 };
 
@@ -748,7 +748,6 @@ var QueueBear = class {
   workflows;
   constructor(options) {
     this.options = {
-      baseUrl: options.baseUrl.replace(/\/$/, ""),
       apiKey: options.apiKey,
       projectId: options.projectId
     };
@@ -803,11 +802,17 @@ var QueueBear = class {
    * ```
    */
   async triggerAndWait(workflowId, workflowUrl, input, options) {
-    return this.workflows.triggerAndWait(workflowId, workflowUrl, input, options);
+    return this.workflows.triggerAndWait(
+      workflowId,
+      workflowUrl,
+      input,
+      options
+    );
   }
 };
 
 // src/context.ts
+var BASE_URL = "https://api.queuebear.com/v1/workflows";
 var WorkflowPausedError = class extends Error {
   constructor(reason) {
     super(reason);
@@ -815,63 +820,55 @@ var WorkflowPausedError = class extends Error {
     this.name = "WorkflowPausedError";
   }
 };
-var WorkflowContext = class {
-  runId;
-  input;
-  runToken;
-  baseUrl;
-  authHeader;
-  stepIndex = 0;
-  constructor(options) {
-    this.runId = options.runId;
-    this.runToken = options.runToken;
-    this.input = options.input;
-    this.baseUrl = options.baseUrl;
-    this.authHeader = options.authHeader;
+var ParallelExecutionError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ParallelExecutionError";
   }
-  /**
-   * Execute a step with caching
-   * Step names must be unique within a workflow run
-   * @param stepName - Unique name for this step
-   * @param fn - Function to execute
-   * @param options - Optional retry configuration
-   */
-  async run(stepName, fn, options) {
+  get failedStepCount() {
+    return this.errors.length;
+  }
+};
+function createWorkflowContext(options) {
+  const { runId, runToken, input, authHeader } = options;
+  let stepIndex = 0;
+  const run = async (stepName, fn, retryOptions) => {
     const checkResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/step/check`,
+      `${BASE_URL}/internal/step/check`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName
         })
       }
     );
     const checkData = await checkResponse.json();
     if (checkData.cached) {
-      this.stepIndex++;
+      stepIndex++;
       return checkData.result;
     }
     const startResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/step/start`,
+      `${BASE_URL}/internal/step/start`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName,
-          stepIndex: this.stepIndex,
+          stepIndex,
           stepType: "run",
-          retryOptions: options
+          retryOptions
         })
       }
     );
@@ -881,76 +878,72 @@ var WorkflowContext = class {
     }
     try {
       const result = await fn();
-      await fetch(`${this.baseUrl}/v1/workflows/internal/step/complete`, {
+      await fetch(`${BASE_URL}/internal/step/complete`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName,
           result
         })
       });
-      this.stepIndex++;
+      stepIndex++;
       return result;
     } catch (error) {
-      await fetch(`${this.baseUrl}/v1/workflows/internal/step/fail`, {
+      await fetch(`${BASE_URL}/internal/step/fail`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName,
           error: error instanceof Error ? error.message : String(error)
         })
       });
       throw error;
     }
-  }
-  /**
-   * Sleep for specified seconds
-   * Step names must be unique within a workflow run
-   */
-  async sleep(stepName, seconds) {
+  };
+  const sleep = async (stepName, seconds) => {
     const checkResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/step/check`,
+      `${BASE_URL}/internal/step/check`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName
         })
       }
     );
     const checkData = await checkResponse.json();
     if (checkData.cached) {
-      this.stepIndex++;
+      stepIndex++;
       return;
     }
     const sleepResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/sleep`,
+      `${BASE_URL}/internal/sleep`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName,
-          stepIndex: this.stepIndex,
+          stepIndex,
           seconds
         })
       }
@@ -960,28 +953,21 @@ var WorkflowContext = class {
       throw new Error(errorData.error || "Failed to schedule sleep");
     }
     throw new WorkflowPausedError(`Sleeping for ${seconds}s`);
-  }
-  /**
-   * Sleep until specific date
-   */
-  async sleepUntil(stepName, until) {
+  };
+  const sleepUntil = async (stepName, until) => {
     const seconds = Math.max(
       0,
       Math.ceil((until.getTime() - Date.now()) / 1e3)
     );
-    return this.sleep(stepName, seconds);
-  }
-  /**
-   * Get all completed steps for the current run
-   * Useful for inspecting progress or debugging
-   */
-  async getCompletedSteps() {
+    return sleep(stepName, seconds);
+  };
+  const getCompletedSteps = async () => {
     const response = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/steps/${this.runId}`,
+      `${BASE_URL}/internal/steps/${runId}`,
       {
         headers: {
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         }
       }
     );
@@ -990,12 +976,9 @@ var WorkflowContext = class {
     }
     const data = await response.json();
     return data.steps;
-  }
-  /**
-   * Make HTTP call (executed as a step)
-   */
-  async call(stepName, config) {
-    return this.run(stepName, async () => {
+  };
+  const call = async (stepName, config) => {
+    return run(stepName, async () => {
       const response = await fetch(config.url, {
         method: config.method || "GET",
         headers: {
@@ -1013,53 +996,47 @@ var WorkflowContext = class {
       }
       return response.text();
     });
-  }
-  /**
-   * Wait for an external event
-   * @param stepName - Unique step name
-   * @param eventName - Name of the event to wait for
-   * @param options - Optional event key and timeout
-   */
-  async waitForEvent(stepName, eventName, options) {
+  };
+  const waitForEvent = async (stepName, eventName, eventOptions) => {
     const checkResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/event/check`,
+      `${BASE_URL}/internal/event/check`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName
         })
       }
     );
     const checkData = await checkResponse.json();
     if (checkData.received) {
-      this.stepIndex++;
+      stepIndex++;
       return checkData.payload;
     }
     if (checkData.expired) {
       throw new Error(`Event "${eventName}" timed out`);
     }
     const waitResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/event/wait`,
+      `${BASE_URL}/internal/event/wait`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepName,
-          stepIndex: this.stepIndex,
+          stepIndex,
           eventName,
-          eventKey: options?.eventKey,
-          timeoutSeconds: options?.timeoutSeconds
+          eventKey: eventOptions?.eventKey,
+          timeoutSeconds: eventOptions?.timeoutSeconds
         })
       }
     );
@@ -1068,20 +1045,15 @@ var WorkflowContext = class {
       throw new Error(errorData.error || "Failed to register event wait");
     }
     throw new WorkflowPausedError(`Waiting for event: ${eventName}`);
-  }
-  /**
-   * Send a fire-and-forget notification event
-   * @param eventName - Name of the event to send
-   * @param payload - Optional payload to include
-   */
-  async notify(eventName, payload) {
+  };
+  const notify = async (eventName, payload) => {
     const response = await fetch(
-      `${this.baseUrl}/v1/workflows/events/${encodeURIComponent(eventName)}`,
+      `${BASE_URL}/events/${encodeURIComponent(eventName)}`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader
+          Authorization: authHeader
         },
         body: JSON.stringify({ payload })
       }
@@ -1090,24 +1062,20 @@ var WorkflowContext = class {
       const errorData = await response.json();
       throw new Error(errorData.error || `Failed to send event: ${eventName}`);
     }
-  }
-  /**
-   * Execute multiple steps in parallel
-   * @param steps - Array of step definitions with name and function
-   */
-  async parallel(steps) {
+  };
+  const parallel = async (steps) => {
     const stepNames = steps.map((s) => s.name);
     const batchResponse = await fetch(
-      `${this.baseUrl}/v1/workflows/internal/steps/batch-check`,
+      `${BASE_URL}/internal/steps/batch-check`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: this.authHeader,
-          "X-QueueBear-Run-Token": this.runToken
+          Authorization: authHeader,
+          "X-QueueBear-Run-Token": runToken
         },
         body: JSON.stringify({
-          runId: this.runId,
+          runId,
           stepNames
         })
       }
@@ -1126,7 +1094,7 @@ var WorkflowContext = class {
         results[i] = cached.result;
       } else {
         pendingPromises.push(
-          this.run(step.name, step.fn).then((result) => {
+          run(step.name, step.fn).then((result) => {
             results[i] = result;
           }).catch((error) => {
             errors.push({
@@ -1147,26 +1115,28 @@ var WorkflowContext = class {
       );
     }
     return results;
-  }
-};
-var ParallelExecutionError = class extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "ParallelExecutionError";
-  }
-  get failedStepCount() {
-    return this.errors.length;
-  }
-};
+  };
+  return {
+    runId,
+    input,
+    run,
+    sleep,
+    sleepUntil,
+    getCompletedSteps,
+    call,
+    waitForEvent,
+    notify,
+    parallel
+  };
+}
 
 // src/serve.ts
 import { createHmac, timingSafeEqual } from "crypto";
+var BASE_URL2 = "https://api.queuebear.com/v1/workflows";
 function serve(handler, options) {
   return async (request) => {
     let runId;
     let runToken;
-    let baseUrl;
     try {
       if (options?.signingSecret) {
         const signature = request.headers.get("X-QueueBear-Signature");
@@ -1187,15 +1157,11 @@ function serve(handler, options) {
           headers: { "Content-Type": "application/json" }
         });
       }
-      baseUrl = options?.baseUrl || getBaseUrl(request);
-      const runResponse = await fetch(
-        `${baseUrl}/v1/workflows/runs/${runId}`,
-        {
-          headers: {
-            Authorization: request.headers.get("Authorization") || ""
-          }
+      const runResponse = await fetch(`${BASE_URL2}/runs/${runId}`, {
+        headers: {
+          Authorization: request.headers.get("Authorization") || ""
         }
-      );
+      });
       if (!runResponse.ok) {
         return new Response(
           JSON.stringify({ error: "Failed to fetch workflow run" }),
@@ -1206,15 +1172,14 @@ function serve(handler, options) {
         );
       }
       const runData = await runResponse.json();
-      const context = new WorkflowContext({
+      const context = createWorkflowContext({
         runId,
         runToken,
         input: runData.input,
-        baseUrl,
         authHeader: request.headers.get("Authorization") || ""
       });
       const result = await handler(context);
-      await fetch(`${baseUrl}/v1/workflows/internal/complete`, {
+      await fetch(`${BASE_URL2}/internal/complete`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -1242,9 +1207,9 @@ function serve(handler, options) {
         );
       }
       console.error("[Workflow] Unhandled error - failing run:", error);
-      if (runId && runToken && baseUrl) {
+      if (runId && runToken) {
         try {
-          await fetch(`${baseUrl}/v1/workflows/internal/fail`, {
+          await fetch(`${BASE_URL2}/internal/fail`, {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
@@ -1275,14 +1240,11 @@ function serve(handler, options) {
 }
 function verifySignature(body, signature, secret) {
   if (!signature) return false;
-  const parts = signature.split(",").reduce(
-    (acc, part) => {
-      const [key, value] = part.split("=");
-      acc[key] = value;
-      return acc;
-    },
-    {}
-  );
+  const parts = signature.split(",").reduce((acc, part) => {
+    const [key, value] = part.split("=");
+    acc[key] = value;
+    return acc;
+  }, {});
   if (!parts.t || !parts.v1) return false;
   const timestamp = parseInt(parts.t, 10);
   const now = Math.floor(Date.now() / 1e3);
@@ -1295,10 +1257,6 @@ function verifySignature(body, signature, secret) {
     return false;
   }
 }
-function getBaseUrl(request) {
-  const url = new URL(request.url);
-  return `${url.protocol}//${url.host}`;
-}
 export {
   DLQAPI,
   MessagesAPI,
@@ -1306,8 +1264,8 @@ export {
   QueueBear,
   QueueBearError,
   SchedulesAPI,
-  WorkflowContext,
   WorkflowPausedError,
   WorkflowsAPI,
+  createWorkflowContext,
   serve
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queuebear",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "QueueBear SDK for message queues, scheduled jobs, and durable workflows",
   "type": "module",
   "main": "./dist/index.js",