@vercel/queue 0.0.0-alpha.5 → 0.0.0-alpha.7

package/README.md

@@ -46,8 +46,7 @@ type Message = {
   timestamp: number;
 };
 
-// Option 1: Using the send and receive helpers (simplest)
-// Automatically uses default client and JSON transport
+// Send a message to a topic
 await send<Message>("my-topic", {
   message: "Hello, World!",
   timestamp: Date.now(),
@@ -55,55 +54,19 @@ await send<Message>("my-topic", {
 
 // Consume a single message off the queue
 // (Often wrapped in a loop to keep polling messages off the queue)
-await receive<Message>("my-topic", "my-consumer-group", (m) => {
-  console.log(m.message);
+await receive<Message>("my-topic", "my-consumer-group", (message, metadata) => {
+  console.log("Received:", message.message);
+  console.log("Timestamp:", new Date(message.timestamp));
+  console.log("Message Metadata", metadata);
+  // => { messageId, deliveryCount, timestamp }
 });
-
-// Option 2: Using createTopic for more control
-
-import { createTopic } from "@vercel/queue";
-
-// Create a topic with JSON serialization (default)
-// Uses default QueueClient automatically authenticated from Vercel environment
-const topic = createTopic<Message>("my-topic");
-
-// Publish a message
-await topic.publish({
-  message: "Hello, World!",
-  timestamp: Date.now(),
-});
-
-// Create a consumer group
-const consumer = topic.consumerGroup("my-consumer-group");
-
-// Process next available message (one-shot processing)
-try {
-  await consumer.consume(async (message, metadata) => {
-    console.log("Received:", message.message);
-    console.log("Timestamp:", new Date(message.timestamp));
-    console.log("Message Metadata", metadata);
-    // => { messageId, deliveryCount, timestamp }
-  });
-} catch (error) {
-  console.error("Processing error:", error);
-}
-```
-
-Run the script
-
-```bash
-# Install dotenv-cli and ts-node if you need it
-npm i -g dotenv-cli ts-node typescript
-
-# Run the script with the OIDC token
-dotenv -e .env.local ts-node index.ts
 ```
 
 ## Usage with Vercel
 
 When deploying on Vercel, rather than having a persistent server subscribed to a
-queue, Vercel can trigger a callback route when a message is ready for
-consumption.
+queue, Vercel can automatically trigger your API routes when messages are ready for
+consumption based on your vercel.json configuration.
 
 To demonstrate using queues on Vercel, let's use a Next.js app. You can use an
 existing app or create one using
@@ -134,69 +97,13 @@ Create a new server function to publish messages
 import { send } from "@vercel/queue";
 
 export async function publishTestMessage(message: string) {
-  // Option 1: Using simple send shorthand
-  const { messageId } = await send(
-    "my-topic",
-    { message, timestamp: Date.now() },
-    {
-      // Provide a callback URL to invoke a consumer when the message is ready to be processed
-      callback: {
-        url: getCallbackUrl() // implementation below
-      },
-    },
-  );
-
-  console.log(`Published message ${messageId}`);
-}
-
-// Option 2: Customize the topic, transport, consumer groups, etc.
-import { createTopic } from "@vercel/queue";
-
-export async function publishTestMessage(message: string) {
-  // Create a topic with JSON serialization (default)
-  const topic = createTopic<{ message: string; timestamp: number }>("my-topic");
-
-  // Publish the message
-  const { messageId } = await topic.publish(
-    { message, timestamp: Date.now() },
-    {
-      // Provide multiple callback URLs to invoke multiple consumer groups
-      callback: {
-        {
-          "consumer-group-1": {
-            url: getCallbackUrl()
-          },
-          "consumer-group-2": {
-            url: getCallbackUrl()
-            delay: 5 // Delay callback by 5 seconds
-          },
-        }
-      },
-    },
-  );
+  const { messageId } = await send("my-topic", {
+    message,
+    timestamp: Date.now(),
+  });
 
   console.log(`Published message ${messageId}`);
 }
-
-// Helper function to generate a local callback URL
-function getCallbackUrl() {
-  const callbackUrl = new URL(
-    process.env.VERCEL_URL
-      ? `https://${process.env.VERCEL_URL}/api/queue/handle`
-      : "http://localhost:3000/api/queue/handle"
-  );
-
-  // Add Vercel automation bypass secret if available (for preview deployments)
-  if (process.env.VERCEL_AUTOMATION_BYPASS_SECRET) {
-    callbackUrl.searchParams.set(
-      "x-vercel-protection-bypass",
-      process.env.VERCEL_AUTOMATION_BYPASS_SECRET
-    );
-  }
-
-  return callbackUrl.toString();
-}
-
 ```
 
 Now wire up the server function to your app
@@ -218,86 +125,175 @@ export default function Page() {
 
 ### Consuming the queue
 
-Instead of running a persistent server that subscribes to the queue, we use the
-callback functionality of Vercel queues to consume messages on the fly, when a
-message is ready to be processed.
+Messages are consumed using consumer groups, which provide load balancing and parallel processing capabilities.
+
+## Usage with Vercel
 
-The `handleCallback` helper function simplifies queue callback handling in NextJS:
+To consume queue messages in a Vercel deployment, you need to create (Next.js) API routes and configure them in your `vercel.json` file.
+
+### 1. Create API Routes
+
+Create API routes to handle incoming queue messages using the `handleCallback` helper:
 
 ```typescript
 // app/api/queue/handle/route.ts
 import { handleCallback } from "@vercel/queue";
 
-// Option 1: Specify a single handler for the topic
+// Option 1: Single topic with multiple consumer groups
 export const POST = handleCallback({
-  "my-topic": (message, metadata) => {
-    console.log(`Received message:`, message, metadata);
-    // metadata: { messageId, deliveryCount, timestamp }
+  "my-topic": {
+    "consumer-group-1": async (message, metadata) => {
+      console.log(`Consumer group 1 processing:`, message, metadata);
+      // Handle consumer group 1 logic
+      await processGroup1(message);
+    },
+    "consumer-group-2": async (message, metadata) => {
+      console.log(`Consumer group 2 processing:`, message, metadata);
+      // Handle consumer group 2 logic
+      await processGroup2(message);
+    },
   },
-
-  // .. more topic handlers can be provided here
 });
 
-// This consumes messages on the "default" consumer group, which is used when no consumer groups
-// were specified in the publish `callback` earlierA
+async function processGroup1(message: any) {
+  // Consumer group 1 specific logic
+}
 
-// Option 2: Multiple consumer groups
+async function processGroup2(message: any) {
+  // Consumer group 2 specific logic
+}
+```
+
+```typescript
+// Alternative: Multiple topics in one handler
 export const POST = handleCallback({
-  // topic: "my-topic"
-  "my-topic": {
-    // consumer group: "compress"
-    "consumer-group-1": (message, metadata) => {
-      console.log("Message:", message);
+  "user-events": {
+    welcome: async (message, metadata) => {
+      console.log(`New user event:`, message, metadata);
+      await sendWelcomeEmail(message.email);
+    },
+  },
+  "order-events": {
+    fulfillment: async (order, metadata) => {
+      console.log(`Processing order:`, order, metadata);
+      await fulfillOrder(order);
     },
-    // consumer group: "resize"
-    "consume-group-2": (message, metadata) => {
-      console.log("Message", message);
+    analytics: async (order, metadata) => {
+      console.log(`Tracking order:`, order, metadata);
+      await trackOrder(order);
     },
   },
 });
 ```
 
-## Key Features
+### 2. Configure vercel.json
+
+Create a `vercel.json` file in your project root to declare which topics and consumer groups each API route handles:
+
+```json
+{
+  "functions": {
+    "app/api/queue/handle/route.ts": {
+      "experimentalTriggers": [
+        {
+          "type": "queue/v1beta",
+          "topic": "my-topic",
+          "consumer": "consumer-group-1"
+        },
+        {
+          "type": "queue/v1beta",
+          "topic": "my-topic",
+          "consumer": "consumer-group-2"
+        }
+      ]
+    }
+  }
+}
+```
 
-### Streaming Support
+### 3. Multiple API Routes
 
-Handle large files and data streams without loading them into memory:
+You can also create separate API routes for different topics:
 
 ```typescript
-import { createTopic, StreamTransport } from "@vercel/queue";
+// app/api/queue/users/route.ts - Handle user events
+import { handleCallback } from "@vercel/queue";
 
-const videoTopic = createTopic<ReadableStream<Uint8Array>>(
-  "video-processing",
-  new StreamTransport(),
-);
+export const POST = handleCallback({
+  "user-events": {
+    processors: async (user, metadata) => {
+      console.log(`Processing user event:`, user, metadata);
+      await sendWelcomeEmail(user.email);
+    },
+  },
+});
+```
 
-// Process large video files efficiently
-const processor = videoTopic.consumerGroup("processors");
-await processor.consume(async (videoStream) => {
-  // Process stream chunk by chunk
-  const reader = videoStream.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    await processChunk(value);
-  }
+```typescript
+// app/api/queue/orders/route.ts - Handle order events
+import { handleCallback } from "@vercel/queue";
+
+export const POST = handleCallback({
+  "order-events": {
+    fulfillment: async (order, metadata) => {
+      console.log(`Processing order:`, order, metadata);
+      await fulfillOrder(order);
+    },
+  },
 });
 ```
 
+With corresponding `vercel.json`:
+
+```json
+{
+  "functions": {
+    "app/api/queue/users/route.ts": {
+      "experimentalTriggers": [
+        {
+          "type": "queue/v1beta",
+          "topic": "user-events",
+          "consumer": "processors"
+        }
+      ]
+    },
+    "app/api/queue/orders/route.ts": {
+      "experimentalTriggers": [
+        {
+          "type": "queue/v1beta",
+          "topic": "order-events",
+          "consumer": "fulfillment"
+        }
+      ]
+    }
+  }
+}
+```
+
+### Key Points
+
+- **Automatic Triggering**: Vercel automatically triggers your API routes when messages are available for the configured topic/consumer combinations
+- **Message Processing**: Your API routes receive the message ID and other metadata via headers, then use the queue client to process the specific message
+- **Configuration Required**: The `vercel.json` file is essential - it tells Vercel which topics and consumers each route should handle
+- **No Polling**: Unlike traditional queue consumers, you don't need to poll for messages - Vercel handles the triggering automatically
+
+## Key Features
+
 ### Consumer Groups
 
 Multiple consumers can process messages from the same topic in parallel:
 
 ```typescript
 // Multiple workers in the same group - they share/split messages
-const worker1 = topic.consumerGroup("workers");
-const worker2 = topic.consumerGroup("workers"); // Same group name
-// worker1 and worker2 will receive different messages (load balancing)
+// Using the same consumer group name means they will load balance messages
+await receive("my-topic", "workers", handler1);
+await receive("my-topic", "workers", handler2);
+// handler1 and handler2 will receive different messages (load balancing)
 
 // Different consumer groups - each gets copies of ALL messages
-const analytics = topic.consumerGroup("analytics");
-const webhooks = topic.consumerGroup("webhooks");
-// analytics and webhooks will both receive every message
+await receive("my-topic", "analytics", analyticsHandler);
+await receive("my-topic", "webhooks", webhooksHandler);
+// analyticsHandler and webhooksHandler will both receive every message
 ```
 
 ## Architecture
@@ -305,8 +301,8 @@ const webhooks = topic.consumerGroup("webhooks");
 - **Topics**: Named message channels with configurable serialization
 - **Consumer Groups**: Named groups of consumers that process messages in
   parallel
-  - `consume()`: Process messages with flexible consumption patterns
-    - No options: Process next available message
+  - `receive()`: Process messages with flexible consumption patterns
+    - Basic usage: Process next available message
     - With `messageId`: Process specific message by ID
     - With `skipPayload: true`: Process message metadata only (without payload)
 - **Transports**: Pluggable serialization/deserialization for different data
@@ -328,8 +324,7 @@ The multipart parser is optimized for high-throughput scenarios:
 
 The queue client supports customizable serialization through the `Transport`
 interface with **streaming support** for memory-efficient processing. Transport
-can be configured at the **topic level** when creating a topic, or at the
-**consumer group level** when creating a consumer group.
+can be configured using the `transport` option when calling `send()` or `receive()`.
 
 ### Built-in Transports
 
@@ -339,11 +334,15 @@ Buffers data for JSON parsing - suitable for structured data that fits in
 memory.
 
 ```typescript
-import { createTopic, JsonTransport } from "@vercel/queue";
-
-const topic = createTopic<{ data: any }>("json-topic", new JsonTransport());
-// or simply (JsonTransport is the default):
-const topic = createTopic<{ data: any }>("json-topic");
+import { send, JsonTransport } from "@vercel/queue";
+
+// JsonTransport is the default, so these are equivalent:
+await send("json-topic", { data: "example" });
+await send(
+  "json-topic",
+  { data: "example" },
+  { transport: new JsonTransport() },
+);
 ```
 
 #### BufferTransport
@@ -351,55 +350,15 @@ const topic = createTopic<{ data: any }>("json-topic");
 Buffers the entire payload into memory as a Buffer - suitable for binary data
 that fits in memory.
 
-```typescript
-import { BufferTransport, createTopic } from "@vercel/queue";
-
-const topic = createTopic<Buffer>("binary-topic", new BufferTransport());
-const binaryData = Buffer.from("Binary data", "utf8");
-await topic.publish(binaryData);
-```
-
 #### StreamTransport
 
 **True streaming support** - passes ReadableStream directly without buffering.
 Ideal for large files and memory-efficient processing.
 
-```typescript
-import { createTopic, StreamTransport } from "@vercel/queue";
-
-const topic = createTopic<ReadableStream<Uint8Array>>(
-  "streaming-topic",
-  new StreamTransport(),
-);
-
-// Send large file as stream without loading into memory
-const fileStream = new ReadableStream<Uint8Array>({
-  start(controller) {
-    // Read file in chunks
-    for (const chunk of readFileInChunks("large-file.bin")) {
-      controller.enqueue(chunk);
-    }
-    controller.close();
-  },
-});
-
-await topic.publish(fileStream);
-```
-
 ### Custom Transport
 
 You can create your own serialization format by implementing the `Transport`
-interface:
-
-```typescript
-import { Transport } from "@vercel/queue";
-
-interface Transport<T = unknown> {
-  serialize(value: T): Buffer | ReadableStream<Uint8Array>;
-  deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
-  contentType: string;
-}
-```
+interface.
 
 ### Choosing the Right Transport
 
@@ -413,52 +372,7 @@ interface Transport<T = unknown> {
 
 ## API Reference
 
-### QueueClient
-
-```typescript
-// Simple usage - automatically gets OIDC token from Vercel environment
-const client = new QueueClient();
-
-// Or with options
-const client = new QueueClient({
-  token?: string; // Optional - will auto-detect if not provided
-  baseUrl?: string; // defaults to 'https://vqs.vercel.sh'
-});
-```
-
-### Topic
-
-```typescript
-// Simple usage with default client
-const topic = createTopic<T>(topicName, transport?);
-
-// For custom client configuration, use Topic constructor directly
-const customClient = new QueueClient({ baseUrl: "https://custom.vqs.vercel.sh" });
-const topic = new Topic<T>(customClient, topicName, transport?);
-
-// Publish a message (uses topic's transport)
-await topic.publish(payload, options?);
-
-// Trigger a callback URL when the message is
-// ready for consumption
-await topic.publish(payload, {
-  callback: { url: "https://example.com/webhook" }
-});
-
-// Or provide multiple callbacks (each URL is called
-// with a separate consumer group)
-await topic.publish(payload, {
-  callback: {
-    group1: { url: "https://example.com/webhook1" },
-    group2: { url: "https://example.com/webhook2", delay: 30 }
-  }
-});
-
-// Create a consumer group (can override transport)
-const consumer = topic.consumerGroup<U>(groupName, options?);
-```
-
-### Send (Shorthand)
+### Send Function
 
 ```typescript
 // Simple send - automatically uses default client and JSON transport
@@ -469,7 +383,6 @@ await send<T>(topicName, payload, {
   transport?: Transport<T>;
   idempotencyKey?: string;
   retentionSeconds?: number;
-  callback?: Record<string, CallbackConfig> | CallbackConfig;
 });
 
 // Examples:
@@ -477,31 +390,31 @@ await send("notifications", { userId: "123", message: "Welcome!" });
 
 await send("images", imageBuffer, {
   transport: new BufferTransport(),
-  callback: { url: "https://example.com/process-image" }
 });
 
 await send("events", eventData, {
   idempotencyKey: "unique-key-123",
   retentionSeconds: 3600,
-  callback: {
-    analytics: { url: "https://analytics.example.com/webhook" },
-    notifications: { url: "https://notifications.example.com/webhook", delay: 30 }
-  }
 });
 ```
 
-### ConsumerGroup
+### Receive Function
 
 ```typescript
 // Process next available message (simplest form)
-await consumer.consume(handler);
+await receive("topic-name", "consumer-group", handler);
 
 // Process specific message by ID with payload
-await consumer.consume(handler, { messageId: "message-id" });
+await receive("topic-name", "consumer-group", handler, {
+  messageId: "message-id",
+});
 
 // Process specific message by ID without payload (metadata only)
 // handler will be called with `undefined` as the payload
-await consumer.consume(handler, { messageId: "message-id", skipPayload: true });
+await receive("topic-name", "consumer-group", handler, {
+  messageId: "message-id",
+  skipPayload: true,
+});
 ```
 
 ### Message Handler
@@ -528,12 +441,16 @@ interface MessageMetadata {
 }
 ```
 
-### ConsumeOptions Interface
+### Receive Options
 
 ```typescript
-interface ConsumeOptions {
+// Options for the receive function
+interface ReceiveOptions<T = unknown> {
   messageId?: string; // Process specific message by ID
   skipPayload?: boolean; // Skip payload download (requires messageId)
+  transport?: Transport<T>; // Custom transport (defaults to JsonTransport)
+  visibilityTimeoutSeconds?: number; // Message visibility timeout
+  refreshInterval?: number; // Refresh interval for long-running operations
 }
 ```
 
@@ -547,44 +464,33 @@ interface Transport<T = unknown> {
 }
 ```
 
-### Callback Utilities
+### Callback Handler
 
 ```typescript
-// Parse queue callback request headers
-function parseCallbackRequest(request: Request): CallbackMessageOptions;
+// Create a callback handler for Next.js route handlers
+function handleCallback(
+  handlers: CallbackHandlers,
+): (request: Request) => Promise<Response>;
 
-// Callback options type
-interface CallbackMessageOptions {
-  queueName: string;
-  consumerGroup: string;
-  messageId: string;
-}
-// Create a callback handler for NextJS route handlers
-function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
-
-// Configuration object with handlers for different topics
+// Configuration object with handlers for different topics and consumer groups
 type CallbackHandlers = {
-  [topicName: string]:
-    | MessageHandler // Single handler (uses 'default' consumer group)
-    | { [consumerGroup: string]: MessageHandler }; // Multiple consumer group handlers
+  [topicName: string]: { [consumerGroup: string]: MessageHandler };
 };
 
 // Example usage:
 export const POST = handleCallback({
-  // Topic handler (uses 'default' consumer group)
-  "new-users": (message, metadata) => {
-    console.log(`New user event:`, message, metadata);
+  "user-events": {
+    welcome: (message, metadata) => {
+      console.log(`New user event:`, message, metadata);
+    },
   },
 
-  // Consumer group specific handlers
+  // Multiple consumer groups per topic
   "image-processing": {
-    "compress": (message, metadata) => console.log("Compressing image", message),
-    "resize": (message, metadata) => console.log("Resizing image", message),
-  }
+    compress: (message, metadata) => console.log("Compressing image", message),
+    resize: (message, metadata) => console.log("Resizing image", message),
+  },
 });
-
-// Error thrown for invalid callback requests
-class InvalidCallbackError extends Error;
 ```
 
 ## Examples
@@ -598,27 +504,16 @@ interface UserEvent {
   timestamp: number;
 }
 
-// Option 1: Using send shorthand
+// Send a message
 await send<UserEvent>("user-events", {
   userId: "123",
   action: "login",
   timestamp: Date.now(),
 });
 
-// Option 2: Using createTopic for consumers
-const userTopic = createTopic<UserEvent>("user-events");
-
-await userTopic.publish({
-  userId: "123",
-  action: "login",
-  timestamp: Date.now(),
-});
-
-const consumer = userTopic.consumerGroup("processors");
-
-// Process next available message
+// Receive and process a message
 try {
-  await consumer.consume(async (message) => {
+  await receive<UserEvent>("user-events", "processors", async (message) => {
     console.log(`User ${message.userId} performed ${message.action}`);
   });
 } catch (error) {
@@ -629,16 +524,13 @@ try {
 ### Processing Specific Messages by ID
 
 ```typescript
-const userTopic = createTopic<{ userId: string; action: string }>(
-  "user-events",
-);
-const consumer = userTopic.consumerGroup("processors");
-
 // Process a specific message if you know its ID
 const messageId = "01234567-89ab-cdef-0123-456789abcdef";
 
 try {
-  await consumer.consume(
+  await receive<{ userId: string; action: string }>(
+    "user-events",
+    "processors",
     async (message, { messageId }) => {
       console.log(`Processing specific message: ${messageId}`);
       console.log(`User ${message.userId} performed ${message.action}`);
@@ -649,8 +541,6 @@ try {
 } catch (error) {
   if (error.message.includes("not found or not available")) {
     console.log("Message was already processed or does not exist");
-  } else if (error.message.includes("FIFO ordering violation")) {
-    console.log("FIFO queue requires processing messages in order");
   } else {
     console.error("Error processing message:", error);
   }
@@ -660,21 +550,22 @@ try {
 ### Processing Next Available Message
 
 ```typescript
-const workTopic = createTopic<{ taskType: string; data: any }>("work-queue");
-const worker = workTopic.consumerGroup("workers");
-
 // Process the next available message (one-shot processing)
 try {
-  await worker.consume(async (message) => {
-    console.log(`Processing task: ${message.taskType}`);
-    await processTask(message.taskType, message.data);
-  });
+  await receive<{ taskType: string; data: any }>(
+    "work-queue",
+    "workers",
+    async (message) => {
+      console.log(`Processing task: ${message.taskType}`);
+      await processTask(message.taskType, message.data);
+    },
+  );
   console.log("Message processed successfully");
 } catch (error) {
   if (error instanceof QueueEmptyError) {
     console.log("No messages available");
   } else if (error instanceof MessageLockedError) {
-    console.log("Next message is locked (FIFO queue)");
+    console.log("Next message is locked");
     if (error.retryAfter) {
       console.log(`Retry after ${error.retryAfter} seconds`);
     }
@@ -684,17 +575,23 @@ try {
 }
 
 // Handle conditional timeouts
-await worker.consume(async (message) => {
-  if (!canProcessTaskType(message.taskType)) {
-    // Return timeout to retry later
-    return { timeoutSeconds: 60 };
-  }
+await receive<{ taskType: string; data: any }>(
+  "work-queue",
+  "workers",
+  async (message) => {
+    if (!canProcessTaskType(message.taskType)) {
+      // Return timeout to retry later
+      return { timeoutSeconds: 60 };
+    }
 
-  await processTask(message.taskType, message.data);
-});
+    await processTask(message.taskType, message.data);
+  },
+);
 
 // Process specific message metadata only (no payload download)
-await worker.consume(
+await receive<{ taskType: string; data: any }>(
+  "work-queue",
+  "workers",
   async (_, metadata) => {
     console.log(`Message ID: ${metadata.messageId}`);
     console.log(`Delivery count: ${metadata.deliveryCount}`);
@@ -708,172 +605,69 @@ await worker.consume(
 ### Timing Out Messages
 
 ```typescript
-const workTopic = createTopic<{ taskType: string; data: any }>("work-queue");
-const worker = workTopic.consumerGroup("workers");
-
 // Process a message with conditional timeout
 try {
-  await worker.consume(async ({ taskType, data }) => {
-    // Check if we can process this task type right now
-    if (taskType === "heavy-computation" && isSystemOverloaded()) {
-      // Return timeout to retry later (5 minutes)
-      return { timeoutSeconds: 300 };
-    }
+  await receive<{ taskType: string; data: any }>(
+    "work-queue",
+    "workers",
+    async ({ taskType, data }) => {
+      // Check if we can process this task type right now
+      if (taskType === "heavy-computation" && isSystemOverloaded()) {
+        // Return timeout to retry later (5 minutes)
+        return { timeoutSeconds: 300 };
+      }
 
-    // Check if we have required resources
-    if (taskType === "external-api" && !isExternalServiceAvailable()) {
-      // Return timeout to retry in 1 minute
-      return { timeoutSeconds: 60 };
-    }
+      // Check if we have required resources
+      if (taskType === "external-api" && !isExternalServiceAvailable()) {
+        // Return timeout to retry in 1 minute
+        return { timeoutSeconds: 60 };
+      }
 
-    // Process the message normally
-    console.log(`Processing ${taskType} task`);
-    await processTask(taskType, data);
-    // Message will be automatically deleted on successful completion
-  });
+      // Process the message normally
+      console.log(`Processing ${taskType} task`);
+      await processTask(taskType, data);
+      // Message will be automatically deleted on successful completion
+    },
+  );
 } catch (error) {
   console.error("Worker processing error:", error);
 }
 
 // Example with exponential backoff
 try {
-  await worker.consume(async (message, { deliveryCount }) => {
-    const maxRetries = 3;
-
-    try {
-      await processMessage(message);
-      // Successful processing - message will be deleted
-    } catch (error) {
-      if (deliveryCount < maxRetries) {
-        // Exponential backoff: 2^deliveryCount minutes
-        const timeoutSeconds = Math.pow(2, deliveryCount) * 60;
-        console.log(
-          `Retrying message in ${timeoutSeconds} seconds (attempt ${deliveryCount})`,
-        );
-        return { timeoutSeconds: timeoutSeconds };
-      } else {
-        // Max retries reached, let the message fail and be deleted
-        console.error("Max retries reached, message will be discarded:", error);
-        throw error;
+  await receive<{ taskType: string; data: any }>(
+    "work-queue",
+    "workers",
+    async (message, { deliveryCount }) => {
+      const maxRetries = 3;
+
+      try {
+        await processMessage(message);
+        // Successful processing - message will be deleted
+      } catch (error) {
+        if (deliveryCount < maxRetries) {
+          // Exponential backoff: 2^deliveryCount minutes
+          const timeoutSeconds = Math.pow(2, deliveryCount) * 60;
+          console.log(
+            `Retrying message in ${timeoutSeconds} seconds (attempt ${deliveryCount})`,
+          );
+          return { timeoutSeconds: timeoutSeconds };
+        } else {
+          // Max retries reached, let the message fail and be deleted
+          console.error(
+            "Max retries reached, message will be discarded:",
+            error,
+          );
+          throw error;
+        }
       }
-    }
-  });
+    },
+  );
 } catch (error) {
   console.error("Backoff processing error:", error);
 }
 ```
 
-### Complete Example: Video Processing Pipeline
-
-Here's a comprehensive example showing a video processing pipeline that
-processes videos with FFmpeg and stores the results in Vercel Blob:
-
-```typescript
-import { createTopic, StreamTransport } from "@vercel/queue";
-import { spawn } from "child_process";
-import ffmpeg from "ffmpeg-static";
-import { put } from "@vercel/blob";
-
-// Input topic with unoptimized videos
-const unoptimizedVideosTopic = createTopic<ReadableStream<Uint8Array>>(
-  "unoptimized-videos",
-  new StreamTransport(),
-);
-
-// Output topic for optimized videos
-const optimizedVideosTopic = createTopic<ReadableStream<Uint8Array>>(
-  "optimized-videos",
-  new StreamTransport(),
-);
-
-// Step 1: Process videos with FFmpeg
-const videoProcessor = unoptimizedVideosTopic.consumerGroup("processors");
-
-try {
-  await videoProcessor.consume(async (inputVideoStream) => {
-    console.log("Processing video...");
-
-    if (!ffmpeg) {
-      throw new Error("FFmpeg not available");
-    }
-
-    // Create optimized video stream using FFmpeg
-    const optimizedStream = new ReadableStream<Uint8Array>({
-      start(controller) {
-        const ffmpegProcess = spawn(
-          ffmpeg,
-          [
-            "-i",
-            "pipe:0", // Input from stdin
-            "-c:v",
-            "libvpx-vp9", // Video codec
-            "-c:a",
-            "libopus", // Audio codec
-            "-crf",
-            "23", // Quality
-            "-f",
-            "webm", // Output format
-            "pipe:1", // Output to stdout
-          ],
-          { stdio: ["pipe", "pipe", "pipe"] },
-        );
-
-        // Pipe input stream to FFmpeg
-        const reader = inputVideoStream.getReader();
-        const pipeInput = async () => {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              ffmpegProcess.stdin?.end();
-              break;
-            }
-            ffmpegProcess.stdin?.write(value);
-          }
-        };
-        pipeInput();
-
-        // Stream FFmpeg output
-        ffmpegProcess.stdout?.on("data", (chunk) => {
-          controller.enqueue(new Uint8Array(chunk));
-        });
-
-        ffmpegProcess.on("close", (code) => {
-          if (code === 0) {
-            controller.close();
-          } else {
-            controller.error(new Error(`FFmpeg failed with code ${code}`));
-          }
-        });
-      },
-    });
-
-    // Publish optimized video to next topic
-    await optimizedVideosTopic.publish(optimizedStream);
-    console.log("Video optimized and published");
-  });
-} catch (error) {
-  console.error("Video processing error:", error);
-}
-
-// Step 2: Store optimized videos in Vercel Blob
-const blobUploader = optimizedVideosTopic.consumerGroup("blob-uploaders");
-
-try {
-  await blobUploader.consume(async (optimizedVideo) => {
-    // Upload to Vercel Blob storage
-    const filename = `optimized-${Date.now()}.webm`;
-    const blob = await put(filename, optimizedVideo, {
-      access: "public",
-      contentType: "video/webm",
-    });
-
-    console.log(`Video uploaded to blob: ${blob.url} (${blob.size} bytes)`);
-  });
-} catch (error) {
-  console.error("Blob upload error:", error);
-}
-```
-
 ## Error Handling
 
 The queue client provides specific error types for different failure scenarios:
@@ -883,39 +677,25 @@ The queue client provides specific error types for different failure scenarios:
 - **`QueueEmptyError`**: Thrown when attempting to receive messages from an
   empty queue (204 status)
 
-  - Thrown by `consume()` when no messages are available
-  - Also thrown when directly using `client.receiveMessages()`
+  - Thrown by `receive()` when no messages are available
 
 - **`MessageLockedError`**: Thrown when a message is temporarily locked (423
   status)
 
   - Contains optional `retryAfter` property with seconds to wait before retry
-  - For `consume()` without options: the next message in FIFO sequence is locked
-  - For `consume()` with messageId: the requested message is locked
+  - For `receive()` without options: the next message is locked
+  - For `receive()` with messageId: the requested message is locked
 
 - **`MessageNotFoundError`**: Message doesn't exist (404 status)
 
 - **`MessageNotAvailableError`**: Message exists but isn't available for
   processing (409 status)
 
-- **`FifoOrderingViolationError`**: FIFO queue ordering violation (409 status
-  with nextMessageId)
-
-  - Contains `nextMessageId` property indicating which message to process first
-
-- **`FailedDependencyError`**: FIFO ordering violation when receiving by ID (424
-  status)
-
-  - Contains `nextMessageId` property indicating which message must be processed
-    first
-  - Similar to `FifoOrderingViolationError` but specifically for receive-by-ID
-    operations
-
 - **`MessageCorruptedError`**: Message data is corrupted or can't be parsed
 
 - **`BadRequestError`**: Invalid request parameters (400 status)
 
-  - Invalid queue names, FIFO limit violations, missing required parameters
+  - Invalid queue names, missing required parameters
 
 - **`UnauthorizedError`**: Authentication failure (401 status)
 
@@ -933,8 +713,6 @@ The queue client provides specific error types for different failure scenarios:
 ```typescript
 import {
   BadRequestError,
-  FailedDependencyError,
-  FifoOrderingViolationError,
   ForbiddenError,
   InternalServerError,
   MessageLockedError,
@@ -944,14 +722,15 @@ import {
 
 // Handle empty queue or locked messages
 try {
-  for await (const message of client.receiveMessages(options, transport)) {
-    // Process messages
-  }
+  await receive("my-topic", "my-consumer", async (message) => {
+    // Process message
+    console.log("Processing message:", message);
+  });
 } catch (error) {
   if (error instanceof QueueEmptyError) {
     console.log("Queue is empty, retry later");
   } else if (error instanceof MessageLockedError) {
-    console.log("Next message in FIFO queue is locked");
+    console.log("Next message is locked");
     if (error.retryAfter) {
       console.log(`Retry after ${error.retryAfter} seconds`);
     }
@@ -960,7 +739,7 @@ try {
 
 // Handle locked message with retry
 try {
-  await consumer.consume(handler, { messageId });
+  await receive("my-topic", "my-consumer", handler, { messageId });
 } catch (error) {
   if (error instanceof MessageLockedError) {
     console.log("Message is locked by another consumer");
@@ -968,15 +747,12 @@ try {
       console.log(`Retry after ${error.retryAfter} seconds`);
       setTimeout(() => retry(), error.retryAfter * 1000);
     }
-  } else if (error instanceof FailedDependencyError) {
-    // FIFO ordering violation for receive by ID
-    console.log(`Must process ${error.nextMessageId} first`);
   }
 }
 
 // Handle authentication and authorization errors
 try {
-  await topic.publish(payload);
+  await send("my-topic", payload);
 } catch (error) {
   if (error instanceof UnauthorizedError) {
     console.log("Invalid token - refresh authentication");