ai 7.0.136 → 7.0.138

package/src/prompt/convert-to-language-model-prompt.ts

@@ -54,38 +54,6 @@ export async function convertToLanguageModelPrompt({
     supportedUrls,
   );
 
-  const approvalIdToToolCallId = new Map<string, string>();
-  for (const message of prompt.messages) {
-    if (message.role === 'assistant' && Array.isArray(message.content)) {
-      for (const part of message.content) {
-        if (
-          part.type === 'tool-approval-request' &&
-          'approvalId' in part &&
-          'toolCallId' in part
-        ) {
-          approvalIdToToolCallId.set(
-            part.approvalId as string,
-            part.toolCallId as string,
-          );
-        }
-      }
-    }
-  }
-
-  const approvedToolCallIds = new Set<string>();
-  for (const message of prompt.messages) {
-    if (message.role === 'tool') {
-      for (const part of message.content) {
-        if (part.type === 'tool-approval-response') {
-          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
-          if (toolCallId) {
-            approvedToolCallIds.add(toolCallId);
-          }
-        }
-      }
-    }
-  }
-
   const messages = [
     ...(prompt.instructions != null
       ? typeof prompt.instructions === 'string'
@@ -157,11 +125,6 @@ export async function convertToLanguageModelPrompt({
       }
       case 'user':
       case 'system':
-        // remove approved tool calls from the set before checking:
-        for (const id of approvedToolCallIds) {
-          toolCallIds.delete(id);
-        }
-
         if (toolCallIds.size > 0) {
           throw new MissingToolResultsError({
             toolCallIds: Array.from(toolCallIds),
@@ -171,11 +134,6 @@ export async function convertToLanguageModelPrompt({
     }
   }
 
-  // remove approved tool calls from the set before checking:
-  for (const id of approvedToolCallIds) {
-    toolCallIds.delete(id);
-  }
-
   if (toolCallIds.size > 0) {
     throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
   }

package/src/types/citation.ts

@@ -0,0 +1,31 @@
+import type { LanguageModelV4Citation } from '@ai-sdk/provider';
+import { z, type ZodType } from '../util/zod';
+import { providerMetadataSchema } from './provider-metadata';
+
+/** A reference supporting a generated text part. */
+export type Citation = LanguageModelV4Citation;
+
+export const citationSchema: ZodType<Citation> = z.object({
+  source: z.discriminatedUnion('sourceType', [
+    z.object({
+      type: z.literal('source'),
+      sourceType: z.literal('url'),
+      id: z.string(),
+      url: z.string(),
+      title: z.string().optional(),
+      providerMetadata: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('source'),
+      sourceType: z.literal('document'),
+      id: z.string(),
+      mediaType: z.string(),
+      title: z.string(),
+      filename: z.string().optional(),
+      providerMetadata: providerMetadataSchema.optional(),
+    }),
+  ]),
+  startIndex: z.number().int().nonnegative().optional(),
+  endIndex: z.number().int().nonnegative().optional(),
+  citedText: z.string().optional(),
+});

package/src/types/index.ts

@@ -1,4 +1,5 @@
 export type { JSONSchema7 } from '@ai-sdk/provider';
+export type { Citation } from './citation';
 export type { Embedding, EmbeddingModel } from './embedding-model';
 export type { EmbeddingModelMiddleware } from './embedding-model-middleware';
 export type { ImageModel, ImageModelProviderMetadata } from './image-model';

package/src/ui/chat.ts

@@ -541,6 +541,33 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     await this.makeRequest({ trigger: 'resume-stream', ...options });
   };
 
+  /**
+   * Resume the stream if the latest response ended with a resumable network
+   * disconnect. If a response is still active, wait for it to settle first so
+   * disconnects reported shortly after the caller's trigger are handled.
+   *
+   * @internal
+   */
+  '~resumeStreamIfDisconnected' = async ({
+    shouldResume = () => true,
+  }: {
+    shouldResume?: () => boolean;
+  } = {}): Promise<void> => {
+    const activeResponse = this.activeResponse;
+
+    if (this.resumableStreamState == null && activeResponse != null) {
+      await activeResponse.completionPromise;
+
+      if (this.resumableStreamState !== activeResponse.state) {
+        return;
+      }
+    }
+
+    if (this.resumableStreamState != null && shouldResume()) {
+      await this.resumeStream();
+    }
+  };
+
   /**
    * Clear the error state and set the status to ready if the chat is in an error state.
    */
@@ -635,7 +662,6 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   }) =>
     this.jobExecutor.run(async () => {
       const messages = this.state.messages;
-      const lastMessage = messages[messages.length - 1];
 
       const updatePart = (
         part: UIMessagePart<UIDataTypes, UITools>,
@@ -675,11 +701,21 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
             };
       };
 
-      // update the message to trigger an immediate UI update
-      this.state.replaceMessage(messages.length - 1, {
-        ...lastMessage,
-        parts: lastMessage.parts.map(updatePart),
-      });
+      const messageIndex = messages.findIndex(message =>
+        message.parts.some(
+          part => isToolUIPart(part) && part.toolCallId === toolCallId,
+        ),
+      );
+
+      if (messageIndex !== -1) {
+        const message = messages[messageIndex];
+
+        // update the message to trigger an immediate UI update
+        this.state.replaceMessage(messageIndex, {
+          ...message,
+          parts: message.parts.map(updatePart),
+        });
+      }
 
       // update the active response if it exists
       if (this.activeResponse) {
@@ -689,6 +725,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
 
       // automatically send the message if the sendAutomaticallyWhen function returns true
       if (
+        messageIndex !== -1 &&
         this.status !== 'streaming' &&
         this.status !== 'submitted' &&
         this.sendAutomaticallyWhen
@@ -701,7 +738,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
             () =>
               this.makeRequest({
                 trigger: 'submit-message',
-                messageId: this.lastMessage?.id,
+                messageId: messages[messageIndex].id,
                 ...options,
               }),
             shouldSend,
@@ -938,6 +975,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       responseMessageIndex === -1
         ? lastMessage
         : this.state.messages[responseMessageIndex];
+    const originalResponseMessageId = responseMessage?.id;
     // The continued stream can start with input deltas or a tool result.
     // Keep unfinished tool parts so result chunks can find their tool call.
     const resumableResponseMessage =
@@ -1028,16 +1066,28 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
                 this.setStatus({ status: 'streaming' });
               }
 
-              if (usesEarlierAssistantMessage) {
+              const existingMessageIndex = this.state.messages.findLastIndex(
+                message => message.id === response.state.message.id,
+              );
+
+              if (existingMessageIndex !== -1) {
                 this.state.replaceMessage(
-                  responseMessageIndex,
+                  existingMessageIndex,
                   response.state.message,
                 );
-              } else if (response.state.message.id === this.lastMessage?.id) {
-                this.state.replaceMessage(
-                  this.state.messages.length - 1,
-                  response.state.message,
+              } else if (usesEarlierAssistantMessage) {
+                const originalMessageIndex = this.state.messages.findLastIndex(
+                  message => message.id === originalResponseMessageId,
                 );
+
+                if (originalMessageIndex !== -1) {
+                  this.state.replaceMessage(
+                    originalMessageIndex,
+                    response.state.message,
+                  );
+                } else {
+                  this.state.pushMessage(response.state.message);
+                }
               } else {
                 this.state.pushMessage(response.state.message);
               }

package/src/ui/default-chat-transport.ts

@@ -12,8 +12,21 @@ import type { UIMessage } from './ui-messages';
 export class DefaultChatTransport<
   UI_MESSAGE extends UIMessage,
 > extends HttpChatTransport<UI_MESSAGE> {
-  constructor(options: HttpChatTransportInitOptions<UI_MESSAGE> = {}) {
+  readonly resumeStreamIsReplay: boolean;
+
+  constructor({
+    resumeStreamIsReplay = true,
+    ...options
+  }: HttpChatTransportInitOptions<UI_MESSAGE> & {
+    /**
+     * Whether resumed streams replay the response from the beginning.
+     * Defaults to true. Set to false for endpoints that only continue the
+     * interrupted response, even when they emit a start chunk.
+     */
+    resumeStreamIsReplay?: boolean;
+  } = {}) {
     super(options);
+    this.resumeStreamIsReplay = resumeStreamIsReplay;
   }
 
   protected processResponseStream(

package/src/ui/process-ui-message-stream.ts

@@ -143,6 +143,8 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
   // A transport can replay a response from the beginning using the same ID.
   resetStateOnFirstMessageStart?: boolean;
 }): ReadableStream<InferUIMessageChunk<UI_MESSAGE>> {
+  let isFirstMessageStart = true;
+
   return stream.pipeThrough(
     new TransformStream<UIMessageChunk, InferUIMessageChunk<UI_MESSAGE>>({
       async transform(chunk, controller) {
@@ -508,6 +510,9 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
                 });
               }
               textPart.state = 'done';
+              if (chunk.citations != null) {
+                textPart.citations = chunk.citations;
+              }
               textPart.providerMetadata =
                 chunk.providerMetadata ?? textPart.providerMetadata;
               delete state.activeTextParts[chunk.id];
@@ -959,20 +964,23 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             }
 
             case 'start': {
-              if (
-                chunk.messageId != null &&
-                (resetStateOnFirstMessageStart ||
-                  (resetStateOnMessageIdChange &&
-                    chunk.messageId !== state.message.id))
-              ) {
-                // Start the separate response with empty parts and metadata.
-                // Reset the active-part maps too, so earlier chunks stay with
-                // the previous response. Keep the state object for its callers.
+              const shouldReset =
+                (resetStateOnFirstMessageStart && isFirstMessageStart) ||
+                (resetStateOnMessageIdChange &&
+                  chunk.messageId != null &&
+                  chunk.messageId !== state.message.id);
+              isFirstMessageStart = false;
+
+              if (shouldReset) {
+                // Rebuild a replay or separate response from empty state. Only
+                // reset a replay once: merged streams can emit more starts.
+                // Keep the state object for its callers and preserve the ID
+                // when the replay does not include one.
                 Object.assign(
                   state,
                   createStreamingUIMessageState({
                     lastMessage: undefined,
-                    messageId: chunk.messageId,
+                    messageId: chunk.messageId ?? state.message.id,
                   }),
                   { finishReason: undefined },
                 );
@@ -984,7 +992,11 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
 
               await updateMessageMetadata(chunk.messageMetadata);
 
-              if (chunk.messageId != null || chunk.messageMetadata != null) {
+              if (
+                shouldReset ||
+                chunk.messageId != null ||
+                chunk.messageMetadata != null
+              ) {
                 write({ updateStatus: false });
               }
               break;

package/src/ui/ui-messages.ts

@@ -1,3 +1,4 @@
+import type { Citation } from '../types/citation';
 import type { JSONObject } from '@ai-sdk/provider';
 import type {
   InferToolInput,
@@ -96,6 +97,9 @@ export type UIMessagePart<
 export type TextUIPart = {
   type: 'text';
 
+  /** References supporting this text, separate from retrieved sources. */
+  citations?: Array<Citation>;
+
   /**
    * The text content.
    */

package/src/ui/validate-ui-messages.ts

@@ -1,3 +1,4 @@
+import { citationSchema } from '../types/citation';
 import { TypeValidationError, type JSONObject } from '@ai-sdk/provider';
 import {
   lazySchema,
@@ -95,6 +96,7 @@ const uiMessagesSchema = lazySchema(() => {
                 z.object({
                   type: z.literal('text'),
                   text: z.string(),
+                  citations: z.array(citationSchema).optional(),
                   state: z.enum(['streaming', 'done']).optional(),
                   providerMetadata: providerMetadataSchema.optional(),
                 }),

package/src/ui-message-stream/read-ui-message-stream.ts

@@ -95,6 +95,7 @@ export function readUIMessageStream<UI_MESSAGE extends UIMessage>({
   consumeStream({
     stream: processUIMessageStream({
       stream,
+      resetStateOnMessageIdChange: true,
       runUpdateMessageJob(
         job: (options: {
           state: StreamingUIMessageState<UI_MESSAGE>;

package/src/ui-message-stream/to-ui-message-chunk.ts

@@ -89,6 +89,7 @@ export function toUIMessageChunk<
       return {
         type: 'text-end',
         id: part.id,
+        ...(part.citations != null ? { citations: part.citations } : {}),
         ...(part.providerMetadata != null
           ? { providerMetadata: part.providerMetadata }
           : {}),

package/src/ui-message-stream/ui-message-chunks.ts

@@ -1,3 +1,4 @@
+import { citationSchema, type Citation } from '../types/citation';
 import type { JSONObject } from '@ai-sdk/provider';
 import {
   providerMetadataSchema,
@@ -37,6 +38,7 @@ export const uiMessageChunkSchema = lazySchema(() =>
       z.looseObject({
         type: z.literal('text-end'),
         id: z.string(),
+        citations: z.array(citationSchema).optional(),
         providerMetadata: providerMetadataSchema.optional(),
       }),
       z.looseObject({
@@ -246,6 +248,7 @@ export type UIMessageChunk<
     }
   | {
       type: 'text-end';
+      citations?: Array<Citation>;
       id: string;
       providerMetadata?: ProviderMetadata;
     }