queuebear 0.1.3 → 0.1.5

package/README.md

@@ -491,6 +491,76 @@ The signing secret is available in your QueueBear project settings. When configu
 
 ---
 
+## Local Development
+
+When developing locally, your webhook endpoints run on `localhost` which isn't accessible from QueueBear's servers. Use a tunnel service to expose your local server.
+
+### Using ngrok (Recommended)
+
+[ngrok](https://ngrok.com) provides stable URLs and a built-in request inspector.
+
+**1. Install and authenticate:**
+
+```bash
+# Install
+brew install ngrok  # or download from ngrok.com/download
+
+# Authenticate (free account required)
+ngrok config add-authtoken YOUR_AUTH_TOKEN
+```
+
+**2. Start the tunnel:**
+
+```bash
+ngrok http 3000
+```
+
+**3. Use the forwarding URL:**
+
+```typescript
+// Use ngrok URL instead of localhost
+await qb.messages.publish("https://abc123.ngrok.io/api/webhooks", {
+  event: "user.created",
+  userId: "123"
+});
+
+// Works for workflows too
+await qb.workflows.trigger(
+  "onboarding",
+  "https://abc123.ngrok.io/api/workflows/onboarding",
+  { userId: "123" }
+);
+```
+
+**Debugging:** ngrok provides a web inspector at `http://localhost:4040` to view requests, responses, and replay failed deliveries.
+
+### Using localtunnel
+
+[localtunnel](https://localtunnel.me) is free and requires no signup.
+
+```bash
+npx localtunnel --port 3000
+# Output: your url is: https://good-months-leave.loca.lt
+```
+
+**Note:** localtunnel shows a reminder page on first visit. Bypass it by adding a header:
+
+```typescript
+await qb.messages.publish(
+  "https://good-months-leave.loca.lt/api/webhooks",
+  { event: "test" },
+  { headers: { "bypass-tunnel-reminder": "true" } }
+);
+```
+
+### Tips
+
+- Store your tunnel URL in `.env` for easy switching between local and production
+- Both `callbackUrl` and `failureCallbackUrl` need public URLs for local testing
+- ngrok URLs change on restart (stable URLs require a paid plan)
+
+---
+
 ## License
 
 MIT

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);
@@ -113,7 +111,6 @@ interface StepRetryOptions {
  * Options for serve() function
  */
 interface ServeOptions {
-    baseUrl?: string;
     retries?: number;
     signingSecret?: string;
 }
@@ -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"
+      }
     });
   }
   /**
@@ -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.3",
+  "version": "0.1.5",
   "description": "QueueBear SDK for message queues, scheduled jobs, and durable workflows",
   "type": "module",
   "main": "./dist/index.js",