@ai-sdk/openai 3.0.30 → 3.0.32

package/docs/03-openai.mdx

@@ -123,7 +123,8 @@ const { text } = await generateText({
 });
 ```
 
-OpenAI language models can also be used in the `streamText`, `generateObject`, and `streamObject` functions
+OpenAI language models can also be used in the `streamText` function
+and support structured data generation with [`Output`](/docs/reference/ai-sdk-core/output)
 (see [AI SDK Core](/docs/ai-sdk-core)).
 
 ### Responses Models
@@ -340,6 +341,67 @@ console.log('Reasoning:', result.reasoning);
 
 Learn more about reasoning summaries in the [OpenAI documentation](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#reasoning-summaries).
 
+#### WebSocket Transport
+
+OpenAI's [WebSocket API](https://developers.openai.com/api/docs/guides/websocket-mode) keeps a persistent connection open, which can significantly
+reduce Time-to-First-Byte (TTFB) in agentic workflows with many tool calls.
+After the initial connection, subsequent requests skip TCP/TLS/HTTP negotiation entirely.
+
+The [`ai-sdk-openai-websocket-fetch`](https://www.npmjs.com/package/ai-sdk-openai-websocket-fetch)
+package provides a drop-in `fetch` replacement that routes streaming requests
+through a persistent WebSocket connection.
+
+<Tabs items={['pnpm', 'npm', 'yarn', 'bun']}>
+  <Tab>
+    <Snippet text="pnpm add ai-sdk-openai-websocket-fetch" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="npm install ai-sdk-openai-websocket-fetch" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="yarn add ai-sdk-openai-websocket-fetch" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="bun add ai-sdk-openai-websocket-fetch" dark />
+  </Tab>
+</Tabs>
+
+Pass the WebSocket fetch to `createOpenAI` via the `fetch` option:
+
+```ts highlight="2,6-7,15"
+import { createOpenAI } from '@ai-sdk/openai';
+import { createWebSocketFetch } from 'ai-sdk-openai-websocket-fetch';
+import { streamText } from 'ai';
+
+// Create a WebSocket-backed fetch instance
+const wsFetch = createWebSocketFetch();
+const openai = createOpenAI({ fetch: wsFetch });
+
+const result = streamText({
+  model: openai('gpt-4.1-mini'),
+  prompt: 'Hello!',
+  tools: {
+    // ...
+  },
+  onFinish: () => wsFetch.close(), // close the WebSocket when done
+});
+```
+
+The first request will be slower because it must establish the WebSocket connection
+(DNS + TCP + TLS + WebSocket upgrade). After that, subsequent steps in a
+multi-step tool-calling loop reuse the open connection, resulting in lower TTFB
+per step.
+
+<Note>
+  The WebSocket transport only routes streaming requests to the OpenAI Responses
+  API (`POST /responses` with `stream: true`) through the WebSocket. All other
+  requests (non-streaming, embeddings, etc.) fall through to the standard
+  `fetch` implementation.
+</Note>
+
+You can see a live side-by-side comparison of HTTP vs WebSocket streaming performance
+in the [demo app](https://github.com/vercel-labs/ai-sdk-openai-websocket).
+
 #### Verbosity Control
 
 You can control the length and detail of model responses using the `textVerbosity` parameter:
@@ -999,37 +1061,26 @@ and the `mediaType` should be set to `'application/pdf'`.
 
 #### Structured Outputs
 
-The OpenAI Responses API supports structured outputs. You can enforce structured outputs using `generateObject` or `streamObject`, which expose a `schema` option. Additionally, you can pass a Zod or JSON Schema object to the `output` option when using `generateText` or `streamText`.
+The OpenAI Responses API supports structured outputs. You can use `generateText` or `streamText` with [`Output`](/docs/reference/ai-sdk-core/output) to enforce structured outputs.
 
 ```ts
-// Using generateObject
-const result = await generateObject({
-  model: openai('gpt-4.1'),
-  schema: z.object({
-    recipe: z.object({
-      name: z.string(),
-      ingredients: z.array(
-        z.object({
-          name: z.string(),
-          amount: z.string(),
-        }),
-      ),
-      steps: z.array(z.string()),
-    }),
-  }),
-  prompt: 'Generate a lasagna recipe.',
-});
-
-// Using generateText
 const result = await generateText({
   model: openai('gpt-4.1'),
-  prompt: 'How do I make a pizza?',
   output: Output.object({
     schema: z.object({
-      ingredients: z.array(z.string()),
-      steps: z.array(z.string()),
+      recipe: z.object({
+        name: z.string(),
+        ingredients: z.array(
+          z.object({
+            name: z.string(),
+            amount: z.string(),
+          }),
+        ),
+        steps: z.array(z.string()),
+      }),
     }),
   }),
+  prompt: 'Generate a lasagna recipe.',
 });
 ```
 
@@ -1458,32 +1509,34 @@ You can disable them by setting the `strictJsonSchema` option to `false`.
 
 ```ts highlight="7"
 import { openai, OpenAILanguageModelChatOptions } from '@ai-sdk/openai';
-import { generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 import { z } from 'zod';
 
-const result = await generateObject({
+const result = await generateText({
   model: openai.chat('gpt-4o-2024-08-06'),
   providerOptions: {
     openai: {
       strictJsonSchema: false,
     } satisfies OpenAILanguageModelChatOptions,
   },
-  schemaName: 'recipe',
-  schemaDescription: 'A recipe for lasagna.',
-  schema: z.object({
-    name: z.string(),
-    ingredients: z.array(
-      z.object({
-        name: z.string(),
-        amount: z.string(),
-      }),
-    ),
-    steps: z.array(z.string()),
+  output: Output.object({
+    schema: z.object({
+      name: z.string(),
+      ingredients: z.array(
+        z.object({
+          name: z.string(),
+          amount: z.string(),
+        }),
+      ),
+      steps: z.array(z.string()),
+    }),
+    schemaName: 'recipe',
+    schemaDescription: 'A recipe for lasagna.',
   }),
   prompt: 'Generate a lasagna recipe.',
 });
 
-console.log(JSON.stringify(result.object, null, 2));
+console.log(JSON.stringify(result.output, null, 2));
 ```
 
 <Note type="warning">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "3.0.30",
+  "version": "3.0.32",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -44,8 +44,8 @@
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@vercel/ai-tsconfig": "0.0.0",
-    "@ai-sdk/test-server": "1.0.3"
+    "@ai-sdk/test-server": "1.0.3",
+    "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/responses/openai-responses-api.ts

@@ -599,29 +599,31 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             type: z.literal('web_search_call'),
             id: z.string(),
             status: z.string(),
-            action: z.discriminatedUnion('type', [
-              z.object({
-                type: z.literal('search'),
-                query: z.string().nullish(),
-                sources: z
-                  .array(
-                    z.discriminatedUnion('type', [
-                      z.object({ type: z.literal('url'), url: z.string() }),
-                      z.object({ type: z.literal('api'), name: z.string() }),
-                    ]),
-                  )
-                  .nullish(),
-              }),
-              z.object({
-                type: z.literal('open_page'),
-                url: z.string().nullish(),
-              }),
-              z.object({
-                type: z.literal('find_in_page'),
-                url: z.string().nullish(),
-                pattern: z.string().nullish(),
-              }),
-            ]),
+            action: z
+              .discriminatedUnion('type', [
+                z.object({
+                  type: z.literal('search'),
+                  query: z.string().nullish(),
+                  sources: z
+                    .array(
+                      z.discriminatedUnion('type', [
+                        z.object({ type: z.literal('url'), url: z.string() }),
+                        z.object({ type: z.literal('api'), name: z.string() }),
+                      ]),
+                    )
+                    .nullish(),
+                }),
+                z.object({
+                  type: z.literal('open_page'),
+                  url: z.string().nullish(),
+                }),
+                z.object({
+                  type: z.literal('find_in_page'),
+                  url: z.string().nullish(),
+                  pattern: z.string().nullish(),
+                }),
+              ])
+              .nullish(),
           }),
           z.object({
             type: z.literal('file_search_call'),
@@ -966,29 +968,34 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
               type: z.literal('web_search_call'),
               id: z.string(),
               status: z.string(),
-              action: z.discriminatedUnion('type', [
-                z.object({
-                  type: z.literal('search'),
-                  query: z.string().nullish(),
-                  sources: z
-                    .array(
-                      z.discriminatedUnion('type', [
-                        z.object({ type: z.literal('url'), url: z.string() }),
-                        z.object({ type: z.literal('api'), name: z.string() }),
-                      ]),
-                    )
-                    .nullish(),
-                }),
-                z.object({
-                  type: z.literal('open_page'),
-                  url: z.string().nullish(),
-                }),
-                z.object({
-                  type: z.literal('find_in_page'),
-                  url: z.string().nullish(),
-                  pattern: z.string().nullish(),
-                }),
-              ]),
+              action: z
+                .discriminatedUnion('type', [
+                  z.object({
+                    type: z.literal('search'),
+                    query: z.string().nullish(),
+                    sources: z
+                      .array(
+                        z.discriminatedUnion('type', [
+                          z.object({ type: z.literal('url'), url: z.string() }),
+                          z.object({
+                            type: z.literal('api'),
+                            name: z.string(),
+                          }),
+                        ]),
+                      )
+                      .nullish(),
+                  }),
+                  z.object({
+                    type: z.literal('open_page'),
+                    url: z.string().nullish(),
+                  }),
+                  z.object({
+                    type: z.literal('find_in_page'),
+                    url: z.string().nullish(),
+                    pattern: z.string().nullish(),
+                  }),
+                ])
+                .nullish(),
             }),
             z.object({
               type: z.literal('file_search_call'),

package/src/responses/openai-responses-language-model.ts

@@ -1969,8 +1969,12 @@ function isErrorChunk(
 }
 
 function mapWebSearchOutput(
-  action: OpenAIResponsesWebSearchAction,
+  action: OpenAIResponsesWebSearchAction | null | undefined,
 ): InferSchema<typeof webSearchOutputSchema> {
+  if (action == null) {
+    return {};
+  }
+
   switch (action.type) {
     case 'search':
       return {

package/src/responses/openai-responses-options.ts

@@ -42,6 +42,8 @@ export const openaiResponsesReasoningModelIds = [
   'gpt-5.2',
   'gpt-5.2-chat-latest',
   'gpt-5.2-pro',
+  'gpt-5.2-codex',
+  'gpt-5.3-codex',
 ] as const;
 
 export const openaiResponsesModelIds = [
@@ -110,6 +112,8 @@ export type OpenAIResponsesModelId =
   | 'gpt-5.2'
   | 'gpt-5.2-chat-latest'
   | 'gpt-5.2-pro'
+  | 'gpt-5.2-codex'
+  | 'gpt-5.3-codex'
   | 'gpt-5-2025-08-07'
   | 'gpt-5-chat-latest'
   | 'gpt-5-codex'

package/src/tool/web-search-preview.ts

@@ -29,21 +29,23 @@ export const webSearchPreviewInputSchema = lazySchema(() =>
 const webSearchPreviewOutputSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      action: z.discriminatedUnion('type', [
-        z.object({
-          type: z.literal('search'),
-          query: z.string().optional(),
-        }),
-        z.object({
-          type: z.literal('openPage'),
-          url: z.string().nullish(),
-        }),
-        z.object({
-          type: z.literal('findInPage'),
-          url: z.string().nullish(),
-          pattern: z.string().nullish(),
-        }),
-      ]),
+      action: z
+        .discriminatedUnion('type', [
+          z.object({
+            type: z.literal('search'),
+            query: z.string().optional(),
+          }),
+          z.object({
+            type: z.literal('openPage'),
+            url: z.string().nullish(),
+          }),
+          z.object({
+            type: z.literal('findInPage'),
+            url: z.string().nullish(),
+            pattern: z.string().nullish(),
+          }),
+        ])
+        .optional(),
     }),
   ),
 );
@@ -57,7 +59,7 @@ export const webSearchPreview = createProviderToolFactoryWithOutputSchema<
      * An object describing the specific action taken in this web search call.
      * Includes details on how the model used the web (search, open_page, find_in_page).
      */
-    action:
+    action?:
       | {
           /**
            * Action type "search" - Performs a web search query.

package/src/tool/web-search.ts

@@ -31,21 +31,23 @@ const webSearchInputSchema = lazySchema(() => zodSchema(z.object({})));
 export const webSearchOutputSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      action: z.discriminatedUnion('type', [
-        z.object({
-          type: z.literal('search'),
-          query: z.string().optional(),
-        }),
-        z.object({
-          type: z.literal('openPage'),
-          url: z.string().nullish(),
-        }),
-        z.object({
-          type: z.literal('findInPage'),
-          url: z.string().nullish(),
-          pattern: z.string().nullish(),
-        }),
-      ]),
+      action: z
+        .discriminatedUnion('type', [
+          z.object({
+            type: z.literal('search'),
+            query: z.string().optional(),
+          }),
+          z.object({
+            type: z.literal('openPage'),
+            url: z.string().nullish(),
+          }),
+          z.object({
+            type: z.literal('findInPage'),
+            url: z.string().nullish(),
+            pattern: z.string().nullish(),
+          }),
+        ])
+        .optional(),
       sources: z
         .array(
           z.discriminatedUnion('type', [
@@ -67,7 +69,7 @@ export const webSearchToolFactory = createProviderToolFactoryWithOutputSchema<
      * An object describing the specific action taken in this web search call.
      * Includes details on how the model used the web (search, open_page, find_in_page).
      */
-    action:
+    action?:
       | {
           /**
            * Action type "search" - Performs a web search query.