orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/@ai-sdk/gateway/dist/index.mjs

@@ -18,12 +18,14 @@ var GatewayError = class _GatewayError extends (_b = Error, _a = symbol, _b) {
   constructor({
     message,
     statusCode = 500,
-    cause
+    cause,
+    generationId
   }) {
-    super(message);
+    super(generationId ? `${message} [${generationId}]` : message);
     this[_a] = true;
     this.statusCode = statusCode;
     this.cause = cause;
+    this.generationId = generationId;
   }
   /**
    * Checks if the given error is a Gateway Error.
@@ -47,9 +49,10 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
   constructor({
     message = "Authentication failed",
     statusCode = 401,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a2] = true;
     // used in isInstance
     this.name = name;
@@ -66,7 +69,8 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
     oidcTokenProvided,
     message = "Authentication failed",
     statusCode = 401,
-    cause
+    cause,
+    generationId
   }) {
     let contextualMessage;
     if (apiKeyProvided) {
@@ -94,7 +98,8 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
     return new _GatewayAuthenticationError({
       message: contextualMessage,
       statusCode,
-      cause
+      cause,
+      generationId
     });
   }
 };
@@ -108,9 +113,10 @@ var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a3 = symbol
   constructor({
     message = "Invalid request",
     statusCode = 400,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a3] = true;
     // used in isInstance
     this.name = name2;
@@ -130,9 +136,10 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b
   constructor({
     message = "Rate limit exceeded",
     statusCode = 429,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a4] = true;
     // used in isInstance
     this.name = name3;
@@ -162,9 +169,10 @@ var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a5 = symbol5
     message = "Model not found",
     statusCode = 404,
     modelId,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a5] = true;
     // used in isInstance
     this.name = name4;
@@ -185,9 +193,10 @@ var GatewayInternalServerError = class extends (_b6 = GatewayError, _a6 = symbol
   constructor({
     message = "Internal server error",
     statusCode = 500,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a6] = true;
     // used in isInstance
     this.name = name5;
@@ -209,9 +218,10 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7
     statusCode = 502,
     response,
     validationError,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a7] = true;
     // used in isInstance
     this.name = name6;
@@ -237,34 +247,49 @@ async function createGatewayErrorFromResponse({
   cause,
   authMethod
 }) {
+  var _a9;
   const parseResult = await safeValidateTypes({
     value: response,
     schema: gatewayErrorResponseSchema
   });
   if (!parseResult.success) {
+    const rawGenerationId = typeof response === "object" && response !== null && "generationId" in response ? response.generationId : void 0;
     return new GatewayResponseError({
       message: `Invalid error response format: ${defaultMessage}`,
       statusCode,
       response,
       validationError: parseResult.error,
-      cause
+      cause,
+      generationId: rawGenerationId
     });
   }
   const validatedResponse = parseResult.value;
   const errorType = validatedResponse.error.type;
   const message = validatedResponse.error.message;
+  const generationId = (_a9 = validatedResponse.generationId) != null ? _a9 : void 0;
   switch (errorType) {
     case "authentication_error":
       return GatewayAuthenticationError.createContextualError({
         apiKeyProvided: authMethod === "api-key",
         oidcTokenProvided: authMethod === "oidc",
         statusCode,
-        cause
+        cause,
+        generationId
       });
     case "invalid_request_error":
-      return new GatewayInvalidRequestError({ message, statusCode, cause });
+      return new GatewayInvalidRequestError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     case "rate_limit_exceeded":
-      return new GatewayRateLimitError({ message, statusCode, cause });
+      return new GatewayRateLimitError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     case "model_not_found": {
       const modelResult = await safeValidateTypes({
         value: validatedResponse.error.param,
@@ -274,13 +299,24 @@ async function createGatewayErrorFromResponse({
         message,
         statusCode,
         modelId: modelResult.success ? modelResult.value.modelId : void 0,
-        cause
+        cause,
+        generationId
       });
     }
     case "internal_server_error":
-      return new GatewayInternalServerError({ message, statusCode, cause });
+      return new GatewayInternalServerError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     default:
-      return new GatewayInternalServerError({ message, statusCode, cause });
+      return new GatewayInternalServerError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
   }
 }
 var gatewayErrorResponseSchema = lazySchema2(
@@ -291,27 +327,97 @@ var gatewayErrorResponseSchema = lazySchema2(
         type: z2.string().nullish(),
         param: z2.unknown().nullish(),
         code: z2.union([z2.string(), z2.number()]).nullish()
-      })
+      }),
+      generationId: z2.string().nullish()
     })
   )
 );
 
+// src/errors/gateway-timeout-error.ts
+var name7 = "GatewayTimeoutError";
+var marker8 = `vercel.ai.gateway.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8, _b8;
+var GatewayTimeoutError = class _GatewayTimeoutError extends (_b8 = GatewayError, _a8 = symbol8, _b8) {
+  constructor({
+    message = "Request timed out",
+    statusCode = 408,
+    cause,
+    generationId
+  } = {}) {
+    super({ message, statusCode, cause, generationId });
+    this[_a8] = true;
+    // used in isInstance
+    this.name = name7;
+    this.type = "timeout_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol8 in error;
+  }
+  /**
+   * Creates a helpful timeout error message with troubleshooting guidance
+   */
+  static createTimeoutError({
+    originalMessage,
+    statusCode = 408,
+    cause,
+    generationId
+  }) {
+    const message = `Gateway request timed out: ${originalMessage}
+
+    This is a client-side timeout. To resolve this, increase your timeout configuration: https://vercel.com/docs/ai-gateway/capabilities/video-generation#extending-timeouts-for-node.js`;
+    return new _GatewayTimeoutError({
+      message,
+      statusCode,
+      cause,
+      generationId
+    });
+  }
+};
+
 // src/errors/as-gateway-error.ts
-function asGatewayError(error, authMethod) {
-  var _a8;
+function isTimeoutError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const errorCode = error.code;
+  if (typeof errorCode === "string") {
+    const undiciTimeoutCodes = [
+      "UND_ERR_HEADERS_TIMEOUT",
+      "UND_ERR_BODY_TIMEOUT",
+      "UND_ERR_CONNECT_TIMEOUT"
+    ];
+    return undiciTimeoutCodes.includes(errorCode);
+  }
+  return false;
+}
+async function asGatewayError(error, authMethod) {
+  var _a9;
   if (GatewayError.isInstance(error)) {
     return error;
   }
+  if (isTimeoutError(error)) {
+    return GatewayTimeoutError.createTimeoutError({
+      originalMessage: error instanceof Error ? error.message : "Unknown error",
+      cause: error
+    });
+  }
   if (APICallError.isInstance(error)) {
-    return createGatewayErrorFromResponse({
+    if (error.cause && isTimeoutError(error.cause)) {
+      return GatewayTimeoutError.createTimeoutError({
+        originalMessage: error.message,
+        cause: error
+      });
+    }
+    return await createGatewayErrorFromResponse({
       response: extractApiCallResponse(error),
-      statusCode: (_a8 = error.statusCode) != null ? _a8 : 500,
+      statusCode: (_a9 = error.statusCode) != null ? _a9 : 500,
       defaultMessage: "Gateway request failed",
       cause: error,
       authMethod
     });
   }
-  return createGatewayErrorFromResponse({
+  return await createGatewayErrorFromResponse({
     response: {},
     statusCode: 500,
     defaultMessage: error instanceof Error ? `Gateway request failed: ${error.message}` : "Unknown Gateway error",
@@ -434,7 +540,7 @@ var gatewayAvailableModelsResponseSchema = lazySchema4(
             provider: z4.string(),
             modelId: z4.string()
           }),
-          modelType: z4.enum(["language", "embedding", "image"]).nullish()
+          modelType: z4.enum(["embedding", "image", "language", "video"]).nullish()
         })
       )
     })
@@ -636,7 +742,7 @@ var GatewayEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a8;
+    var _a9;
     const resolvedHeaders = await resolve3(this.config.headers());
     try {
       const {
@@ -667,7 +773,7 @@ var GatewayEmbeddingModel = class {
       });
       return {
         embeddings: responseBody.embeddings,
-        usage: (_a8 = responseBody.usage) != null ? _a8 : void 0,
+        usage: (_a9 = responseBody.usage) != null ? _a9 : void 0,
         providerMetadata: responseBody.providerMetadata,
         response: { headers: responseHeaders, body: rawValue },
         warnings: []
@@ -729,7 +835,7 @@ var GatewayImageModel = class {
     headers,
     abortSignal
   }) {
-    var _a8;
+    var _a9, _b9, _c, _d;
     const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const {
@@ -769,16 +875,23 @@ var GatewayImageModel = class {
       return {
         images: responseBody.images,
         // Always base64 strings from server
-        warnings: (_a8 = responseBody.warnings) != null ? _a8 : [],
+        warnings: (_a9 = responseBody.warnings) != null ? _a9 : [],
         providerMetadata: responseBody.providerMetadata,
         response: {
           timestamp: /* @__PURE__ */ new Date(),
           modelId: this.modelId,
           headers: responseHeaders
+        },
+        ...responseBody.usage != null && {
+          usage: {
+            inputTokens: (_b9 = responseBody.usage.inputTokens) != null ? _b9 : void 0,
+            outputTokens: (_c = responseBody.usage.outputTokens) != null ? _c : void 0,
+            totalTokens: (_d = responseBody.usage.totalTokens) != null ? _d : void 0
+          }
         }
       };
     } catch (error) {
-      throw asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   getUrl() {
@@ -803,90 +916,407 @@ function maybeEncodeImageFile(file) {
 var providerMetadataEntrySchema = z7.object({
   images: z7.array(z7.unknown()).optional()
 }).catchall(z7.unknown());
+var gatewayImageWarningSchema = z7.discriminatedUnion("type", [
+  z7.object({
+    type: z7.literal("unsupported"),
+    feature: z7.string(),
+    details: z7.string().optional()
+  }),
+  z7.object({
+    type: z7.literal("compatibility"),
+    feature: z7.string(),
+    details: z7.string().optional()
+  }),
+  z7.object({
+    type: z7.literal("other"),
+    message: z7.string()
+  })
+]);
+var gatewayImageUsageSchema = z7.object({
+  inputTokens: z7.number().nullish(),
+  outputTokens: z7.number().nullish(),
+  totalTokens: z7.number().nullish()
+});
 var gatewayImageResponseSchema = z7.object({
   images: z7.array(z7.string()),
   // Always base64 strings over the wire
-  warnings: z7.array(
-    z7.object({
-      type: z7.literal("other"),
-      message: z7.string()
-    })
-  ).optional(),
-  providerMetadata: z7.record(z7.string(), providerMetadataEntrySchema).optional()
+  warnings: z7.array(gatewayImageWarningSchema).optional(),
+  providerMetadata: z7.record(z7.string(), providerMetadataEntrySchema).optional(),
+  usage: gatewayImageUsageSchema.optional()
 });
 
-// src/tool/perplexity-search.ts
+// src/gateway-video-model.ts
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler5,
+  parseJsonEventStream,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve5
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var GatewayVideoModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    // Set a very large number to prevent client-side splitting of requests
+    this.maxVideosPerCall = Number.MAX_SAFE_INTEGER;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    aspectRatio,
+    resolution,
+    duration,
+    fps,
+    seed,
+    image,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a9;
+    const resolvedHeaders = await resolve5(this.config.headers());
+    try {
+      const { responseHeaders, value: responseBody } = await postJsonToApi4({
+        url: this.getUrl(),
+        headers: combineHeaders4(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve5(this.config.o11yHeaders),
+          { accept: "text/event-stream" }
+        ),
+        body: {
+          prompt,
+          n,
+          ...aspectRatio && { aspectRatio },
+          ...resolution && { resolution },
+          ...duration && { duration },
+          ...fps && { fps },
+          ...seed && { seed },
+          ...providerOptions && { providerOptions },
+          ...image && { image: maybeEncodeVideoFile(image) }
+        },
+        successfulResponseHandler: async ({
+          response,
+          url,
+          requestBodyValues
+        }) => {
+          if (response.body == null) {
+            throw new APICallError2({
+              message: "SSE response body is empty",
+              url,
+              requestBodyValues,
+              statusCode: response.status
+            });
+          }
+          const eventStream = parseJsonEventStream({
+            stream: response.body,
+            schema: gatewayVideoEventSchema
+          });
+          const reader = eventStream.getReader();
+          const { done, value: parseResult } = await reader.read();
+          reader.releaseLock();
+          if (done || !parseResult) {
+            throw new APICallError2({
+              message: "SSE stream ended without a data event",
+              url,
+              requestBodyValues,
+              statusCode: response.status
+            });
+          }
+          if (!parseResult.success) {
+            throw new APICallError2({
+              message: "Failed to parse video SSE event",
+              cause: parseResult.error,
+              url,
+              requestBodyValues,
+              statusCode: response.status
+            });
+          }
+          const event = parseResult.value;
+          if (event.type === "error") {
+            throw new APICallError2({
+              message: event.message,
+              statusCode: event.statusCode,
+              url,
+              requestBodyValues,
+              responseHeaders: Object.fromEntries([...response.headers]),
+              responseBody: JSON.stringify(event),
+              data: {
+                error: {
+                  message: event.message,
+                  type: event.errorType,
+                  param: event.param
+                }
+              }
+            });
+          }
+          return {
+            value: {
+              videos: event.videos,
+              warnings: event.warnings,
+              providerMetadata: event.providerMetadata
+            },
+            responseHeaders: Object.fromEntries([...response.headers])
+          };
+        },
+        failedResponseHandler: createJsonErrorResponseHandler5({
+          errorSchema: z8.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        videos: responseBody.videos,
+        warnings: (_a9 = responseBody.warnings) != null ? _a9 : [],
+        providerMetadata: responseBody.providerMetadata,
+        response: {
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders
+        }
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/video-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-video-model-specification-version": "3",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+function maybeEncodeVideoFile(file) {
+  if (file.type === "file" && file.data instanceof Uint8Array) {
+    return {
+      ...file,
+      data: convertUint8ArrayToBase642(file.data)
+    };
+  }
+  return file;
+}
+var providerMetadataEntrySchema2 = z8.object({
+  videos: z8.array(z8.unknown()).optional()
+}).catchall(z8.unknown());
+var gatewayVideoDataSchema = z8.union([
+  z8.object({
+    type: z8.literal("url"),
+    url: z8.string(),
+    mediaType: z8.string()
+  }),
+  z8.object({
+    type: z8.literal("base64"),
+    data: z8.string(),
+    mediaType: z8.string()
+  })
+]);
+var gatewayVideoWarningSchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("unsupported"),
+    feature: z8.string(),
+    details: z8.string().optional()
+  }),
+  z8.object({
+    type: z8.literal("compatibility"),
+    feature: z8.string(),
+    details: z8.string().optional()
+  }),
+  z8.object({
+    type: z8.literal("other"),
+    message: z8.string()
+  })
+]);
+var gatewayVideoEventSchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("result"),
+    videos: z8.array(gatewayVideoDataSchema),
+    warnings: z8.array(gatewayVideoWarningSchema).optional(),
+    providerMetadata: z8.record(z8.string(), providerMetadataEntrySchema2).optional()
+  }),
+  z8.object({
+    type: z8.literal("error"),
+    message: z8.string(),
+    errorType: z8.string(),
+    statusCode: z8.number(),
+    param: z8.unknown().nullable()
+  })
+]);
+
+// src/tool/parallel-search.ts
 import {
   createProviderToolFactoryWithOutputSchema,
   lazySchema as lazySchema6,
   zodSchema as zodSchema6
 } from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod";
-var perplexitySearchInputSchema = lazySchema6(
+import { z as z9 } from "zod";
+var parallelSearchInputSchema = lazySchema6(
+  () => zodSchema6(
+    z9.object({
+      objective: z9.string().describe(
+        "Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."
+      ),
+      search_queries: z9.array(z9.string()).optional().describe(
+        "Optional search queries to supplement the objective. Maximum 200 characters per query."
+      ),
+      mode: z9.enum(["one-shot", "agentic"]).optional().describe(
+        'Mode preset: "one-shot" for comprehensive results with longer excerpts (default), "agentic" for concise, token-efficient results for multi-step workflows.'
+      ),
+      max_results: z9.number().optional().describe(
+        "Maximum number of results to return (1-20). Defaults to 10 if not specified."
+      ),
+      source_policy: z9.object({
+        include_domains: z9.array(z9.string()).optional().describe("List of domains to include in search results."),
+        exclude_domains: z9.array(z9.string()).optional().describe("List of domains to exclude from search results."),
+        after_date: z9.string().optional().describe(
+          "Only include results published after this date (ISO 8601 format)."
+        )
+      }).optional().describe(
+        "Source policy for controlling which domains to include/exclude and freshness."
+      ),
+      excerpts: z9.object({
+        max_chars_per_result: z9.number().optional().describe("Maximum characters per result."),
+        max_chars_total: z9.number().optional().describe("Maximum total characters across all results.")
+      }).optional().describe("Excerpt configuration for controlling result length."),
+      fetch_policy: z9.object({
+        max_age_seconds: z9.number().optional().describe(
+          "Maximum age in seconds for cached content. Set to 0 to always fetch fresh content."
+        )
+      }).optional().describe("Fetch policy for controlling content freshness.")
+    })
+  )
+);
+var parallelSearchOutputSchema = lazySchema6(
   () => zodSchema6(
-    z8.object({
-      query: z8.union([z8.string(), z8.array(z8.string())]).describe(
+    z9.union([
+      // Success response
+      z9.object({
+        searchId: z9.string(),
+        results: z9.array(
+          z9.object({
+            url: z9.string(),
+            title: z9.string(),
+            excerpt: z9.string(),
+            publishDate: z9.string().nullable().optional(),
+            relevanceScore: z9.number().optional()
+          })
+        )
+      }),
+      // Error response
+      z9.object({
+        error: z9.enum([
+          "api_error",
+          "rate_limit",
+          "timeout",
+          "invalid_input",
+          "configuration_error",
+          "unknown"
+        ]),
+        statusCode: z9.number().optional(),
+        message: z9.string()
+      })
+    ])
+  )
+);
+var parallelSearchToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "gateway.parallel_search",
+  inputSchema: parallelSearchInputSchema,
+  outputSchema: parallelSearchOutputSchema
+});
+var parallelSearch = (config = {}) => parallelSearchToolFactory(config);
+
+// src/tool/perplexity-search.ts
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema2,
+  lazySchema as lazySchema7,
+  zodSchema as zodSchema7
+} from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod";
+var perplexitySearchInputSchema = lazySchema7(
+  () => zodSchema7(
+    z10.object({
+      query: z10.union([z10.string(), z10.array(z10.string())]).describe(
         "Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."
       ),
-      max_results: z8.number().optional().describe(
+      max_results: z10.number().optional().describe(
         "Maximum number of search results to return (1-20, default: 10)"
       ),
-      max_tokens_per_page: z8.number().optional().describe(
-        "Maximum number of tokens to extract per search result page (256-2048, default: 1024)"
+      max_tokens_per_page: z10.number().optional().describe(
+        "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
+      ),
+      max_tokens: z10.number().optional().describe(
+        "Maximum total tokens across all search results (default: 25000, max: 1000000)"
       ),
-      country: z8.string().optional().describe(
+      country: z10.string().optional().describe(
         "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
       ),
-      search_domain_filter: z8.array(z8.string()).optional().describe(
+      search_domain_filter: z10.array(z10.string()).optional().describe(
         "List of domains to include or exclude from search results (max 20). To include: ['nature.com', 'science.org']. To exclude: ['-example.com', '-spam.net']"
       ),
-      search_language_filter: z8.array(z8.string()).optional().describe(
+      search_language_filter: z10.array(z10.string()).optional().describe(
         "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
       ),
-      search_after_date: z8.string().optional().describe(
+      search_after_date: z10.string().optional().describe(
         "Include only results published after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
       ),
-      search_before_date: z8.string().optional().describe(
+      search_before_date: z10.string().optional().describe(
         "Include only results published before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
       ),
-      search_recency_filter: z8.enum(["day", "week", "month", "year"]).optional().describe(
+      last_updated_after_filter: z10.string().optional().describe(
+        "Include only results last updated after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
+      ),
+      last_updated_before_filter: z10.string().optional().describe(
+        "Include only results last updated before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
+      ),
+      search_recency_filter: z10.enum(["day", "week", "month", "year"]).optional().describe(
         "Filter results by relative time period. Cannot be used with search_after_date or search_before_date."
       )
     })
   )
 );
-var perplexitySearchOutputSchema = lazySchema6(
-  () => zodSchema6(
-    z8.union([
+var perplexitySearchOutputSchema = lazySchema7(
+  () => zodSchema7(
+    z10.union([
       // Success response
-      z8.object({
-        results: z8.array(
-          z8.object({
-            title: z8.string(),
-            url: z8.string(),
-            snippet: z8.string(),
-            date: z8.string().optional(),
-            lastUpdated: z8.string().optional()
+      z10.object({
+        results: z10.array(
+          z10.object({
+            title: z10.string(),
+            url: z10.string(),
+            snippet: z10.string(),
+            date: z10.string().optional(),
+            lastUpdated: z10.string().optional()
           })
         ),
-        id: z8.string()
+        id: z10.string()
       }),
       // Error response
-      z8.object({
-        error: z8.enum([
+      z10.object({
+        error: z10.enum([
           "api_error",
           "rate_limit",
           "timeout",
           "invalid_input",
           "unknown"
         ]),
-        statusCode: z8.number().optional(),
-        message: z8.string()
+        statusCode: z10.number().optional(),
+        message: z10.string()
       })
     ])
   )
 );
-var perplexitySearchToolFactory = createProviderToolFactoryWithOutputSchema({
+var perplexitySearchToolFactory = createProviderToolFactoryWithOutputSchema2({
   id: "gateway.perplexity_search",
   inputSchema: perplexitySearchInputSchema,
   outputSchema: perplexitySearchOutputSchema
@@ -895,6 +1325,15 @@ var perplexitySearch = (config = {}) => perplexitySearchToolFactory(config);
 
 // src/gateway-tools.ts
 var gatewayTools = {
+  /**
+   * Search the web using Parallel AI's Search API for LLM-optimized excerpts.
+   *
+   * Takes a natural language objective and returns relevant excerpts,
+   * replacing multiple keyword searches with a single call for broad
+   * or complex queries. Supports different search types for depth vs
+   * breadth tradeoffs.
+   */
+  parallelSearch,
   /**
    * Search the web using Perplexity's Search API for real-time information,
    * news, research papers, and articles.
@@ -909,25 +1348,25 @@ var gatewayTools = {
 import { getContext } from "@vercel/oidc";
 import { getVercelOidcToken } from "@vercel/oidc";
 async function getVercelRequestId() {
-  var _a8;
-  return (_a8 = getContext().headers) == null ? void 0 : _a8["x-vercel-id"];
+  var _a9;
+  return (_a9 = getContext().headers) == null ? void 0 : _a9["x-vercel-id"];
 }
 
 // src/gateway-provider.ts
 import { withUserAgentSuffix } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.11" : "0.0.0-test";
+var VERSION = true ? "3.0.66" : "0.0.0-test";
 
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
 function createGatewayProvider(options = {}) {
-  var _a8, _b8;
+  var _a9, _b9;
   let pendingMetadata = null;
   let metadataCache = null;
-  const cacheRefreshMillis = (_a8 = options.metadataCacheRefreshMillis) != null ? _a8 : 1e3 * 60 * 5;
+  const cacheRefreshMillis = (_a9 = options.metadataCacheRefreshMillis) != null ? _a9 : 1e3 * 60 * 5;
   let lastFetchTime = 0;
-  const baseURL = (_b8 = withoutTrailingSlash(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v3/ai";
+  const baseURL = (_b9 = withoutTrailingSlash(options.baseURL)) != null ? _b9 : "https://ai-gateway.vercel.sh/v3/ai";
   const getHeaders = async () => {
     try {
       const auth = await getGatewayAuthToken(options);
@@ -962,13 +1401,18 @@ function createGatewayProvider(options = {}) {
       settingValue: void 0,
       environmentVariableName: "VERCEL_REGION"
     });
+    const projectId = loadOptionalSetting({
+      settingValue: void 0,
+      environmentVariableName: "VERCEL_PROJECT_ID"
+    });
     return async () => {
       const requestId = await getVercelRequestId();
       return {
         ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
         ...environment && { "ai-o11y-environment": environment },
         ...region && { "ai-o11y-region": region },
-        ...requestId && { "ai-o11y-request-id": requestId }
+        ...requestId && { "ai-o11y-request-id": requestId },
+        ...projectId && { "ai-o11y-project-id": projectId }
       };
     };
   };
@@ -982,8 +1426,8 @@ function createGatewayProvider(options = {}) {
     });
   };
   const getAvailableModels = async () => {
-    var _a9, _b9, _c;
-    const now = (_c = (_b9 = (_a9 = options._internal) == null ? void 0 : _a9.currentDate) == null ? void 0 : _b9.call(_a9).getTime()) != null ? _c : Date.now();
+    var _a10, _b10, _c;
+    const now = (_c = (_b10 = (_a10 = options._internal) == null ? void 0 : _a10.currentDate) == null ? void 0 : _b10.call(_a10).getTime()) != null ? _c : Date.now();
     if (!pendingMetadata || now - lastFetchTime > cacheRefreshMillis) {
       lastFetchTime = now;
       pendingMetadata = new GatewayFetchMetadata({
@@ -1046,6 +1490,19 @@ function createGatewayProvider(options = {}) {
   };
   provider.embeddingModel = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
+  provider.videoModel = (modelId) => {
+    return new GatewayVideoModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.chat = provider.languageModel;
+  provider.embedding = provider.embeddingModel;
+  provider.image = provider.imageModel;
+  provider.video = provider.videoModel;
   provider.tools = gatewayTools;
   return provider;
 }