ai 7.0.52 → 7.0.55

package/docs/02-foundations/02-providers-and-models.mdx

@@ -95,6 +95,7 @@ The open-source community has created the following providers:
 - [Zhipu (Z.AI) Provider](/providers/community-providers/zhipu) (`zhipu-ai-provider`)
 - [OLLM Provider](/providers/community-providers/ollm) (`@ofoundation/ollm`)
 - [ZeroEntropy Provider](/providers/community-providers/zeroentropy) (`zeroentropy-ai-provider`)
+- [Crusoe Provider](/providers/community-providers/crusoe) (`crusoe-ai-provider`)
 - [Neon AI Gateway Provider](/providers/community-providers/neon-ai-gateway) (`@neon/ai-sdk-provider`)
 
 ## Self-Hosted Models

package/docs/03-ai-sdk-core/36-transcription.mdx

@@ -327,5 +327,6 @@ try {
 | [xAI](/providers/ai-sdk-providers/xai#transcription-models)                         | `default`                |
 | [Cartesia](/providers/ai-sdk-providers/cartesia#transcription-models)               | `ink-whisper`            |
 | [Cartesia](/providers/ai-sdk-providers/cartesia#streaming-transcription-models)     | `ink-2`                  |
+| [Fish Audio](/providers/ai-sdk-providers/fish-audio#transcription-models)           | `transcribe-1`           |
 
 Above are a small subset of the transcription models supported by the AI SDK providers. For more, see the respective provider documentation.

package/docs/03-ai-sdk-core/37-speech.mdx

@@ -173,5 +173,8 @@ try {
 | [Cartesia](/providers/ai-sdk-providers/cartesia#speech-models)           | `sonic-3`                           |
 | [Cartesia](/providers/ai-sdk-providers/cartesia#speech-models)           | `sonic-2`                           |
 | [Cartesia](/providers/ai-sdk-providers/cartesia#speech-models)           | `sonic-turbo`                       |
+| [Fish Audio](/providers/ai-sdk-providers/fish-audio#speech-models)       | `s1`                                |
+| [Fish Audio](/providers/ai-sdk-providers/fish-audio#speech-models)       | `s2-pro`                            |
+| [Fish Audio](/providers/ai-sdk-providers/fish-audio#speech-models)       | `s2.1-pro`                          |
 
 Above are a small subset of the speech models supported by the AI SDK providers. For more, see the respective provider documentation.

package/docs/03-ai-sdk-core/40-middleware.mdx

@@ -57,6 +57,7 @@ The AI SDK comes with several built-in middlewares that you can use to configure
 - `extractReasoningMiddleware`: Extracts reasoning information from the generated text and exposes it as a `reasoning` property on the result.
 - `extractJsonMiddleware`: Extracts JSON from text content by stripping markdown code fences. Useful when using `Output.object()` with models that wrap JSON responses in code blocks.
 - `simulateStreamingMiddleware`: Simulates streaming behavior with responses from non-streaming language models.
+- `defaultInstructionsMiddleware`: Applies default instructions when a call does not provide its own instructions.
 - `defaultSettingsMiddleware`: Applies default settings to a language model.
 - `addToolInputExamplesMiddleware`: Adds tool input examples to tool descriptions for providers that don't natively support the `inputExamples` property.
 
@@ -159,6 +160,33 @@ const model = wrapLanguageModel({
 });
 ```
 
+### Default Instructions
+
+The `defaultInstructionsMiddleware` function applies instructions to calls that
+do not already contain a system message. Instructions provided directly on a
+call take precedence over the defaults.
+
+```ts
+import { wrapLanguageModel, defaultInstructionsMiddleware } from 'ai';
+
+const model = wrapLanguageModel({
+  model: yourModel,
+  middleware: defaultInstructionsMiddleware({
+    instructions: 'You are a concise technical assistant.',
+  }),
+});
+```
+
+The `instructions` option also accepts a `SystemModelMessage` or an array of
+`SystemModelMessage` objects when you need provider options on an instruction.
+
+<Note>
+  The middleware treats any system message in the normalized prompt as
+  call-level instructions and does not add the defaults. Only enable
+  `allowSystemInMessages` for trusted message histories, because a system
+  message in that history can override these defaults.
+</Note>
+
 ### Add Tool Input Examples
 
 The `addToolInputExamplesMiddleware` function adds tool input examples to tool descriptions.

package/docs/03-ai-sdk-core/60-telemetry.mdx

@@ -448,7 +448,8 @@ For `generateText` and `streamText`, the integration records 3 types of spans:
   - `gen_ai.provider.name`: the provider
   - `gen_ai.request.model`: the requested model ID
   - `gen_ai.request.temperature`, `gen_ai.request.max_tokens`, `gen_ai.request.top_p`, `gen_ai.request.top_k`, `gen_ai.request.frequency_penalty`, `gen_ai.request.presence_penalty`, `gen_ai.request.stop_sequences`: request parameters
-  - `gen_ai.input.messages`: the prompt messages in [GenAI SemConv message format](#genai-message-format) (when `recordInputs` is enabled)
+  - `gen_ai.system_instructions`: instructions supplied separately from the chat history, formatted as a JSON array of parts (when `recordInputs` is enabled)
+  - `gen_ai.input.messages`: the prompt messages in [GenAI SemConv message format](#genai-message-format), including system messages that are part of the chat history in their original order (when `recordInputs` is enabled)
   - `gen_ai.tool.definitions`: the tool definitions as stringified JSON (when `recordInputs` is enabled)
 
   Attributes set on finish:
@@ -537,7 +538,7 @@ Messages are JSON arrays of objects with a `role` and a `parts` array. Each part
 
 Output messages also include a `finish_reason` field (e.g. `"stop"`, `"tool_call"`, `"length"`, `"content_filter"`).
 
-System instructions are recorded separately in `gen_ai.system_instructions` as a JSON array of `{ type: "text", content: "..." }` parts.
+Instructions supplied through `instructions` (or the deprecated `system` option) are recorded separately in `gen_ai.system_instructions` as a JSON array of `{ type: "text", content: "..." }` parts. System messages supplied as chat history with `allowSystemInMessages` remain in `gen_ai.input.messages` in their original positions.
 
 ##### GenAI tool call spans
 

package/docs/07-reference/01-ai-sdk-core/68-default-instructions-middleware.mdx

@@ -0,0 +1,106 @@
+---
+title: defaultInstructionsMiddleware
+description: Middleware that applies default instructions to language model calls
+---
+
+# `defaultInstructionsMiddleware()`
+
+`defaultInstructionsMiddleware` applies default instructions to language model
+calls that do not already contain a system message. This is useful for
+configuring reusable model behavior while allowing call-level `instructions` to
+take precedence.
+
+## Import
+
+<Snippet
+  text={`import { defaultInstructionsMiddleware } from "ai"`}
+  prompt={false}
+/>
+
+## API Signature
+
+```ts
+function defaultInstructionsMiddleware(options: {
+  instructions: Instructions;
+}): LanguageModelMiddleware;
+```
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'instructions',
+      type: 'string | SystemModelMessage | Array<SystemModelMessage>',
+      isOptional: false,
+      description:
+        'Default instructions to prepend when a call does not already contain a system message.',
+    },
+  ]}
+/>
+
+### Returns
+
+Returns a
+[LanguageModelMiddleware](/docs/ai-sdk-core/middleware) that:
+
+- Prepends the configured instructions to calls without a system message.
+- Preserves instruction-level `providerOptions`.
+- Leaves calls containing any system message unchanged, so call-level
+  instructions take precedence.
+- Applies to both non-streaming and streaming language model calls.
+
+## Usage Example
+
+```ts
+import {
+  defaultInstructionsMiddleware,
+  generateText,
+  wrapLanguageModel,
+} from 'ai';
+
+const model = wrapLanguageModel({
+  model: __MODEL__,
+  middleware: defaultInstructionsMiddleware({
+    instructions: 'You are a concise technical assistant.',
+  }),
+});
+
+const defaultResult = await generateText({
+  model,
+  prompt: 'Explain HTTP caching.',
+});
+
+const overriddenResult = await generateText({
+  model,
+  instructions: 'Explain concepts for a complete beginner.',
+  prompt: 'Explain HTTP caching.',
+});
+```
+
+You can attach provider options to default instructions by using a
+`SystemModelMessage`:
+
+```ts
+const model = wrapLanguageModel({
+  model: __MODEL__,
+  middleware: defaultInstructionsMiddleware({
+    instructions: {
+      role: 'system',
+      content: 'You are a concise technical assistant.',
+      providerOptions: {
+        anthropic: {
+          cacheControl: { type: 'ephemeral' },
+        },
+      },
+    },
+  }),
+});
+```
+
+<Note>
+  This middleware provides defaults, not enforced instructions. Any system
+  message in the normalized prompt suppresses the defaults. Only use
+  `allowSystemInMessages` with trusted message histories, because an untrusted
+  system message could override the configured defaults.
+</Note>

package/docs/07-reference/01-ai-sdk-core/68-default-settings-middleware.mdx

@@ -7,6 +7,9 @@ description: Middleware that applies default settings for language models
 
 `defaultSettingsMiddleware` is a middleware function that applies default settings to language model calls. This is useful when you want to establish consistent default parameters across multiple model invocations.
 
+To apply default system instructions, use
+[`defaultInstructionsMiddleware`](/docs/reference/ai-sdk-core/default-instructions-middleware).
+
 ```ts
 import { defaultSettingsMiddleware } from 'ai';
 

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

@@ -201,6 +201,11 @@ It also contains the following helper functions:
       description: 'Applies default settings to a language model.',
       href: '/docs/reference/ai-sdk-core/default-settings-middleware',
     },
+    {
+      title: 'defaultInstructionsMiddleware()',
+      description: 'Applies default instructions to a language model.',
+      href: '/docs/reference/ai-sdk-core/default-instructions-middleware',
+    },
     {
       title: 'smoothStream()',
       description: 'Smooths text and reasoning streaming output.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.52",
+  "version": "7.0.55",
   "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,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.41",
-    "@ai-sdk/provider": "4.0.5",
-    "@ai-sdk/provider-utils": "5.0.21"
+    "@ai-sdk/gateway": "4.0.43",
+    "@ai-sdk/provider": "4.0.6",
+    "@ai-sdk/provider-utils": "5.0.23"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/agent/tool-loop-agent-settings.ts

@@ -326,6 +326,7 @@ export type ToolLoopAgentSettings<
           | 'frequencyPenalty'
           | 'stopSequences'
           | 'seed'
+          | 'reasoning'
           | 'headers'
           | 'instructions'
           | 'allowSystemInMessages'
@@ -361,6 +362,7 @@ export type ToolLoopAgentSettings<
         | 'frequencyPenalty'
         | 'stopSequences'
         | 'seed'
+        | 'reasoning'
         | 'headers'
         | 'instructions'
         | 'allowSystemInMessages'

package/src/batch/batch-types.ts

@@ -0,0 +1,134 @@
+import type {
+  Experimental_BatchV4Error as BatchV4Error,
+  Experimental_BatchV4StartResult as BatchV4StartResult,
+  Experimental_BatchV4Status as BatchV4Status,
+  Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+} from '@ai-sdk/provider';
+import type { ProviderOptions } from '@ai-sdk/provider-utils';
+import type { LanguageModelCallOptions } from '../prompt/language-model-call-options';
+import type { Prompt } from '../prompt/prompt';
+import type {
+  FinishReason,
+  GlobalProviderModelId,
+} from '../types/language-model';
+import type { ProviderMetadata } from '../types/provider-metadata';
+import type { LanguageModelUsage } from '../types/usage';
+
+/**
+ * Language model input that can be used for durable batch processing.
+ *
+ * String model IDs are resolved through the global provider and checked for
+ * batch support at runtime.
+ */
+export type BatchLanguageModel = GlobalProviderModelId | BatchLanguageModelV4;
+
+/**
+ * The persisted reference for a text batch.
+ */
+export type TextBatchReference = {
+  readonly version: 1;
+  readonly type: 'text';
+  readonly id: string;
+  readonly provider: string;
+  readonly modelId: string;
+};
+
+/**
+ * Persisted reference for any supported batch type.
+ *
+ * Additional modality-specific references can be added to this union.
+ */
+export type BatchReference = TextBatchReference;
+
+/**
+ * Serializable error information for a batch or batch item.
+ */
+export type BatchError = BatchV4Error;
+
+/**
+ * The latest normalized lifecycle status for a batch.
+ */
+export type BatchStatus = BatchV4Status;
+
+/**
+ * A text batch and its latest normalized lifecycle status.
+ */
+export type TextBatch = TextBatchReference & BatchStatus;
+
+/**
+ * One text generation request within a batch.
+ */
+export type TextBatchRequest = Prompt &
+  LanguageModelCallOptions & {
+    id: string;
+    providerOptions?: ProviderOptions;
+  };
+
+type BatchRequestOptions = {
+  abortSignal?: AbortSignal;
+  headers?: Record<string, string | undefined>;
+  timeout?: number | { totalMs?: number };
+};
+
+/**
+ * Options for starting a text batch.
+ */
+export type StartTextBatchOptions = {
+  model: BatchLanguageModel;
+  requests: ReadonlyArray<TextBatchRequest>;
+  providerOptions?: ProviderOptions;
+} & BatchRequestOptions;
+
+/**
+ * The acknowledged text batch and warnings produced while starting it.
+ */
+export type StartTextBatchResult = TextBatch & {
+  readonly warnings: BatchV4StartResult['warnings'];
+};
+
+/**
+ * Options shared by batch status and result retrieval operations.
+ */
+export type BatchOperationOptions = {
+  model: BatchLanguageModel;
+  batch: BatchReference;
+  providerOptions?: ProviderOptions;
+  maxRetries?: number;
+} & BatchRequestOptions;
+
+/**
+ * A normalized result for a successful text batch item.
+ */
+export type TextBatchGenerationResult = {
+  readonly text: string;
+  readonly finishReason: FinishReason;
+  readonly rawFinishReason?: string;
+  readonly usage: LanguageModelUsage;
+  readonly response?: {
+    readonly id?: string;
+    readonly timestamp?: string;
+    readonly modelId?: string;
+  };
+  readonly providerMetadata?: ProviderMetadata;
+};
+
+/**
+ * A complete terminal result for one request in a text batch.
+ */
+export type TextBatchItemResult =
+  | (TextBatchGenerationResult & {
+      readonly id: string;
+      readonly status: 'succeeded';
+    })
+  | {
+      readonly id: string;
+      readonly status: 'failed';
+      readonly error: BatchError;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly id: string;
+      readonly status: 'cancelled' | 'expired';
+      readonly error?: BatchError;
+      readonly providerMetadata?: ProviderMetadata;
+    };