ai 7.0.136 → 7.0.138

package/docs/03-ai-sdk-core/05-generating-text.mdx

@@ -703,8 +703,12 @@ const result = streamText({
 Some providers such as [Perplexity](/providers/ai-sdk-providers/perplexity#sources) and
 [Google](/providers/ai-sdk-providers/google#sources) include sources in the response.
 
-Currently sources are limited to web pages that ground the response.
-You can access them using the `sources` property of the result.
+Sources can reference URLs or documents. You can access them using the `sources`
+property of the result. For OpenAI Responses and Anthropic web search, sources
+contain the retrieved references, which can include more references than the
+model cites in its answer. OpenAI file-search results are also exposed as document
+sources when the API returns those results. If retrieval data is unavailable,
+citation-derived references remain available as sources for compatibility.
 
 Each `url` source contains the following properties:
 
@@ -759,6 +763,70 @@ for await (const part of result.stream) {
 
 The sources are also available in the `result.sources` promise.
 
+### Citations
+
+OpenAI Responses and Anthropic attach an optional `citations` array to each
+`text` content part. A citation is a reference supporting that text, independently
+of the complete retrieved source set. Use citations to render inline references;
+use `result.sources` to list retrieved sources.
+
+Each `Citation` (exported from `ai`) contains:
+
+- `source`: A URL or document source, including its title when available. Its ID
+  identifies the cited resource and does not necessarily match an ID in
+  `result.sources`.
+- `startIndex` and `endIndex`: Optional provider-supplied offsets within the
+  containing generated text; the end is exclusive. Providers can use different
+  character indexing conventions. The SDK preserves their offsets.
+- `citedText`: An optional supporting passage from the source. This is source
+  text, rather than an offset in the generated answer.
+
+For inline rendering, use the offsets within the containing text part and follow
+the provider's character indexing convention. JavaScript's `slice()` uses UTF-16
+code units, so provider offsets may need conversion when the text contains emoji
+or other characters outside the basic multilingual plane. When offsets are
+absent or cannot be interpreted reliably, render the references alongside the
+containing text block instead of guessing a range.
+
+`citedText` and provider-specific document locations identify the supporting
+evidence in the source; they do not locate the claim in the generated answer.
+Preserve query parameters and fragments in source URLs, since they can identify a
+particular version, page, or passage. Multiple citations can reference the same
+source at different locations in the generated text.
+
+Anthropic supplies supporting passages and document locations instead of output
+text offsets. Provider-specific location details remain in provider metadata.
+OpenAI file-search citation `index` values are retained in provider metadata;
+they are not interpreted as output text ranges.
+
+```ts
+for (const part of result.content) {
+  if (part.type === 'text') {
+    for (const citation of part.citations ?? []) {
+      console.log(citation.source, citation.startIndex, citation.endIndex);
+    }
+  }
+}
+```
+
+For `streamText`, citations are available on `text-end` events, associated with
+the text block's `id`, and on text parts in the completed `result.content`.
+They also survive `toUIMessageStream` as `TextUIPart.citations`, including when
+source events are disabled. Citation fallback source events can arrive at the
+end of the provider stream, after the SDK knows whether retrieval data exists.
+
+```ts
+for await (const part of result.stream) {
+  if (part.type === 'text-end') {
+    console.log(part.id, part.citations);
+  }
+}
+```
+
+Raw OpenAI annotations and Anthropic citations remain in text provider metadata.
+Other providers may omit `citations`; an omitted field does not imply that their
+sources are a complete retrieval set.
+
 ## Examples
 
 You can see `generateText` and `streamText` in action using various frameworks in the following examples:

package/docs/03-ai-sdk-core/15-tools-and-tool-calling.mdx

@@ -307,7 +307,7 @@ for (const part of result.content) {
       type: 'tool-approval-response',
       approvalId: part.approvalId,
       approved: true, // or false to deny
-      reason: 'User confirmed the command', // Optional context for the model
+      reason: 'User confirmed the command', // Optional, see below
     };
     approvals.push(response);
   }
@@ -319,6 +319,19 @@ messages.push({ role: 'tool', content: approvals });
 
 Then call `generateText` or `streamText` again with the updated messages. If approved, the tool executes. If denied, the model receives the denial and can respond accordingly.
 
+The optional `reason` is handled differently depending on the decision:
+
+- **Denied**: the reason is included in the `execution-denied` tool result, so the model can see why the tool call was not executed.
+- **Approved** (tools executed by the AI SDK): the reason remains in the approval response in your messages (e.g. for rendering in the UI or for audit logs). The SDK does not include it in the model prompt, modify the tool's input, or expose it through a dedicated execution option. The model only sees the tool result. In manual `generateText` and `streamText` continuations, the approval response is available to the tool's `execute` function through `options.messages`.
+
+<Note>
+  The approval `reason` is not a channel for passing data to an approved tool.
+  If you need input from the user (for example, an answer to a question or a
+  corrected value), use a tool without an `execute` function and provide its
+  result from the client instead. See [Chatbot Tool
+  Usage](/docs/ai-sdk-ui/chatbot-tool-usage).
+</Note>
+
 When the tool should execute without any approval metadata in the output, use
 `'not-applicable'`, return `undefined` from an approval function, or omit `toolApproval`. Use `'approved'`, `'denied'`, or
 their object forms only when you want the result to include an automatic

package/docs/04-ai-sdk-ui/03-chatbot-resume-streams.mdx

@@ -90,6 +90,28 @@ export function Chat({
 
 When you enable `resume`, the `useChat` hook makes a `GET` request to `/api/chat/[id]/stream` on mount to check for and resume any active streams.
 
+The hook also reconnects when the page becomes visible again after being in the background (for example, after switching browser tabs or returning to a mobile app). This only happens when the stream was interrupted by a network disconnect. Healthy streams and other errors are left untouched.
+
+`DefaultChatTransport` treats resumed streams as full replays by default, as
+returned by the `resumable-stream` setup below. On the first `start` chunk, the
+client resets the interrupted response and rebuilds it from the replay. This
+prevents duplicate text, reasoning, and step parts after a network disconnect.
+
+If your resume endpoint sends only the remaining chunks, set
+`resumeStreamIsReplay: false`. This preserves the interrupted response even if
+the continuation includes a `start` chunk with the same message ID:
+
+```ts
+const transport = new DefaultChatTransport({
+  resumeStreamIsReplay: false,
+});
+```
+
+When a continuation omits the `start` chunk, the client preserves its interrupted
+streaming state with either setting. Continuing active text or reasoning parts
+requires the same chat instance; a page reload does not retain that streaming
+state, so use a full replay for reloads.
+
 The default transport URL-encodes the chat ID as a single path segment. IDs equal
 to `.` or `..` are rejected with an `InvalidArgumentError` because URL parsers
 interpret them as path traversal segments.
@@ -216,7 +238,7 @@ The diagram above shows the complete lifecycle of a resumable stream:
 
 1. **Stream creation**: When you send a new message, the POST handler uses `streamText` to generate the response. The `consumeSseStream` callback creates a resumable stream with a unique ID and stores it in Redis through the `resumable-stream` package
 2. **Stream tracking**: Your persistence layer saves the `activeStreamId` in the chat data
-3. **Client reconnection**: When the client reconnects (page reload), the `resume` option triggers a GET request to `/api/chat/[id]/stream`
+3. **Client reconnection**: When the client reconnects (page reload, or returning to a backgrounded page after a network disconnect), the `resume` option triggers a GET request to `/api/chat/[id]/stream`
 4. **Stream recovery**: The GET handler checks for an `activeStreamId` and uses `resumeExistingStream` to reconnect. If no active stream exists, it returns a 204 (No Content) response
 5. **Completion cleanup**: When the stream finishes, the `onEnd` callback clears the `activeStreamId` by setting it to `null`
 

package/docs/04-ai-sdk-ui/03-chatbot-tool-usage.mdx

@@ -555,6 +555,12 @@ as `part.approval.reason`.
 For manual approval requests, the reason for requiring approval is available as
 `part.approval.requestReason`. It remains separate from an optional response
 reason supplied to `addToolApprovalResponse`.
+When a response reason is supplied with a denial, it is included in the
+`execution-denied` tool result that the model sees. When it is supplied with an
+approval for a tool executed by the AI SDK, it is recorded on the message part,
+but the SDK does not include it in the model prompt, modify the tool's input, or
+expose it through a dedicated execution option. To collect input from the user
+for a tool, use a client-side tool and `addToolOutput` instead.
 
 Approval request chunks can also include an `approvalDescriptor` with opaque
 application-specific metadata. UI message processing exposes it as

package/docs/04-ai-sdk-ui/21-error-handling.mdx

@@ -52,6 +52,40 @@ globalThis.AI_SDK_LOG_WARNINGS = ({ warnings, provider, model }) => {
 };
 ```
 
+If your application loads multiple AI SDK versions in the same runtime, they all
+share `globalThis.AI_SDK_LOG_WARNINGS`. Each version calls the logger with its own
+arguments and warning types. The merged global type declarations prevent
+TypeScript declaration conflicts, but do not convert these arguments at runtime.
+A handler typed for only one version may therefore fail when another version
+calls it.
+
+Import `LogWarningsFunction` from every installed version that can call the logger
+and accept a union of their parameter types. For example, with AI SDK 7 installed
+as `ai` and AI SDK 6 installed under the package alias `ai-v6` (`npm:ai@6`):
+
+```ts
+import type { LogWarningsFunction as LogWarningsFunctionV7 } from 'ai';
+import type { LogWarningsFunction as LogWarningsFunctionV6 } from 'ai-v6';
+
+type LoggerOptions =
+  | Parameters<LogWarningsFunctionV7>[0]
+  | Parameters<LogWarningsFunctionV6>[0];
+
+const logger = ({ warnings, provider, model }: LoggerOptions) => {
+  for (const warning of warnings) {
+    console.warn('AI SDK Warning:', warning, { provider, model });
+  }
+};
+
+globalThis.AI_SDK_LOG_WARNINGS = logger;
+```
+
+Check the argument shape and warning type before accessing version-specific
+fields. If AI SDK 5 is also installed, include its
+`Experimental_LogWarningsFunction` parameter type and use `Array.isArray` to
+handle its warning array before accessing the options object used by AI SDK 6
+and 7.
+
 ### Deprecation Warnings
 
 The default logger emits each deprecation code once per loaded SDK instance.

package/docs/07-reference/01-ai-sdk-core/01-generate-text.mdx

@@ -2157,7 +2157,8 @@ To see `generateText` in action, check out [these examples](#examples).
             {
               name: 'content',
               type: 'Array<ContentPart<TOOLS>>',
-              description: 'The content that was generated in all steps.',
+              description:
+                'The content that was generated in all steps. Text parts can include an optional citations array of references supporting that text; see Sources and Citations in the generating text guide.',
             },
             {
               name: 'providerMetadata',
@@ -2457,7 +2458,8 @@ To see `generateText` in action, check out [these examples](#examples).
     {
       name: 'content',
       type: 'Array<ContentPart<TOOLS>>',
-      description: 'The content that was generated in all steps.',
+      description:
+        'The content that was generated in all steps. Text parts can include an optional citations array of references supporting that text; see Sources and Citations in the generating text guide.',
     },
     {
       name: 'text',

package/docs/07-reference/01-ai-sdk-core/02-stream-text.mdx

@@ -2650,7 +2650,7 @@ To see `streamText` in action, check out [these examples](#examples).
       name: 'content',
       type: 'Promise<Array<ContentPart<TOOLS>>>',
       description:
-        'The content that was generated in all steps. Automatically consumes the stream.',
+        'The content that was generated in all steps. Text parts can include an optional citations array of references supporting that text. Automatically consumes the stream.',
     },
     {
       name: 'finishReason',
@@ -3352,6 +3352,16 @@ To see `streamText` in action, check out [these examples](#examples).
       description:
         'A stream with all events, including text deltas, tool calls, tool results, and errors. Well-formed mid-stream provider failures are emitted in error parts as StreamProviderError instances. You can use it as either an AsyncIterable or a ReadableStream. Only errors that stop the stream, such as network errors, are thrown.',
       properties: [
+        {
+          type: 'TextStreamTextEndPart',
+          description: 'End of a text block, including optional citations supporting that block.',
+          parameters: [
+            { name: 'type', type: "'text-end'", description: 'The event type.' },
+            { name: 'id', type: 'string', description: 'The text block ID.' },
+            { name: 'citations', type: 'Array<Citation>', isOptional: true, description: 'References supporting this text block. Each citation contains a URL or document source, optional startIndex/endIndex offsets in this block, and an optional citedText passage from the source.' },
+            { name: 'providerMetadata', type: 'ProviderMetadata', isOptional: true, description: 'Additional provider metadata, including raw annotations.' },
+          ],
+        },
         {
           type: 'TextStreamPart',
           description: 'Text content part from ContentPart<TOOLS>',

package/docs/07-reference/02-ai-sdk-ui/01-use-chat.mdx

@@ -69,6 +69,13 @@ Allows you to easily create a conversational user interface for your chatbot app
               isOptional: true,
               description: 'The API endpoint for chat requests.',
             },
+            {
+              name: 'resumeStreamIsReplay',
+              type: 'boolean',
+              isOptional: true,
+              description:
+                'Defaults to true. Resets the interrupted response on the first resumed start chunk and rebuilds it from the replay. Set to false for endpoints that only send the remaining chunks of the same response.',
+            },
             {
               name: 'credentials',
               type: 'RequestCredentials',
@@ -345,7 +352,7 @@ Allows you to easily create a conversational user interface for your chatbot app
       type: 'boolean',
       isOptional: true,
       description:
-        'Whether to resume an ongoing chat generation stream. Defaults to false.',
+        'Whether to automatically resume an ongoing chat generation stream on mount and after the page becomes visible again following a network disconnect. Defaults to false.',
     },
   ]}
 />

package/docs/07-reference/04-ai-sdk-workflow/02-workflow-chat-transport.mdx

@@ -59,7 +59,7 @@ export default function Chat() {
       type: 'number',
       isOptional: true,
       description:
-        'Maximum number of consecutive errors allowed during reconnection attempts before giving up. Default: 3.',
+        'Maximum number of consecutive errors allowed during reconnection attempts before giving up. Streams that end without receiving any UI message chunks count as errors. Default: 3.',
     },
     {
       name: 'initialStartIndex',
@@ -199,7 +199,7 @@ The transport follows this flow:
 2. **Stream** the SSE response, counting chunks as they arrive.
 3. **Detect interruption**: If the stream closes without a `finish` event (e.g., function timeout, network error), the transport knows the response is incomplete.
 4. **Reconnect** via GET to `{api}/{runId}/stream?startIndex={chunkIndex}` to resume from the last received chunk.
-5. **Retry**: If the reconnection stream also interrupts, retry up to `maxConsecutiveErrors` times.
+5. **Retry**: If the reconnection stream also interrupts, resume from the updated chunk index. Streams that end without receiving any UI message chunks count toward `maxConsecutiveErrors`, as do stream parsing errors. A successfully parsed stream that receives chunks resets the consecutive error count.
 6. **Complete**: Once a `finish` event is received, call `onChatEnd` and close the stream.
 
 ### Negative Start Index

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.136",
+  "version": "7.0.138",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.110",
-    "@ai-sdk/provider": "4.0.26",
-    "@ai-sdk/provider-utils": "5.0.58"
+    "@ai-sdk/gateway": "4.0.111",
+    "@ai-sdk/provider": "4.0.27",
+    "@ai-sdk/provider-utils": "5.0.59"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.113",
-    "@ai-sdk/deepseek": "3.0.63",
-    "@ai-sdk/google": "4.0.93",
-    "@ai-sdk/groq": "4.0.59",
-    "@ai-sdk/huggingface": "2.0.67",
-    "@ai-sdk/moonshotai": "3.0.67",
-    "@ai-sdk/openai": "4.0.91",
+    "@ai-sdk/amazon-bedrock": "5.0.114",
+    "@ai-sdk/deepseek": "3.0.64",
+    "@ai-sdk/google": "4.0.94",
+    "@ai-sdk/groq": "4.0.60",
+    "@ai-sdk/huggingface": "2.0.68",
+    "@ai-sdk/moonshotai": "3.0.68",
+    "@ai-sdk/openai": "4.0.92",
     "@ai-sdk/test-server": "2.0.4",
-    "@ai-sdk/xai": "5.0.20",
+    "@ai-sdk/xai": "5.0.21",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/decide/validate-decision.ts

@@ -253,7 +253,8 @@ export function validateDecisionAnswers({
           const selected = answer.probabilities[answer.choice];
           if (
             Object.values(answer.probabilities).some(
-              probability => probability > selected + tolerance,
+              probability =>
+                probability > selected + tolerance + 2 * probabilityError,
             )
           ) {
             invalidAnswer(

package/src/generate-text/content-part.ts

@@ -1,5 +1,6 @@
 import type { ToolSet } from '@ai-sdk/provider-utils';
 import type { ProviderMetadata } from '../types';
+import type { Citation } from '../types/citation';
 import type { Source } from '../types/language-model';
 import type { GeneratedFile } from './generated-file';
 import type { ReasoningFileOutput, ReasoningOutput } from './reasoning-output';
@@ -10,7 +11,12 @@ import type { TypedToolError } from './tool-error';
 import type { TypedToolResult } from './tool-result';
 
 export type ContentPart<TOOLS extends ToolSet> =
-  | { type: 'text'; text: string; providerMetadata?: ProviderMetadata }
+  | {
+      type: 'text';
+      text: string;
+      citations?: Array<Citation>;
+      providerMetadata?: ProviderMetadata;
+    }
   | {
       type: 'custom';
       kind: `${string}.${string}`;

package/src/generate-text/is-output-chunk.ts

@@ -0,0 +1,59 @@
+import type { ExecuteToolsStreamPart } from './execute-tools-from-stream';
+import type { StreamRetryAttemptBoundaryPart } from './stream-retry-attempt-boundary';
+
+// Chunk types that contain semantic model output. This classification is used
+// for first-content and inter-content timeouts as well as to distinguish empty
+// incomplete streams from incomplete streams with partial results. It is
+// exhaustive so that new chunk types must be classified explicitly.
+const isOutputChunkType = {
+  file: true,
+  custom: false,
+  source: false,
+  'text-start': false,
+  'text-end': false,
+  'text-delta': true,
+  'reasoning-start': false,
+  'reasoning-end': false,
+  'reasoning-delta': true,
+  'reasoning-file': true,
+  'tool-input-start': false,
+  'tool-input-end': false,
+  'tool-input-delta': true,
+  'tool-approval-request': false,
+  'tool-approval-response': false,
+  'tool-call': true,
+  'tool-result': false,
+  'tool-error': false,
+  'tool-output-denied': false,
+  'tool-execution-end': false,
+  'model-call-start': false,
+  'model-call-response-metadata': false,
+  'model-call-end': false,
+  error: false,
+  raw: false,
+} as const satisfies Record<
+  Exclude<ExecuteToolsStreamPart, StreamRetryAttemptBoundaryPart>['type'],
+  boolean
+>;
+
+export function isOutputChunk(
+  chunk: Exclude<ExecuteToolsStreamPart, StreamRetryAttemptBoundaryPart>,
+): boolean {
+  if (!isOutputChunkType[chunk.type]) {
+    return false;
+  }
+
+  switch (chunk.type) {
+    case 'text-delta':
+    case 'reasoning-delta':
+      return chunk.text.length > 0;
+    case 'tool-input-delta':
+      return chunk.delta.length > 0;
+    case 'file':
+    case 'reasoning-file':
+    case 'tool-call':
+      return true;
+    default:
+      return false;
+  }
+}

package/src/generate-text/stream-text-result.ts

@@ -1,3 +1,4 @@
+import type { Citation } from '../types/citation';
 import type { JSONObject } from '@ai-sdk/provider';
 import type { Context, IdGenerator, ToolSet } from '@ai-sdk/provider-utils';
 import type { ServerResponse } from 'node:http';
@@ -458,6 +459,7 @@ export type TextStreamTextStartPart = {
 
 export type TextStreamTextEndPart = {
   type: 'text-end';
+  citations?: Array<Citation>;
   id: string;
   providerMetadata?: ProviderMetadata;
 };

package/src/generate-text/stream-text.ts

@@ -54,6 +54,7 @@ import type {
   LanguageModel,
   ToolChoice,
 } from '../types/language-model';
+import type { Citation } from '../types/citation';
 import type { ProviderMetadata } from '../types/provider-metadata';
 import {
   addLanguageModelUsage,
@@ -89,6 +90,7 @@ import {
   executeToolsFromStream,
   type ExecuteToolsStreamPart,
 } from './execute-tools-from-stream';
+import { isOutputChunk } from './is-output-chunk';
 import { createToolSearchState } from '../tool-search/prepare-tool-search';
 import { executeToolCall } from './execute-tool-call';
 import {
@@ -175,63 +177,6 @@ const originalGenerateCallId = createIdGenerator({
   size: 24,
 });
 
-// Chunk types that contain semantic model output. This classification is used
-// for first-content and inter-content timeouts as well as to distinguish empty
-// incomplete streams from incomplete streams with partial results. It is
-// exhaustive so that new chunk types must be classified explicitly.
-const isOutputChunkType = {
-  file: true,
-  custom: false,
-  source: false,
-  'text-start': false,
-  'text-end': false,
-  'text-delta': true,
-  'reasoning-start': false,
-  'reasoning-end': false,
-  'reasoning-delta': true,
-  'reasoning-file': true,
-  'tool-input-start': false,
-  'tool-input-end': false,
-  'tool-input-delta': true,
-  'tool-approval-request': false,
-  'tool-approval-response': false,
-  'tool-call': true,
-  'tool-result': false,
-  'tool-error': false,
-  'tool-output-denied': false,
-  'tool-execution-end': false,
-  'model-call-start': false,
-  'model-call-response-metadata': false,
-  'model-call-end': false,
-  error: false,
-  raw: false,
-} as const satisfies Record<
-  Exclude<ExecuteToolsStreamPart, StreamRetryAttemptBoundaryPart>['type'],
-  boolean
->;
-
-function isOutputChunk(
-  chunk: Exclude<ExecuteToolsStreamPart, StreamRetryAttemptBoundaryPart>,
-): boolean {
-  if (!isOutputChunkType[chunk.type]) {
-    return false;
-  }
-
-  switch (chunk.type) {
-    case 'text-delta':
-    case 'reasoning-delta':
-      return chunk.text.length > 0;
-    case 'tool-input-delta':
-      return chunk.delta.length > 0;
-    case 'file':
-    case 'reasoning-file':
-    case 'tool-call':
-      return true;
-    default:
-      return false;
-  }
-}
-
 export type StreamTextInclude = {
   /**
    * Whether to retain the request body in step results.
@@ -1463,6 +1408,7 @@ class DefaultStreamTextResult<
       {
         type: 'text';
         text: string;
+        citations?: Array<Citation>;
         providerMetadata: ProviderMetadata | undefined;
       }
     > = createIdMap();
@@ -1583,6 +1529,10 @@ class DefaultStreamTextResult<
           activeText.providerMetadata =
             part.providerMetadata ?? activeText.providerMetadata;
 
+          if (part.citations != null) {
+            activeText.citations = part.citations;
+          }
+
           delete activeTextContent[part.id];
         }
 

package/src/global.ts

@@ -2,8 +2,20 @@ import type { ProviderV2, ProviderV3, ProviderV4 } from '@ai-sdk/provider';
 import type { LogWarningsFunction } from './logger/log-warnings';
 import type { Telemetry } from './telemetry/telemetry';
 
-// add AI SDK default provider to the globalThis object
+// Each installed copy contributes its own types without conflicting with other
+// versions. This is a type-only key; no symbol is created at runtime.
+declare const aiSdkGlobalsKey: unique symbol;
+
 declare global {
+  interface AISDKGlobalTypes {
+    [aiSdkGlobalsKey]: {
+      provider: ProviderV4 | ProviderV3 | ProviderV2;
+      logWarnings: LogWarningsFunction;
+      telemetry: Telemetry;
+    };
+  }
+
+  // Keep these registry-based declarations identical across major versions.
   /**
    * The default provider to use for the AI SDK.
    * String model ids are resolved to the default provider and model id.
@@ -13,7 +25,9 @@ declare global {
    *
    * @see https://ai-sdk.dev/docs/ai-sdk-core/provider-management#global-provider-configuration
    */
-  var AI_SDK_DEFAULT_PROVIDER: ProviderV4 | ProviderV3 | ProviderV2 | undefined;
+  var AI_SDK_DEFAULT_PROVIDER:
+    | AISDKGlobalTypes[keyof AISDKGlobalTypes]['provider']
+    | undefined;
 
   /**
    * The warning logger to use for the AI SDK.
@@ -23,7 +37,10 @@ declare global {
    *
    * If set to false, no warnings are logged.
    */
-  var AI_SDK_LOG_WARNINGS: LogWarningsFunction | undefined | false;
+  var AI_SDK_LOG_WARNINGS:
+    | AISDKGlobalTypes[keyof AISDKGlobalTypes]['logWarnings']
+    | undefined
+    | false;
 
   /**
    * Globally registered telemetry integrations for the AI SDK.
@@ -34,5 +51,7 @@ declare global {
    * Prefer using `registerTelemetry()` from `'ai'` instead of
    * assigning this directly.
    */
-  var AI_SDK_TELEMETRY_INTEGRATIONS: Telemetry[] | undefined;
+  var AI_SDK_TELEMETRY_INTEGRATIONS:
+    | Array<AISDKGlobalTypes[keyof AISDKGlobalTypes]['telemetry']>
+    | undefined;
 }

package/src/middleware/simulate-streaming-middleware.ts

@@ -24,7 +24,7 @@ export function simulateStreamingMiddleware(): LanguageModelMiddleware {
           for (const part of result.content) {
             switch (part.type) {
               case 'text': {
-                if (part.text.length > 0) {
+                if (part.text.length > 0 || (part.citations?.length ?? 0) > 0) {
                   controller.enqueue({
                     type: 'text-start',
                     id: String(id),
@@ -37,7 +37,13 @@ export function simulateStreamingMiddleware(): LanguageModelMiddleware {
                     id: String(id),
                     delta: part.text,
                   });
-                  controller.enqueue({ type: 'text-end', id: String(id) });
+                  controller.enqueue({
+                    type: 'text-end',
+                    id: String(id),
+                    ...(part.citations != null
+                      ? { citations: part.citations }
+                      : {}),
+                  });
                   id++;
                 }
                 break;