ai 7.0.52 → 7.0.55

package/src/batch/batch.ts

@@ -0,0 +1,336 @@
+import {
+  UnsupportedFunctionalityError,
+  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+  type Experimental_BatchV4ItemResult as BatchV4ItemResult,
+  type LanguageModelV4,
+  type LanguageModelV4GenerateResult,
+} from '@ai-sdk/provider';
+import { withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+import { logWarnings } from '../logger/log-warnings';
+import { resolveLanguageModel } from '../model/resolve-model';
+import { convertToLanguageModelPrompt } from '../prompt/convert-to-language-model-prompt';
+import { prepareLanguageModelCallOptions } from '../prompt/prepare-language-model-call-options';
+import { getTotalTimeoutMs } from '../prompt/request-options';
+import { standardizePrompt } from '../prompt/standardize-prompt';
+import { wrapGatewayError } from '../prompt/wrap-gateway-error';
+import { asLanguageModelUsage } from '../types/usage';
+import { asAsyncIterableStream } from '../util/async-iterable-stream';
+import { mergeAbortSignals } from '../util/merge-abort-signals';
+import { prepareRetries } from '../util/prepare-retries';
+import { VERSION } from '../version';
+import type {
+  BatchOperationOptions,
+  BatchReference,
+  BatchStatus,
+  StartTextBatchOptions,
+  StartTextBatchResult,
+  TextBatchGenerationResult,
+  TextBatchItemResult,
+  TextBatchRequest,
+} from './batch-types';
+
+/**
+ * Starts a durable text-generation batch.
+ */
+export async function startTextBatch({
+  model: modelArg,
+  requests,
+  providerOptions,
+  abortSignal,
+  headers,
+  timeout,
+}: StartTextBatchOptions): Promise<StartTextBatchResult> {
+  validateRequests(requests);
+
+  const model = resolveBatchLanguageModel(modelArg);
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+  );
+  const supportedUrls = await model.supportedUrls;
+  operationAbortSignal?.throwIfAborted();
+  const normalizedRequests = [];
+
+  for (const request of requests) {
+    const standardizedPrompt = await standardizePrompt(request);
+
+    normalizedRequests.push({
+      id: request.id,
+      options: {
+        ...prepareLanguageModelCallOptions(request),
+        prompt: await convertToLanguageModelPrompt({
+          prompt: standardizedPrompt,
+          supportedUrls,
+          download: undefined,
+          provider: model.provider.split('.')[0],
+        }),
+        providerOptions: request.providerOptions,
+      },
+    });
+    operationAbortSignal?.throwIfAborted();
+  }
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+  try {
+    const result = await model.experimental_doStartBatch({
+      requests: normalizedRequests,
+      providerOptions,
+      abortSignal: operationAbortSignal,
+      headers: headersWithUserAgent,
+    });
+    const { batchId, warnings, ...status } = result;
+
+    logWarnings({
+      warnings: warnings.map(({ warning }) => warning),
+      provider: model.provider,
+      model: model.modelId,
+    });
+
+    return {
+      version: 1,
+      type: 'text',
+      id: batchId,
+      provider: model.provider,
+      modelId: model.modelId,
+      ...status,
+      warnings,
+    };
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
+}
+
+/**
+ * Retrieves the latest normalized status for a durable batch.
+ */
+export async function getBatchStatus({
+  model: modelArg,
+  batch,
+  providerOptions,
+  maxRetries,
+  abortSignal,
+  headers,
+  timeout,
+}: BatchOperationOptions): Promise<BatchStatus> {
+  const model = resolveBatchLanguageModel(modelArg);
+  validateBatchReference({ model, batch });
+
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+  );
+  const { retry } = prepareRetries({
+    maxRetries,
+    abortSignal: operationAbortSignal,
+  });
+
+  try {
+    const status = await retry(() =>
+      model.experimental_doGetBatchStatus({
+        batchId: batch.id,
+        providerOptions,
+        abortSignal: operationAbortSignal,
+        headers: withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`),
+      }),
+    );
+
+    return status;
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
+}
+
+/**
+ * Streams complete terminal results for the requests in a durable batch.
+ */
+export function getBatchResults({
+  model: modelArg,
+  batch,
+  providerOptions,
+  maxRetries,
+  abortSignal,
+  headers,
+  timeout,
+}: BatchOperationOptions) {
+  const model = resolveBatchLanguageModel(modelArg);
+  validateBatchReference({ model, batch });
+
+  const streamAbortController = new AbortController();
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+    streamAbortController.signal,
+  );
+  const { retry } = prepareRetries({
+    maxRetries,
+    abortSignal: operationAbortSignal,
+  });
+  const transformer: Transformer<
+    BatchV4ItemResult<LanguageModelV4GenerateResult>,
+    TextBatchItemResult
+  > & { cancel?: (reason?: unknown) => void } = {
+    transform(item, controller) {
+      controller.enqueue(convertBatchItemResult(item));
+    },
+
+    cancel(reason) {
+      streamAbortController.abort(
+        reason ?? new Error('Batch results stream was cancelled.'),
+      );
+    },
+  };
+  const transform = new TransformStream<
+    BatchV4ItemResult<LanguageModelV4GenerateResult>,
+    TextBatchItemResult
+  >(transformer);
+
+  void (async () => {
+    try {
+      const stream = await retry(() =>
+        model.experimental_doGetBatchResults({
+          batchId: batch.id,
+          providerOptions,
+          abortSignal: operationAbortSignal,
+          headers: withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`),
+        }),
+      );
+
+      await stream.pipeTo(transform.writable, {
+        signal: operationAbortSignal,
+      });
+    } catch (error) {
+      await transform.writable.abort(wrapGatewayError(error)).catch(() => {});
+    }
+  })();
+
+  return asAsyncIterableStream(transform.readable);
+}
+
+function resolveBatchLanguageModel(
+  modelArg: StartTextBatchOptions['model'],
+): BatchLanguageModelV4 {
+  const model = resolveLanguageModel(modelArg);
+
+  if (!isBatchLanguageModel(model)) {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'batch processing',
+      message: `The ${model.provider} model "${model.modelId}" does not support batch processing.`,
+    });
+  }
+
+  return model;
+}
+
+function isBatchLanguageModel(
+  model: LanguageModelV4,
+): model is BatchLanguageModelV4 {
+  const candidate = model as Partial<BatchLanguageModelV4>;
+  return (
+    typeof candidate.experimental_doStartBatch === 'function' &&
+    typeof candidate.experimental_doGetBatchStatus === 'function' &&
+    typeof candidate.experimental_doGetBatchResults === 'function'
+  );
+}
+
+function validateRequests(requests: ReadonlyArray<TextBatchRequest>) {
+  if (requests.length === 0) {
+    throw new InvalidArgumentError({
+      parameter: 'requests',
+      value: requests,
+      message: 'requests must not be empty',
+    });
+  }
+
+  const ids = new Set<string>();
+
+  for (const request of requests) {
+    if (request.id.trim().length === 0) {
+      throw new InvalidArgumentError({
+        parameter: 'requests',
+        value: requests,
+        message: 'request IDs must not be empty',
+      });
+    }
+
+    if (ids.has(request.id)) {
+      throw new InvalidArgumentError({
+        parameter: 'requests',
+        value: requests,
+        message: `request IDs must be unique; duplicate ID "${request.id}"`,
+      });
+    }
+
+    ids.add(request.id);
+  }
+}
+
+function validateBatchReference({
+  model,
+  batch,
+}: {
+  model: BatchLanguageModelV4;
+  batch: BatchReference;
+}) {
+  if (batch.version !== 1 || batch.type !== 'text') {
+    throw new InvalidArgumentError({
+      parameter: 'batch',
+      value: batch,
+      message: 'batch must be a supported text batch reference',
+    });
+  }
+
+  if (batch.provider !== model.provider || batch.modelId !== model.modelId) {
+    throw new InvalidArgumentError({
+      parameter: 'model',
+      value: model,
+      message:
+        `model ${model.provider}:${model.modelId} is not compatible with ` +
+        `batch ${batch.provider}:${batch.modelId}`,
+    });
+  }
+}
+
+function convertBatchItemResult(
+  item: BatchV4ItemResult<LanguageModelV4GenerateResult>,
+): TextBatchItemResult {
+  if (item.status !== 'succeeded') {
+    return item;
+  }
+
+  return {
+    id: item.id,
+    status: 'succeeded',
+    ...convertGenerateResult(item.result),
+  };
+}
+
+function convertGenerateResult(
+  result: LanguageModelV4GenerateResult,
+): TextBatchGenerationResult {
+  return {
+    text: result.content
+      .filter(
+        (part): part is Extract<typeof part, { type: 'text' }> =>
+          part.type === 'text',
+      )
+      .map(part => part.text)
+      .join(''),
+    finishReason: result.finishReason.unified,
+    rawFinishReason: result.finishReason.raw,
+    usage: asLanguageModelUsage(result.usage),
+    ...(result.response != null
+      ? {
+          response: {
+            id: result.response.id,
+            timestamp: result.response.timestamp?.toISOString(),
+            modelId: result.response.modelId,
+          },
+        }
+      : {}),
+    providerMetadata: result.providerMetadata,
+  };
+}

package/src/batch/index.ts

@@ -0,0 +1,19 @@
+export {
+  startTextBatch as experimental_startTextBatch,
+  getBatchResults as experimental_getBatchResults,
+  getBatchStatus as experimental_getBatchStatus,
+} from './batch';
+export type {
+  BatchError as Experimental_BatchError,
+  BatchLanguageModel as Experimental_BatchLanguageModel,
+  BatchOperationOptions as Experimental_BatchOperationOptions,
+  BatchReference as Experimental_BatchReference,
+  BatchStatus as Experimental_BatchStatus,
+  StartTextBatchOptions as Experimental_StartTextBatchOptions,
+  StartTextBatchResult as Experimental_StartTextBatchResult,
+  TextBatch as Experimental_TextBatch,
+  TextBatchGenerationResult as Experimental_TextBatchGenerationResult,
+  TextBatchItemResult as Experimental_TextBatchItemResult,
+  TextBatchReference as Experimental_TextBatchReference,
+  TextBatchRequest as Experimental_TextBatchRequest,
+} from './batch-types';

package/src/index.ts

@@ -32,6 +32,7 @@ export {
 
 // directory exports
 export * from './agent';
+export * from './batch';
 export * from './embed';
 export * from './error';
 export * from './generate-image';

package/src/middleware/default-instructions-middleware.ts

@@ -0,0 +1,44 @@
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import { asArray } from '@ai-sdk/provider-utils';
+import type { Instructions } from '../prompt/prompt';
+import type { LanguageModelMiddleware } from '../types';
+
+/**
+ * Applies default instructions to a language model when a call does not
+ * already contain a system message.
+ */
+export function defaultInstructionsMiddleware({
+  instructions,
+}: {
+  /**
+   * Default instructions to prepend to calls that do not contain a system
+   * message.
+   */
+  instructions: Instructions;
+}): LanguageModelMiddleware {
+  const defaultSystemMessages: LanguageModelV4Prompt =
+    typeof instructions === 'string'
+      ? [{ role: 'system', content: instructions }]
+      : asArray(instructions).map(message => ({
+          role: 'system',
+          content: message.content,
+          providerOptions: message.providerOptions,
+        }));
+
+  return {
+    specificationVersion: 'v4',
+    transformParams: async ({ params }) => {
+      if (
+        defaultSystemMessages.length === 0 ||
+        params.prompt.some(message => message.role === 'system')
+      ) {
+        return params;
+      }
+
+      return {
+        ...params,
+        prompt: [...defaultSystemMessages, ...params.prompt],
+      };
+    },
+  };
+}

package/src/middleware/index.ts

@@ -1,4 +1,5 @@
 export { defaultEmbeddingSettingsMiddleware } from './default-embedding-settings-middleware';
+export { defaultInstructionsMiddleware } from './default-instructions-middleware';
 export { defaultSettingsMiddleware } from './default-settings-middleware';
 export { extractJsonMiddleware } from './extract-json-middleware';
 export { extractReasoningMiddleware } from './extract-reasoning-middleware';

package/src/ui/chat.ts

@@ -655,7 +655,10 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     try {
       const response = {
         state: createStreamingUIMessageState({
-          lastMessage: this.state.snapshot(lastMessage),
+          lastMessage:
+            trigger === 'regenerate-message'
+              ? undefined
+              : this.state.snapshot(lastMessage),
           messageId: this.generateId(),
         }),
         abortController: new AbortController(),

package/src/ui/convert-to-model-messages.ts

@@ -62,8 +62,10 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
       parts: message.parts.filter(
         part =>
           !isToolUIPart(part) ||
-          (part.state !== 'input-streaming' &&
-            part.state !== 'input-available'),
+          part.state === 'approval-responded' ||
+          part.state === 'output-available' ||
+          part.state === 'output-error' ||
+          part.state === 'output-denied',
       ),
     }));
   }

package/src/util/async-iterable-stream.ts

@@ -78,7 +78,15 @@ export function asAsyncIterableStream<T>(
           return { done: true, value: undefined };
         }
 
-        const { done, value } = await reader.read();
+        let result: ReadableStreamReadResult<T>;
+        try {
+          result = await reader.read();
+        } catch (error) {
+          await cleanup(false);
+          throw error;
+        }
+
+        const { done, value } = result;
 
         if (done) {
           await cleanup(true);