@ai-sdk/gateway 3.0.201 → 3.0.202

package/docs/00-ai-gateway.mdx

@@ -655,6 +655,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.
@@ -1064,7 +1190,7 @@ 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.
 
@@ -1072,6 +1198,7 @@ The following gateway provider options are available:
 
   - `'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.
 
@@ -1215,7 +1342,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": "3.0.201",
+  "version": "3.0.202",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/gateway-provider-options.ts

@@ -117,6 +117,7 @@ const gatewayProviderOptions = lazySchema(() =>
        * - `'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
        * - `'quantization:<value>'`: providers serving that weight format
@@ -130,7 +131,13 @@ const gatewayProviderOptions = lazySchema(() =>
       has: z
         .array(
           z.union([
-            z.enum(['implicit-caching', 'reasoning', 'tool-use', 'vision']),
+            z.enum([
+              'implicit-caching',
+              'reasoning',
+              'structured-output',
+              'tool-use',
+              'vision',
+            ]),
             z.templateLiteral(['quantization:', z.string()]),
             z.templateLiteral(['!quantization:', z.string()]),
           ]),

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/tool/browserbase-fetch.ts

@@ -0,0 +1,158 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod';
+
+export type BrowserbaseFetchFormat = 'raw' | 'json' | 'markdown';
+
+export interface BrowserbaseFetchConfig {
+  /** Whether to follow HTTP redirects (default: false). */
+  allowRedirects?: boolean;
+  /** Whether to bypass TLS certificate verification (default: false). */
+  allowInsecureSsl?: boolean;
+  /** Whether to route the request through Browserbase proxies (default: false). */
+  proxies?: boolean;
+  /** Output format for the response content (default: raw). */
+  format?: BrowserbaseFetchFormat;
+  /**
+   * JSON Schema describing the desired response content. Only used when format
+   * is json.
+   */
+  schema?: Record<string, unknown>;
+}
+
+export interface BrowserbaseFetchInput {
+  /** URL of the page to fetch. */
+  url: string;
+  /** Whether to follow HTTP redirects. */
+  allow_redirects?: boolean;
+  /** Whether to bypass TLS certificate verification. */
+  allow_insecure_ssl?: boolean;
+  /** Whether to route the request through Browserbase proxies. */
+  proxies?: boolean;
+  /** Output format for the response content. */
+  format?: BrowserbaseFetchFormat;
+  /**
+   * JSON Schema describing the desired response content. Only used when format
+   * is json.
+   */
+  schema?: Record<string, unknown>;
+}
+
+export interface BrowserbaseFetchResponse {
+  /** Unique identifier for the fetch request. */
+  id: string;
+  /**
+   * Response body. Raw and markdown responses return strings; JSON extraction
+   * returns an object matching the requested schema.
+   */
+  content: string | Record<string, unknown>;
+  /** MIME type of the response. */
+  contentType: string;
+  /** Character encoding of the response. */
+  encoding: string;
+  /** Response headers from the fetched page. */
+  headers: Record<string, string>;
+  /** HTTP status code returned by the fetched page. */
+  statusCode: number;
+}
+
+export interface BrowserbaseFetchError {
+  error:
+    | 'api_error'
+    | 'configuration_error'
+    | 'execution_error'
+    | 'invalid_input'
+    | 'rate_limit'
+    | 'timeout'
+    | 'unknown';
+  statusCode?: number;
+  message: string;
+}
+
+export type BrowserbaseFetchOutput =
+  | BrowserbaseFetchError
+  | BrowserbaseFetchResponse;
+
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+
+const browserbaseFetchInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      url: z.string().url().describe('URL of the page to fetch.'),
+      allow_redirects: z
+        .boolean()
+        .optional()
+        .describe('Whether to follow HTTP redirects (default: false).'),
+      allow_insecure_ssl: z
+        .boolean()
+        .optional()
+        .describe(
+          'Whether to bypass TLS certificate verification (default: false). Only use for trusted hosts.',
+        ),
+      proxies: z
+        .boolean()
+        .optional()
+        .describe(
+          'Whether to route the request through Browserbase proxies (default: false).',
+        ),
+      format: z
+        .enum(['raw', 'json', 'markdown'])
+        .optional()
+        .describe(
+          'Output format. raw returns the response body unchanged, markdown returns page content as Markdown, and json returns structured content using schema.',
+        ),
+      schema: jsonObjectSchema
+        .optional()
+        .describe(
+          'JSON Schema for structured extraction. Only use with format set to json.',
+        ),
+    }),
+  ),
+);
+
+const browserbaseFetchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.union([
+      z.object({
+        id: z.string(),
+        content: z.union([z.string(), jsonObjectSchema]),
+        contentType: z.string(),
+        encoding: z.string(),
+        headers: z.record(z.string(), z.string()),
+        statusCode: z.number(),
+      }),
+      z.object({
+        error: z.enum([
+          'api_error',
+          'configuration_error',
+          'execution_error',
+          'invalid_input',
+          'rate_limit',
+          'timeout',
+          'unknown',
+        ]),
+        statusCode: z.number().optional(),
+        message: z.string(),
+      }),
+    ]),
+  ),
+);
+
+export const browserbaseFetchToolFactory =
+  createProviderToolFactoryWithOutputSchema<
+    BrowserbaseFetchInput,
+    BrowserbaseFetchOutput,
+    BrowserbaseFetchConfig
+  >({
+    id: 'gateway.browserbase_fetch',
+    inputSchema: browserbaseFetchInputSchema,
+    outputSchema: browserbaseFetchOutputSchema,
+  });
+
+export const browserbaseFetch = (
+  config: BrowserbaseFetchConfig = {},
+): ReturnType<typeof browserbaseFetchToolFactory> =>
+  browserbaseFetchToolFactory(config);

package/src/tool/browserbase-search.ts

@@ -0,0 +1,138 @@
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod';
+
+export interface BrowserbaseSearchConfig {
+  /**
+   * Default maximum number of results to return (1-25, default: 10).
+   */
+  numResults?: number;
+}
+
+export interface BrowserbaseSearchInput {
+  /**
+   * Web search query (1-200 characters).
+   */
+  query: string;
+
+  /**
+   * Maximum number of results to return (1-25, default: 10).
+   */
+  num_results?: number;
+}
+
+export interface BrowserbaseSearchResult {
+  /** Unique identifier for the result. */
+  id: string;
+  /** Title of the search result. */
+  title: string;
+  /** URL of the search result. */
+  url: string;
+  /** Author of the content, when available. */
+  author?: string;
+  /** Favicon URL, when available. */
+  favicon?: string;
+  /** Image URL, when available. */
+  image?: string;
+  /** Publication date in ISO 8601 format, when available. */
+  publishedDate?: string;
+}
+
+export interface BrowserbaseSearchResponse {
+  /** The search query that was executed. */
+  query: string;
+  /** Unique identifier for the request. */
+  requestId: string;
+  /** Search results. */
+  results: BrowserbaseSearchResult[];
+}
+
+export interface BrowserbaseSearchError {
+  error:
+    | 'api_error'
+    | 'configuration_error'
+    | 'execution_error'
+    | 'invalid_input'
+    | 'rate_limit'
+    | 'timeout'
+    | 'unknown';
+  statusCode?: number;
+  message: string;
+}
+
+export type BrowserbaseSearchOutput =
+  | BrowserbaseSearchError
+  | BrowserbaseSearchResponse;
+
+const browserbaseSearchInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      query: z
+        .string()
+        .min(1)
+        .max(200)
+        .describe('Web search query. Must be between 1 and 200 characters.'),
+      num_results: z
+        .number()
+        .int()
+        .min(1)
+        .max(25)
+        .optional()
+        .describe('Maximum number of results to return (1-25, default: 10).'),
+    }),
+  ),
+);
+
+const browserbaseSearchOutputSchema = lazySchema(() =>
+  zodSchema(
+    z.union([
+      z.object({
+        query: z.string(),
+        requestId: z.string(),
+        results: z.array(
+          z.object({
+            id: z.string(),
+            title: z.string(),
+            url: z.string(),
+            author: z.string().optional(),
+            favicon: z.string().optional(),
+            image: z.string().optional(),
+            publishedDate: z.string().optional(),
+          }),
+        ),
+      }),
+      z.object({
+        error: z.enum([
+          'api_error',
+          'configuration_error',
+          'execution_error',
+          'invalid_input',
+          'rate_limit',
+          'timeout',
+          'unknown',
+        ]),
+        statusCode: z.number().optional(),
+        message: z.string(),
+      }),
+    ]),
+  ),
+);
+
+export const browserbaseSearchToolFactory =
+  createProviderToolFactoryWithOutputSchema<
+    BrowserbaseSearchInput,
+    BrowserbaseSearchOutput,
+    BrowserbaseSearchConfig
+  >({
+    id: 'gateway.browserbase_search',
+    inputSchema: browserbaseSearchInputSchema,
+    outputSchema: browserbaseSearchOutputSchema,
+  });
+
+export const browserbaseSearch = (
+  config: BrowserbaseSearchConfig = {},
+): ReturnType<typeof browserbaseSearchToolFactory> =>
+  browserbaseSearchToolFactory(config);