@ai-sdk/openai 4.0.91 → 4.0.93

package/docs/03-openai.mdx

@@ -757,6 +757,13 @@ for (const toolResult of result.toolResults) {
 }
 ```
 
+`result.sources` and source stream events expose the URLs returned in
+`web_search_call.action.sources`. These may include uncited URLs. Inline
+references are available separately on `text.citations` and `text-end.citations`,
+including titles and provider-supplied text ranges. Raw annotations remain in
+text provider metadata. Citation-only responses and `web_search_preview`
+responses without retrieval data retain citation-derived sources.
+
 The web search tool supports the following configuration options:
 
 - **externalWebAccess** _boolean_ - Whether to use external web access for fetching live content. Defaults to `true`.
@@ -1853,6 +1860,10 @@ for (const part of result.content) {
           // url_citation is returned from web_search and provides:
           // properties: type, url, title, start_index and end_index
           break;
+        case 'file_search':
+          // Retrieved file-search result; provides fileId.
+          // The filename is available as part.filename.
+          break;
         case 'file_citation':
           // file_citation is returned from file_search and provides:
           // properties: type, file_id, filename and index
@@ -1931,12 +1942,20 @@ for (const part of result.content) {
 }
 ```
 
+When file-search results are included in the API response, each retrieved file
+is exposed once as a document source, even if it has multiple matching passages
+or is not cited. Inline file citations are available on `text.citations` and
+`text-end.citations`. If the response omits file-search results, file citations
+also remain document sources for compatibility. Generated file paths remain
+source parts and are not treated as citations.
+
 #### Typed providerMetadata in Source Document Parts
 
 For source document parts, when `part.type === 'source'` and `sourceType === 'document'`, the `providerMetadata` is provided as `OpenaiResponsesSourceDocumentProviderMetadata`.
 
 This metadata is also a discriminated union with a required `type` field. Supported types include:
 
+- `file_search` (retrieved file; includes `fileId`)
 - `file_citation`
 - `container_file_citation`
 - `file_path`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.91",
+  "version": "4.0.93",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.26",
-    "@ai-sdk/provider-utils": "5.0.58"
+    "@ai-sdk/provider": "4.0.27",
+    "@ai-sdk/provider-utils": "5.0.59"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/responses/convert-to-openai-responses-input.ts

@@ -15,6 +15,7 @@ import {
   parseProviderOptions,
   resolveFullMediaType,
   resolveProviderReference,
+  safeValidateTypes,
   validateTypes,
   type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
@@ -37,6 +38,7 @@ import type {
   OpenAIResponsesInput,
   OpenAIResponsesReasoning,
   OpenAIResponsesToolCaller,
+  OpenAIResponsesWebSearchCall,
 } from './openai-responses-api';
 import {
   toolSearchInputSchema,
@@ -46,6 +48,7 @@ import {
   programmaticToolCallingInputSchema,
   programmaticToolCallingOutputSchema,
 } from '../tool/programmatic-tool-calling';
+import { webSearchOutputSchema } from '../tool/web-search';
 import {
   getParallelToolCallMetadata,
   type ParallelToolCallMetadata,
@@ -68,6 +71,65 @@ function mapToolCaller(
       : caller;
 }
 
+async function convertWebSearchToolResultOutput({
+  output,
+  id,
+}: {
+  output: LanguageModelV4ToolResultOutput;
+  id: string;
+}): Promise<OpenAIResponsesWebSearchCall | undefined> {
+  if (output.type !== 'json') {
+    return undefined;
+  }
+
+  const validation = await safeValidateTypes({
+    value: output.value,
+    schema: webSearchOutputSchema,
+  });
+
+  if (!validation.success || validation.value.action == null) {
+    return undefined;
+  }
+
+  const { action, sources } = validation.value;
+
+  switch (action.type) {
+    case 'search':
+      return {
+        type: 'web_search_call',
+        id,
+        status: 'completed',
+        action: {
+          type: 'search',
+          ...(action.query != null && { query: action.query }),
+          ...(action.queries != null && { queries: action.queries }),
+          ...(sources != null && { sources }),
+        },
+      };
+    case 'openPage':
+      return {
+        type: 'web_search_call',
+        id,
+        status: 'completed',
+        action: {
+          type: 'open_page',
+          url: action.url,
+        },
+      };
+    case 'findInPage':
+      return {
+        type: 'web_search_call',
+        id,
+        status: 'completed',
+        action: {
+          type: 'find_in_page',
+          url: action.url,
+          pattern: action.pattern,
+        },
+      };
+  }
+}
+
 async function convertFunctionToolResultOutput({
   output,
   toolName,
@@ -373,6 +435,7 @@ export async function convertToOpenAIResponsesInput({
   fileIdPrefixes,
   passThroughUnsupportedFiles = false,
   store,
+  isReasoningModel = false,
   hasConversation = false,
   hasPreviousResponseId = false,
   hasLocalShellTool = false,
@@ -393,6 +456,7 @@ export async function convertToOpenAIResponsesInput({
   fileIdPrefixes?: readonly string[];
   passThroughUnsupportedFiles?: boolean;
   store: boolean;
+  isReasoningModel?: boolean; // when true, stored assistant messages are only referenced together with their reasoning
   hasConversation?: boolean; // when true, skip assistant messages that already have item IDs
   hasPreviousResponseId?: boolean; // when true, skip reasoning and function-call items that already exist in the previous response chain
   hasLocalShellTool?: boolean;
@@ -652,6 +716,13 @@ export async function convertToOpenAIResponsesInput({
         const reasoningMessages: Record<string, OpenAIResponsesReasoning> = {};
         const emittedTextItemIds = new Set<string>();
 
+        // Stored messages of reasoning models are bound to the reasoning item
+        // that produced them. When the reasoning has been removed (e.g. with
+        // `pruneMessages`), referencing the message fails with "Item 'msg_...'
+        // of type 'message' was provided without its required 'reasoning'
+        // item", so it is sent with its content instead.
+        let hasPrecedingReasoning = false;
+
         for (const part of content) {
           switch (part.type) {
             case 'text': {
@@ -670,7 +741,11 @@ export async function convertToOpenAIResponsesInput({
               }
 
               // item references reduce the payload size
-              if (store && id != null) {
+              if (
+                store &&
+                id != null &&
+                (!isReasoningModel || hasPrecedingReasoning)
+              ) {
                 if (!emittedTextItemIds.has(id)) {
                   emittedTextItemIds.add(id);
                   input.push({ type: 'item_reference', id });
@@ -1039,6 +1114,33 @@ export async function convertToOpenAIResponsesInput({
                 part.toolName,
               );
 
+              if (
+                resolvedResultToolName === 'web_search' ||
+                resolvedResultToolName === 'web_search_preview'
+              ) {
+                const itemId =
+                  (
+                    part.providerOptions?.[providerOptionsName] as
+                      | { itemId?: string }
+                      | undefined
+                  )?.itemId ?? part.toolCallId;
+
+                if (store) {
+                  input.push({ type: 'item_reference', id: itemId });
+                  break;
+                }
+
+                const webSearchCall = await convertWebSearchToolResultOutput({
+                  output: part.output,
+                  id: itemId,
+                });
+
+                if (webSearchCall != null) {
+                  input.push(webSearchCall);
+                  break;
+                }
+              }
+
               if (part.toolName === toolSearchToolName) {
                 const itemId = (part.providerOptions?.[providerOptionsName]
                   ?.itemId ??
@@ -1154,6 +1256,8 @@ export async function convertToOpenAIResponsesInput({
             }
 
             case 'reasoning': {
+              hasPrecedingReasoning = true;
+
               const providerOptions = await parseProviderOptions({
                 provider: providerOptionsName,
                 providerOptions: part.providerOptions,

package/src/responses/map-openai-responses-annotation.ts

@@ -0,0 +1,75 @@
+import type {
+  LanguageModelV4Citation,
+  LanguageModelV4Source,
+} from '@ai-sdk/provider';
+import type { ResponsesTextProviderMetadata } from './openai-responses-provider-metadata';
+
+type Annotation = NonNullable<
+  ResponsesTextProviderMetadata['annotations']
+>[number];
+
+export function mapOpenAIResponsesAnnotationSource(
+  annotation: Annotation,
+  providerOptionsName: string,
+  id: string,
+): LanguageModelV4Source {
+  if (annotation.type === 'url_citation') {
+    return {
+      type: 'source',
+      sourceType: 'url',
+      id,
+      url: annotation.url,
+      title: annotation.title,
+    };
+  }
+
+  const filename =
+    annotation.type === 'file_path' ? annotation.file_id : annotation.filename;
+  return {
+    type: 'source',
+    sourceType: 'document',
+    id,
+    mediaType:
+      annotation.type === 'file_path'
+        ? 'application/octet-stream'
+        : 'text/plain',
+    title: filename,
+    filename,
+    providerMetadata: {
+      [providerOptionsName]: {
+        type: annotation.type,
+        fileId: annotation.file_id,
+        ...(annotation.type === 'container_file_citation'
+          ? { containerId: annotation.container_id }
+          : { index: annotation.index }),
+      },
+    },
+  };
+}
+
+export function mapOpenAIResponsesCitations(
+  annotations: Array<Annotation>,
+  providerOptionsName: string,
+): Array<LanguageModelV4Citation> {
+  return annotations.flatMap(annotation =>
+    annotation.type === 'file_path'
+      ? []
+      : [
+          {
+            source: mapOpenAIResponsesAnnotationSource(
+              annotation,
+              providerOptionsName,
+              annotation.type === 'url_citation'
+                ? annotation.url
+                : annotation.file_id,
+            ),
+            ...('start_index' in annotation
+              ? {
+                  startIndex: annotation.start_index,
+                  endIndex: annotation.end_index,
+                }
+              : {}),
+          },
+        ],
+  );
+}

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

@@ -177,6 +177,7 @@ export type OpenAIResponsesInputItem =
   | OpenAIResponsesApplyPatchCallOutput
   | OpenAIResponsesToolSearchCall
   | OpenAIResponsesToolSearchOutput
+  | OpenAIResponsesWebSearchCall
   | OpenAIResponsesReasoning
   | OpenAIResponsesItemReference
   | OpenAIResponsesCompactionItem
@@ -342,6 +343,13 @@ export type OpenAIResponsesProgramOutput = {
   status: 'completed' | 'incomplete';
 };
 
+export type OpenAIResponsesWebSearchCall = {
+  type: 'web_search_call';
+  id: string;
+  status: 'completed';
+  action: OpenAIResponsesWebSearchAction;
+};
+
 export type OpenAIResponsesCustomToolCall = {
   type: 'custom_tool_call';
   id?: string;