@ai-sdk/gateway 4.0.92 → 4.0.95

package/docs/00-ai-gateway.mdx

@@ -985,6 +985,132 @@ token-efficient content controls. Deep synthesis modes and generated summaries
 are intentionally not exposed yet because they have separate pricing from
 standard Search.
 
+#### Browserbase Search
+
+The Browserbase Search tool enables models to search the web using [Browserbase's Search API](https://docs.browserbase.com/reference/api/web-search). It is executed by AI Gateway and returns fast, structured search results without opening a browser session.
+
+```ts
+import { gateway, generateText } from 'ai';
+
+const result = await generateText({
+  model: 'openai/gpt-5.6-luna',
+  prompt:
+    'Find official guidance on traveling with power banks on U.S. flights. Return the most relevant page titles and URLs.',
+  tools: {
+    browserbase_search: gateway.tools.browserbaseSearch(),
+  },
+});
+
+console.log(result.text);
+console.log('Tool calls:', JSON.stringify(result.toolCalls, null, 2));
+console.log('Tool results:', JSON.stringify(result.toolResults, null, 2));
+```
+
+You can configure the maximum number of results returned by each search:
+
+```ts
+import { gateway, generateText } from 'ai';
+
+const result = await generateText({
+  model: 'openai/gpt-5.6-luna',
+  prompt:
+    'Find three recent reviews comparing e-readers for outdoor reading. Return their titles and URLs.',
+  tools: {
+    browserbase_search: gateway.tools.browserbaseSearch({
+      numResults: 3,
+    }),
+  },
+});
+
+console.log(result.text);
+```
+
+The Browserbase Search tool supports this optional configuration option:
+
+- **numResults** _number_
+
+  Maximum number of search results to return (1-25, default: 10).
+
+The tool works with both `generateText` and `streamText`.
+
+#### Browserbase Fetch
+
+The Browserbase Fetch tool enables models to retrieve page content using [Browserbase's Fetch API](https://docs.browserbase.com/platform/fetch/overview). It is a lightweight option for pages that do not require JavaScript execution or browser interaction, and it supports raw, Markdown, and schema-driven JSON output.
+
+```ts
+import { gateway, generateText } from 'ai';
+
+const result = await generateText({
+  model: 'openai/gpt-5.6-luna',
+  prompt:
+    'Fetch https://www.nps.gov/yose/planyourvisit/halfdome.htm and summarize the permit requirements and main safety warnings.',
+  tools: {
+    browserbase_fetch: gateway.tools.browserbaseFetch(),
+  },
+});
+
+console.log(result.text);
+console.log('Tool calls:', JSON.stringify(result.toolCalls, null, 2));
+console.log('Tool results:', JSON.stringify(result.toolResults, null, 2));
+```
+
+You can configure the output format and request behavior. For example, use JSON extraction to return content matching a JSON Schema:
+
+```ts
+import { gateway, generateText } from 'ai';
+
+const result = await generateText({
+  model: 'openai/gpt-5.6-luna',
+  prompt:
+    'Fetch https://www.nps.gov/yose/planyourvisit/halfdome.htm and extract its page title, whether a permit is required, and three safety tips.',
+  tools: {
+    browserbase_fetch: gateway.tools.browserbaseFetch({
+      allowRedirects: true,
+      format: 'json',
+      schema: {
+        type: 'object',
+        properties: {
+          pageTitle: { type: 'string' },
+          permitRequired: { type: 'boolean' },
+          safetyTips: {
+            type: 'array',
+            items: { type: 'string' },
+            maxItems: 3,
+          },
+        },
+        required: ['pageTitle', 'permitRequired', 'safetyTips'],
+      },
+    }),
+  },
+});
+
+console.log(result.text);
+```
+
+The Browserbase Fetch tool supports these optional configuration options:
+
+- **format** _'raw' | 'markdown' | 'json'_
+
+  Output format for the fetched content. `raw` returns the upstream response body unchanged and is the default. `markdown` converts the page to Markdown. `json` performs structured extraction and requires `schema`.
+
+- **schema** _object_
+
+  JSON Schema describing the desired structured content. Only used when `format` is `json`.
+
+- **allowRedirects** _boolean_
+
+  Follow HTTP redirects. Defaults to `false`.
+
+- **proxies** _boolean_
+
+  Route the request through Browserbase's proxy network. Defaults to `false`.
+
+- **allowInsecureSsl** _boolean_
+
+  Bypass TLS certificate verification. Defaults to `false`; only enable it for trusted hosts.
+
+The Fetch API does not execute JavaScript. Use a browser session for interactive or JavaScript-rendered pages. The tool works with both `generateText` and `streamText`.
+
 #### Tako Search
 
 The Tako Search tool enables models to search the web and Tako's curated knowledge graph in a single call using [Tako's Search API](https://docs.tako.com/documentation/integrating-tako/search/overview). This tool is executed by the AI Gateway and returns token-efficient web excerpts, plus knowledge-graph results that carry structured data, premium source attribution, and an embed-ready visualization.
@@ -1346,12 +1472,16 @@ The following gateway provider options are available:
 
   When `sort` is active, the response's `providerMetadata.gateway.routing.sort` object contains the sort option used, the resulting execution order, per-provider metric values, and any providers that were deprioritized.
 
-- **models** _string[]_
+- **models** _string[] | [GatewayModelFallback, ...string[]]_
 
-  Specifies fallback models to use when the primary model fails or is unavailable. The gateway will try the primary model first (specified in the `model` parameter), then try each model in this array in order until one succeeds.
+  Specifies fallback models in attempt order. String entries keep their existing behavior: the gateway tries them when the primary model fails or is unavailable. Evaluation requests can also start the list with one conditional `{ model, when }` entry to retry a successful but uncertain evaluation with another model. Only the first entry can be conditional, and only one conditional entry is allowed. If the primary model fails, the gateway also advances to the conditional entry under its existing error fallback behavior. Conditional entries are rejected on non-evaluation requests. Type evaluation options with `GatewayEvaluationProviderOptions`, since `GatewayProviderOptions` only accepts string entries.
 
   Example: `models: ['openai/gpt-5.4-nano', 'google/gemini-3.8-flash']` will try the fallback models in order if the primary model fails.
 
+  A direct condition uses `{ question, confidenceBelow }` for Choice and Score questions, or `{ question, probabilityBetween: [minimum, maximum] }` for Boolean questions. Boolean probability is P(true), not confidence in the selected Boolean outcome. Bounds are inclusive, finite, ordered, and within `[0, 1]`.
+
+  Combine conditions with `{ any: [...] }`, `{ all: [...] }`, or `{ atLeast: { count, conditions: [...] } }`. Each condition list holds 1 to 20 conditions. `atLeast.count` must be an integer from `1` through the number of conditions. Conditions nest at most 5 levels deep. Question IDs and the conditional `model` are 1 to 256 characters. The SDK checks these bounds before sending the request, and the gateway also checks that each question exists and has a kind that matches its condition. String error fallbacks may follow the conditional entry.
+
 - **user** _string_
 
   Optional identifier for the end user on whose behalf the request is being made. This is used for spend tracking and attribution purposes, allowing you to track usage per end-user in your application.
@@ -1390,13 +1520,14 @@ The following gateway provider options are available:
 
   The unique identifier for the entity against which quota is tracked. Used for quota management and enforcement purposes.
 
-- **has** _Array<'implicit-caching' | 'reasoning' | 'tool-use' | 'vision' | `quantization:${string}` | `!quantization:${string}`>_
+- **has** _Array<'implicit-caching' | 'reasoning' | 'structured-output' | 'tool-use' | 'vision' | `quantization:${string}` | `!quantization:${string}`>_
 
   Restricts routing to provider models that have all of the specified capabilities. Applies to both BYOK and system credentials, since the capability is a property of the model rather than the credential. If no provider model for the requested model satisfies the capabilities, the request fails. Unsupported values are rejected.
 
   Supported capabilities:
   - `'implicit-caching'` — models that perform automatic (implicit) prompt caching.
   - `'reasoning'` — models that support reasoning.
+  - `'structured-output'` — models that support schema-constrained output.
   - `'tool-use'` — models that support tool calling.
   - `'vision'` — models that accept image input.
 
@@ -1481,6 +1612,63 @@ const { text } = await generateText({
 // 4. Return the result from the first model that succeeds
 ```
 
+#### Conditional Evaluation Fallbacks Example
+
+Conditional model entries are available only for evaluation requests. Keep the
+configuration under `providerOptions.gateway.models`. `experimental_evaluate`
+does not have a top-level fallback option.
+
+```ts
+import type { GatewayEvaluationProviderOptions } from '@ai-sdk/gateway';
+import { experimental_evaluate } from 'ai';
+
+const questions = {
+  department: {
+    type: 'choice',
+    instructions: 'Which team should handle this?',
+    criteria: { billing: 'Charges and refunds', support: 'Other requests' },
+  },
+  requestsRefund: {
+    type: 'boolean',
+    instructions: 'Is the customer requesting money back?',
+  },
+} as const;
+
+const result = await experimental_evaluate({
+  model: 'typesafe-ai/jev',
+  state: 'I was charged twice. Please refund the duplicate.',
+  questions,
+  providerOptions: {
+    gateway: {
+      models: [
+        {
+          model: 'openai/gpt-5.6-sol',
+          when: {
+            any: [
+              { question: 'department', confidenceBelow: 0.6 },
+              {
+                question: 'requestsRefund',
+                probabilityBetween: [0.4, 0.6],
+              },
+            ],
+          },
+        },
+      ],
+    } satisfies GatewayEvaluationProviderOptions<keyof typeof questions>,
+  },
+});
+
+// The model that produced the answers, the fallback when the condition matched.
+console.log(result.response.modelId);
+console.log(JSON.stringify(result.providerMetadata?.gateway?.routing, null, 2));
+```
+
+When the condition matches, `result.response.modelId` names the fallback model,
+and `providerMetadata.gateway.routing.modelAttempts` lists the primary and
+fallback attempts. The successful attempt of each stage carries its own
+`generationId`, `usage`, and cost fields, and the first fallback attempt lists
+the questions that triggered it in `triggeredBy`.
+
 #### Zero Data Retention Example
 
 Set `zeroDataRetention` to true to route requests to providers with zero data retention agreements with Vercel for AI Gateway. BYOK credentials are skipped by default, since your provider agreements differ from Vercel's. When this filter is on, AI Gateway routes only to providers Vercel has ZDR agreements with for the model. If you have BYOK keys marked as ZDR, those keys are tried first, then AI Gateway falls back to its system credentials. You are responsible for the accuracy of that marking. Applies to both account-wide and request-level ZDR. The request fails if no ZDR-eligible credentials are available. When `zeroDataRetention` is `false` or not specified, there is no enforcement of restricting routing. Request-level ZDR is only available for Vercel Pro and Enterprise plans.
@@ -1540,7 +1728,7 @@ const { text } = await generateText({
 
 #### Filtering by Model Capability
 
-Set `has` to restrict routing to provider models that have the specified capabilities. This applies to both BYOK and system credentials, since the capability is a property of the model rather than the credential. `'implicit-caching'` limits routing to models that perform automatic prompt caching, `'vision'` limits routing to models that accept image input, `'reasoning'` limits routing to models that support reasoning, and `'tool-use'` limits routing to models that support tool calling. Weight-format conditions (`'quantization:fp8'` to require, `'!quantization:fp8'` to exclude) limit routing by the serving provider's recorded weight format. If no provider model for the requested model satisfies the capabilities, the request fails.
+Set `has` to restrict routing to provider models that have the specified capabilities. This applies to both BYOK and system credentials, since the capability is a property of the model rather than the credential. `'implicit-caching'` limits routing to models that perform automatic prompt caching, `'vision'` limits routing to models that accept image input, `'reasoning'` limits routing to models that support reasoning, `'structured-output'` limits routing to models that support schema-constrained output, and `'tool-use'` limits routing to models that support tool calling. Weight-format conditions (`'quantization:fp8'` to require, `'!quantization:fp8'` to exclude) limit routing by the serving provider's recorded weight format. If no provider model for the requested model satisfies the capabilities, the request fails.
 
 ```ts
 import type { GatewayProviderOptions } from '@ai-sdk/gateway';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ai-sdk/gateway",
   "private": false,
-  "version": "4.0.92",
+  "version": "4.0.95",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.18",
-    "@ai-sdk/provider-utils": "5.0.47",
+    "@ai-sdk/provider-utils": "5.0.49",
     "@vercel/oidc": "3.2.0"
   },
   "devDependencies": {
-    "@ai-sdk/test-server": "2.0.1",
+    "@ai-sdk/test-server": "2.0.2",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "tsup": "^8.5.1",

package/src/gateway-evaluation-model.ts

@@ -8,6 +8,7 @@ import {
   createJsonResponseHandler,
   getErrorMessage,
   lazySchema,
+  parseProviderOptions,
   postJsonToApi,
   resolve,
   zodSchema,
@@ -17,6 +18,7 @@ import { z } from './zod';
 import { asGatewayError } from './errors';
 import { parseAuthMethod } from './errors/parse-auth-method';
 import type { GatewayConfig } from './gateway-config';
+import { gatewayEvaluationProviderOptionsSchema } from './gateway-provider-options';
 
 export class GatewayEvaluationModel implements EvaluationModelV4 {
   readonly specificationVersion = 'v4';
@@ -44,6 +46,15 @@ export class GatewayEvaluationModel implements EvaluationModelV4 {
   }: Parameters<EvaluationModelV4['doEvaluate']>[0]): Promise<
     Awaited<ReturnType<EvaluationModelV4['doEvaluate']>>
   > {
+    const gatewayOptions = await parseProviderOptions({
+      provider: 'gateway',
+      providerOptions,
+      schema: gatewayEvaluationProviderOptionsSchema,
+    });
+    const validatedProviderOptions =
+      gatewayOptions == null
+        ? providerOptions
+        : { ...providerOptions, gateway: gatewayOptions };
     const resolvedHeaders = this.config.headers
       ? await resolve(this.config.headers)
       : undefined;
@@ -63,7 +74,9 @@ export class GatewayEvaluationModel implements EvaluationModelV4 {
         body: {
           state,
           questions,
-          ...(providerOptions ? { providerOptions } : {}),
+          ...(validatedProviderOptions
+            ? { providerOptions: validatedProviderOptions }
+            : {}),
         },
         successfulResponseHandler: createJsonResponseHandler(
           gatewayEvaluationResponseSchema,
@@ -84,7 +97,7 @@ export class GatewayEvaluationModel implements EvaluationModelV4 {
         providerMetadata:
           responseBody.providerMetadata as unknown as SharedV4ProviderMetadata,
         response: {
-          modelId: this.modelId,
+          modelId: responseBody.model ?? this.modelId,
           headers: responseHeaders,
           body: rawValue,
         },
@@ -152,6 +165,7 @@ const gatewayEvaluationResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
       answers: z.record(z.string(), gatewayEvaluationAnswerSchema),
+      model: z.string().optional(),
       rounding: z
         .object({
           probabilityDecimals: z.number().optional(),

package/src/gateway-provider-options.ts

@@ -1,4 +1,50 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import type { ZodType } from 'zod/v4';
+import { z } from './zod';
+
 // https://vercel.com/docs/ai-gateway/provider-options
+export const EVALUATION_FALLBACK_MAX_CONDITION_DEPTH = 5;
+export const EVALUATION_FALLBACK_MAX_CONDITIONS_PER_LIST = 20;
+export const EVALUATION_FALLBACK_MAX_QUESTION_LENGTH = 256;
+export const EVALUATION_FALLBACK_MAX_MODEL_LENGTH = 256;
+
+export const gatewayEvaluationProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        models: gatewayModelFallbacksSchema.optional(),
+      })
+      .catchall(z.unknown()),
+  ),
+);
+
+/**
+ * A condition on the primary model's answers. `QUESTION_ID` narrows
+ * `question` to your question IDs. Groups nest at most five levels deep,
+ * which the SDK checks at runtime.
+ */
+export type EvaluationFallbackCondition<QUESTION_ID extends string = string> =
+  | ExclusiveCondition<{ question: QUESTION_ID; confidenceBelow: number }>
+  | ExclusiveCondition<{
+      question: QUESTION_ID;
+      probabilityBetween: [number, number];
+    }>
+  | ExclusiveCondition<{ any: EvaluationFallbackConditionList<QUESTION_ID> }>
+  | ExclusiveCondition<{ all: EvaluationFallbackConditionList<QUESTION_ID> }>
+  | ExclusiveCondition<{
+      atLeast: {
+        count: number;
+        conditions: EvaluationFallbackConditionList<QUESTION_ID>;
+      };
+    }>;
+
+export type GatewayModelFallback<QUESTION_ID extends string = string> =
+  | string
+  | {
+      model: string;
+      when: EvaluationFallbackCondition<QUESTION_ID>;
+    };
+
 export type GatewayProviderOptions = {
   /**
    * Service-owned options may be added by the Gateway without requiring an SDK
@@ -19,16 +65,18 @@ export type GatewayProviderOptions = {
    * Restrict routing to provider models that satisfy every given entry.
    *
    * Entries are capability tags (`'implicit-caching'`, `'reasoning'`,
-   * `'tool-use'`, `'vision'`) or weight-format conditions: `'quantization:fp8'`
-   * requires the serving provider to report that weight format,
-   * `'!quantization:fp8'` excludes it (providers with no recorded format still
-   * pass an exclusion). Format values are an open space but must match
-   * `[a-zA-Z0-9._-]{1,32}` and compare case-insensitively; unknown capability
-   * names are rejected by the Gateway with a 400.
+   * `'tool-use'`, `'vision'` (image input), `'structured-output'`
+   * (schema-constrained output)) or weight-format conditions:
+   * `'quantization:fp8'` requires the serving provider to report that weight
+   * format, `'!quantization:fp8'` excludes it (providers with no recorded
+   * format still pass an exclusion). Format values are an open space but must
+   * match `[a-zA-Z0-9._-]{1,32}` and compare case-insensitively. Unknown
+   * capability names are rejected by the Gateway with a 400.
    */
   has?: Array<
     | 'implicit-caching'
     | 'reasoning'
+    | 'structured-output'
     | 'tool-use'
     | 'vision'
     | `quantization:${string}`
@@ -41,7 +89,11 @@ export type GatewayProviderOptions = {
    */
   idempotencyKey?: string;
 
-  /** Array of model slugs specifying fallback models to use in order. */
+  /**
+   * Array of model slugs specifying fallback models to use in order.
+   * Conditional entries are only valid on evaluation requests, see
+   * `GatewayEvaluationProviderOptions`.
+   */
   models?: string[];
 
   /** Array of provider slugs that are the only ones allowed to be used. */
@@ -73,3 +125,153 @@ export type GatewayProviderOptions = {
   /** Filter to providers with zero data retention agreements. */
   zeroDataRetention?: boolean;
 };
+
+/**
+ * Gateway provider options for evaluation requests. Same as
+ * `GatewayProviderOptions`, except `models` may start with one conditional
+ * `{ model, when }` entry followed by string error fallbacks.
+ *
+ * The SDK validates `models` strictly before sending the request, so new
+ * condition shapes need an SDK release. Other keys pass through unchanged.
+ */
+export type GatewayEvaluationProviderOptions<
+  QUESTION_ID extends string = string,
+> = GatewayProviderOptionsWithoutModels & {
+  models?: GatewayModelFallbackList<QUESTION_ID>;
+};
+
+type EvaluationFallbackConditionList<QUESTION_ID extends string> = [
+  EvaluationFallbackCondition<QUESTION_ID>,
+  ...EvaluationFallbackCondition<QUESTION_ID>[],
+];
+
+type ConditionKey =
+  | 'question'
+  | 'confidenceBelow'
+  | 'probabilityBetween'
+  | 'any'
+  | 'all'
+  | 'atLeast';
+
+// Rules out the other shapes' keys, so a condition can't mix two shapes.
+type ExclusiveCondition<CONDITION> = CONDITION & {
+  [KEY in Exclude<ConditionKey, keyof CONDITION>]?: never;
+};
+
+type GatewayProviderOptionsWithoutModels = {
+  [KEY in keyof GatewayProviderOptions as KEY extends 'models'
+    ? never
+    : KEY]: GatewayProviderOptions[KEY];
+};
+
+type ConditionalGatewayModelFallback<QUESTION_ID extends string> = Exclude<
+  GatewayModelFallback<QUESTION_ID>,
+  string
+>;
+
+type GatewayModelFallbackList<QUESTION_ID extends string> =
+  | string[]
+  | [ConditionalGatewayModelFallback<QUESTION_ID>, ...string[]];
+
+const probabilitySchema = z.number().finite().min(0).max(1);
+const questionSchema = z
+  .string()
+  .min(1)
+  .max(EVALUATION_FALLBACK_MAX_QUESTION_LENGTH);
+const directConditionSchema = z.union([
+  z
+    .object({
+      question: questionSchema,
+      confidenceBelow: probabilitySchema,
+    })
+    .strict(),
+  z
+    .object({
+      question: questionSchema,
+      probabilityBetween: z
+        .array(probabilitySchema)
+        .length(2)
+        .refine(([minimum, maximum]) => minimum <= maximum, {
+          message:
+            'probabilityBetween minimum must be less than or equal to maximum',
+        }),
+    })
+    .strict(),
+]) as ZodType<EvaluationFallbackCondition>;
+
+const groupBeyondMaxDepthSchema = z
+  .union([
+    z.object({ any: z.unknown() }),
+    z.object({ all: z.unknown() }),
+    z.object({ atLeast: z.unknown() }),
+  ])
+  .superRefine((_, context) => {
+    context.addIssue({
+      code: 'custom',
+      message: `conditions can be nested at most ${EVALUATION_FALLBACK_MAX_CONDITION_DEPTH} levels deep`,
+    });
+  });
+
+const conditionalModelFallbackSchema = z
+  .object({
+    model: z.string().min(1).max(EVALUATION_FALLBACK_MAX_MODEL_LENGTH),
+    when: conditionSchema(1),
+  })
+  .strict();
+
+const gatewayModelFallbacksSchema = z
+  .array(z.union([z.string(), conditionalModelFallbackSchema]))
+  .superRefine((entries, context) => {
+    const conditionalIndexes = entries.flatMap((entry, index) =>
+      typeof entry === 'string' ? [] : [index],
+    );
+    if (conditionalIndexes.length > 1) {
+      context.addIssue({
+        code: 'custom',
+        message: 'models supports at most one conditional evaluation fallback',
+      });
+    }
+    if (conditionalIndexes[0] !== undefined && conditionalIndexes[0] !== 0) {
+      context.addIssue({
+        code: 'custom',
+        message:
+          'a conditional evaluation fallback must be the first models entry',
+        path: [conditionalIndexes[0]],
+      });
+    }
+  });
+
+function conditionSchema(depth: number): ZodType<EvaluationFallbackCondition> {
+  if (depth === EVALUATION_FALLBACK_MAX_CONDITION_DEPTH) {
+    return z.union([
+      directConditionSchema,
+      groupBeyondMaxDepthSchema,
+    ]) as ZodType<EvaluationFallbackCondition>;
+  }
+
+  const childConditionSchema = conditionSchema(depth + 1);
+  const conditionListSchema = z
+    .array(childConditionSchema)
+    .min(1)
+    .max(EVALUATION_FALLBACK_MAX_CONDITIONS_PER_LIST);
+
+  return z.union([
+    directConditionSchema,
+    z.object({ any: conditionListSchema }).strict(),
+    z.object({ all: conditionListSchema }).strict(),
+    z
+      .object({
+        atLeast: z
+          .object({
+            count: z.number().int().min(1),
+            conditions: conditionListSchema,
+          })
+          .strict()
+          .refine(({ count, conditions }) => count <= conditions.length, {
+            message: 'atLeast count cannot exceed the number of conditions',
+            path: ['count'],
+          }),
+      })
+      .strict(),
+  ]) as ZodType<EvaluationFallbackCondition>;
+}

package/src/gateway-tools.ts

@@ -1,3 +1,5 @@
+import { browserbaseFetch } from './tool/browserbase-fetch';
+import { browserbaseSearch } from './tool/browserbase-search';
 import { exaSearch } from './tool/exa-search';
 import { parallelSearch } from './tool/parallel-search';
 import { perplexitySearch } from './tool/perplexity-search';
@@ -7,6 +9,22 @@ import { takoSearch } from './tool/tako-search';
  * Gateway-specific provider-defined tools.
  */
 export const gatewayTools = {
+  /**
+   * Fetch page content using Browserbase's lightweight Fetch API.
+   *
+   * Supports raw, Markdown, and schema-driven JSON output as well as redirects,
+   * proxy routing, and TLS controls.
+   */
+  browserbaseFetch,
+
+  /**
+   * Search the web using Browserbase's Search API for fast, structured results.
+   *
+   * Returns titles, URLs, and available publication metadata without requiring
+   * a browser session.
+   */
+  browserbaseSearch,
+
   /**
    * Search the web using Exa for current information and token-efficient
    * excerpts optimized for agent workflows.

package/src/index.ts

@@ -47,6 +47,9 @@ export type {
   GatewayProviderMetadata,
 } from './gateway-provider-metadata';
 export type {
+  EvaluationFallbackCondition,
+  GatewayEvaluationProviderOptions,
+  GatewayModelFallback,
   GatewayProviderOptions,
   /** @deprecated Use `GatewayProviderOptions` instead. */
   GatewayProviderOptions as GatewayLanguageModelOptions,