ai 7.0.154 → 7.0.155

package/docs/03-ai-sdk-core/16-mcp-tools.mdx

@@ -31,6 +31,13 @@ with `server/discover` and automatically falls back to the legacy
 `initialize` handshake for older servers. Custom transports can opt into this
 negotiation with `supportsProtocolVersionDiscovery: true`.
 
+Recognized modern protocol errors, including `-32022` (unsupported protocol
+version), do not trigger automatic fallback to `initialize`. If you know an
+endpoint requires legacy initialization, set `protocolVersionDiscovery: false`
+on `createMCPClient` to skip discovery and start with the legacy handshake.
+The server can then negotiate an older supported version in its `initialize`
+response.
+
 ### HTTP Transport (Recommended)
 
 For production deployments, we recommend using the HTTP transport. You can configure it directly on the client:

package/docs/07-reference/01-ai-sdk-core/23-create-mcp-client.mdx

@@ -201,6 +201,13 @@ experimental webhook delivery, see the [MCP Events guide](/docs/ai-sdk-core/mcp-
                 },
               ],
             },
+            {
+              name: 'protocolVersionDiscovery',
+              type: 'boolean',
+              isOptional: true,
+              description:
+                'Whether transports that support protocol discovery probe with server/discover before legacy initialization. Defaults to true. Set to false for a known legacy server to start with initialize. Recognized modern protocol errors do not trigger automatic legacy fallback.',
+            },
             {
               name: 'initializationOptions',
               type: 'RequestOptions',

package/docs/07-reference/05-ai-sdk-errors/ai-invalid-prompt-error.mdx

@@ -9,25 +9,40 @@ This error occurs when the prompt provided is invalid.
 
 ## Potential Causes
 
-### UI Messages
+### System Messages in `prompt` or `messages`
 
-You are passing a `UIMessage[]` as messages into e.g. `streamText`.
-
-You need to first convert them to a `ModelMessage[]` using `convertToModelMessages()`.
+AI SDK functions reject system messages in the `prompt` or `messages` fields to reduce the risk of prompt injection.
+Pass system instructions with the `instructions` option instead:
 
 ```typescript
-import { type UIMessage, generateText, convertToModelMessages } from 'ai';
-
-const messages: UIMessage[] = [
-  /* ... */
-];
+import { generateText } from 'ai';
 
 const result = await generateText({
   // ...
-  messages: await convertToModelMessages(messages),
+  instructions: 'You are a helpful assistant.',
+  messages,
 });
 ```
 
+If the system messages come from a trusted source, you can allow them with `allowSystemInMessages: true`.
+
+### Empty Messages
+
+The `messages` array (or a `prompt` given as an array) must contain at least one message.
+
+### Provider-Specific Prompt Requirements
+
+Some providers throw this error when a prompt can't be expressed for their API,
+for example when an assistant prefix message isn't the final message, or when a part combines options the provider doesn't support.
+The error message describes the provider requirement that wasn't met.
+
+<Note>
+  AI SDK functions do not validate the shape of `ModelMessage` objects at
+  runtime. If your messages come from an untrusted source, validate them before
+  passing them to an AI SDK function. See
+  [`ModelMessage`](/docs/reference/ai-sdk-core/model-message).
+</Note>
+
 ## Properties
 
 - `prompt`: The invalid prompt value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.154",
+  "version": "7.0.155",
   "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.127",
+    "@ai-sdk/gateway": "4.0.128",
     "@ai-sdk/provider": "4.0.34",
-    "@ai-sdk/provider-utils": "5.0.69"
+    "@ai-sdk/provider-utils": "5.0.70"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.125",
-    "@ai-sdk/deepseek": "3.0.74",
-    "@ai-sdk/google": "4.0.106",
-    "@ai-sdk/groq": "4.0.71",
-    "@ai-sdk/huggingface": "2.0.79",
-    "@ai-sdk/moonshotai": "3.0.79",
-    "@ai-sdk/openai": "4.0.103",
+    "@ai-sdk/amazon-bedrock": "5.0.126",
+    "@ai-sdk/deepseek": "3.0.75",
+    "@ai-sdk/google": "4.0.107",
+    "@ai-sdk/groq": "4.0.72",
+    "@ai-sdk/huggingface": "2.0.80",
+    "@ai-sdk/moonshotai": "3.0.80",
+    "@ai-sdk/openai": "4.0.104",
     "@ai-sdk/test-server": "2.0.4",
-    "@ai-sdk/xai": "5.0.31",
+    "@ai-sdk/xai": "5.0.32",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/batch/batch.ts

@@ -491,14 +491,6 @@ function validateBatchReference({
   batchApi: BatchV4;
   batch: BatchReference;
 }) {
-  if (batch.version !== 2) {
-    throw new InvalidArgumentError({
-      parameter: 'batch',
-      value: batch,
-      message: 'batch must be a supported batch reference',
-    });
-  }
-
   if (batch.provider !== batchApi.provider) {
     throw new InvalidArgumentError({
       parameter: 'provider',

package/src/decide/validate-decision.ts

@@ -3,7 +3,6 @@ import {
   type Experimental_DecisionModelV4Result as DecisionModelV4Result,
   type Experimental_DecisionModelV4Question as DecisionQuestion,
 } from '@ai-sdk/provider';
-import { filePartSchema, textPartSchema } from '../prompt/content-part';
 import type { DecisionState } from './decision-state';
 import { InvalidArgumentError } from '../error/invalid-argument-error';
 
@@ -17,30 +16,28 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return prototype === Object.prototype || prototype === null;
 }
 
-function isJSON(value: unknown, ancestors = new Set<object>()): boolean {
-  if (value === null || typeof value === 'string' || typeof value === 'boolean')
-    return true;
+/**
+ * Checks the JSON constraints that types cannot express: finite numbers, no
+ * cycles, and no array holes. These would otherwise be silently changed by
+ * `JSON.stringify` or make it throw.
+ */
+function isSerializableJSON(
+  value: unknown,
+  ancestors = new Set<object>(),
+): boolean {
   if (typeof value === 'number') return Number.isFinite(value);
-  if (typeof value !== 'object' || (!Array.isArray(value) && !isRecord(value)))
-    return false;
+  if (value == null || typeof value !== 'object') return true;
   if (ancestors.has(value)) return false;
   ancestors.add(value);
-  const valid =
-    Object.getOwnPropertySymbols(value).length === 0 &&
-    (Array.isArray(value)
-      ? Array.from(value).every(item => isJSON(item, ancestors))
-      : Object.values(value).every(item => isJSON(item, ancestors)));
+  const valid = Array.isArray(value)
+    ? Array.from(value.keys()).every(
+        index => index in value && isSerializableJSON(value[index], ancestors),
+      )
+    : Object.values(value).every(item => isSerializableJSON(item, ancestors));
   ancestors.delete(value);
   return valid;
 }
 
-function isInput(value: unknown): boolean {
-  return (
-    (typeof value === 'string' || Array.isArray(value) || isRecord(value)) &&
-    isJSON(value)
-  );
-}
-
 function invalidInput(
   parameter: string,
   value: unknown,
@@ -56,50 +53,43 @@ export function validateDecisionInput({
   state: DecisionState;
   questions: Readonly<Record<string, DecisionQuestion>>;
 }) {
-  const validState = Array.isArray(state)
-    ? Array.from(state).every(part => {
-        if (!isRecord(part)) return false;
-        switch (part.type) {
-          case 'text':
-            return textPartSchema.safeParse(part).success;
-          case 'file':
-            return filePartSchema.safeParse(part).success;
-          case 'json':
-            return isJSON(part.value);
-          default:
-            return false;
-        }
-      })
-    : (typeof state === 'string' || isRecord(state)) && isJSON(state);
-  if (!validState) {
+  if (
+    Array.isArray(state) &&
+    Array.from(state.keys()).some(index => !(index in state))
+  ) {
+    invalidInput('state', state, 'state parts must not contain array holes');
+  }
+
+  const stateJSON = Array.isArray(state)
+    ? state.flatMap(part => (part.type === 'json' ? [part.value] : []))
+    : state;
+  if (!isSerializableJSON(stateJSON)) {
     invalidInput(
       'state',
       state,
-      'must be a string, JSON object, or array of text, file, or json parts',
+      'JSON content must not contain non-finite numbers, cycles, or array holes',
     );
   }
-  if (!isRecord(questions) || Object.keys(questions).length === 0) {
+
+  if (Object.keys(questions).length === 0) {
     invalidInput('questions', questions, 'must be a nonempty question map');
   }
 
   for (const [id, question] of Object.entries(questions)) {
     const parameter = `questions.${id}`;
     if (
-      !isRecord(question) ||
-      ((question.type === 'box' || question.instructions != null) &&
-        !isInput(question.instructions))
+      !isSerializableJSON(question.instructions) ||
+      ('criteria' in question && !isSerializableJSON(question.criteria))
     ) {
       invalidInput(
         parameter,
         question,
-        'instructions must be a JSON-compatible string, object, or array',
+        'instructions and criteria must not contain non-finite numbers, cycles, or array holes',
       );
     }
-    if (question.type === 'box') continue;
-    const criteria = question.criteria;
     switch (question.type) {
       case 'choice':
-        if (!isRecord(criteria) || Object.keys(criteria).length === 0) {
+        if (Object.keys(question.criteria).length === 0) {
           invalidInput(
             parameter,
             question,
@@ -108,7 +98,7 @@ export function validateDecisionInput({
         }
         break;
       case 'score':
-        if (!Array.isArray(criteria) || criteria.length === 0) {
+        if (question.criteria.length === 0) {
           invalidInput(
             parameter,
             question,
@@ -116,10 +106,11 @@ export function validateDecisionInput({
           );
         }
         break;
-      case 'boolean':
+      case 'boolean': {
+        const criteria = question.criteria;
         if (
           question.instructions == null &&
-          (!isRecord(criteria) ||
+          (criteria == null ||
             !Object.values(criteria).some(value => value != null))
         ) {
           invalidInput(
@@ -128,9 +119,8 @@ export function validateDecisionInput({
             'boolean questions require instructions or at least one non-null criterion',
           );
         }
-        if (criteria === undefined) continue;
         if (
-          !isRecord(criteria) ||
+          criteria != null &&
           Object.keys(criteria).some(key => key !== 'true' && key !== 'false')
         ) {
           invalidInput(
@@ -140,22 +130,7 @@ export function validateDecisionInput({
           );
         }
         break;
-      default:
-        invalidInput(
-          parameter,
-          question,
-          'question type must be choice, score, boolean, or box',
-        );
-    }
-    if (
-      !isJSON(criteria) ||
-      Object.values(criteria).some(value => value !== null && !isInput(value))
-    ) {
-      invalidInput(
-        parameter,
-        question,
-        'criteria descriptions must be JSON-compatible strings, objects, arrays, or null',
-      );
+      }
     }
   }
 }

package/src/generate-object/validate-object-generation-input.ts

@@ -14,20 +14,6 @@ export function validateObjectGenerationInput({
   schemaDescription?: string;
   enumValues?: Array<unknown>;
 }) {
-  if (
-    output != null &&
-    output !== 'object' &&
-    output !== 'array' &&
-    output !== 'enum' &&
-    output !== 'no-schema'
-  ) {
-    throw new InvalidArgumentError({
-      parameter: 'output',
-      value: output,
-      message: 'Invalid output type.',
-    });
-  }
-
   if (output === 'no-schema') {
     if (schema != null) {
       throw new InvalidArgumentError({
@@ -63,14 +49,6 @@ export function validateObjectGenerationInput({
   }
 
   if (output === 'object') {
-    if (schema == null) {
-      throw new InvalidArgumentError({
-        parameter: 'schema',
-        value: schema,
-        message: 'Schema is required for object output.',
-      });
-    }
-
     if (enumValues != null) {
       throw new InvalidArgumentError({
         parameter: 'enumValues',
@@ -81,14 +59,6 @@ export function validateObjectGenerationInput({
   }
 
   if (output === 'array') {
-    if (schema == null) {
-      throw new InvalidArgumentError({
-        parameter: 'schema',
-        value: schema,
-        message: 'Element schema is required for array output.',
-      });
-    }
-
     if (enumValues != null) {
       throw new InvalidArgumentError({
         parameter: 'enumValues',
@@ -123,15 +93,7 @@ export function validateObjectGenerationInput({
       });
     }
 
-    if (enumValues == null) {
-      throw new InvalidArgumentError({
-        parameter: 'enumValues',
-        value: enumValues,
-        message: 'Enum values are required for enum output.',
-      });
-    }
-
-    for (const value of enumValues) {
+    for (const value of enumValues ?? []) {
       if (typeof value !== 'string') {
         throw new InvalidArgumentError({
           parameter: 'enumValues',

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

@@ -12,7 +12,6 @@ import {
   withUserAgentSuffix,
   type ProviderOptions,
 } from '@ai-sdk/provider-utils';
-import { InvalidArgumentError } from '../error/invalid-argument-error';
 import { NoSpeechGeneratedError } from '../error/no-speech-generated-error';
 import { StreamProviderError } from '../error/stream-provider-error';
 import { logWarnings } from '../logger/log-warnings';
@@ -533,23 +532,12 @@ function toSourceStream(
       iterable[Symbol.asyncIterator](),
     );
   }
-  if (
-    typeof (text as Partial<Iterable<unknown>>)?.[Symbol.iterator] ===
-    'function'
-  ) {
-    const iterable = text as Iterable<string | SpeechTextPart>;
-    return convertAsyncIteratorToReadableStream(
-      (async function* () {
-        yield* iterable;
-      })(),
-    );
-  }
-  throw new InvalidArgumentError({
-    parameter: 'text',
-    value: text,
-    message:
-      'Expected a string, an iterable or async iterable, or a ReadableStream of strings or text parts.',
-  });
+  const iterable = text as Iterable<string | SpeechTextPart>;
+  return convertAsyncIteratorToReadableStream(
+    (async function* () {
+      yield* iterable;
+    })(),
+  );
 }
 
 function toTextPart(

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

@@ -1,8 +1,5 @@
 import { delay as originalDelay, type ToolSet } from '@ai-sdk/provider-utils';
-import {
-  InvalidArgumentError,
-  type SharedV4ProviderMetadata,
-} from '@ai-sdk/provider';
+import type { SharedV4ProviderMetadata } from '@ai-sdk/provider';
 import type { TextStreamPart } from './stream-text-result';
 
 const CHUNKING_REGEXPS = {
@@ -92,16 +89,7 @@ export function smoothStream<TOOLS extends ToolSet>({
     const chunkingRegex =
       typeof chunking === 'string'
         ? CHUNKING_REGEXPS[chunking]
-        : chunking instanceof RegExp
-          ? chunking
-          : undefined;
-
-    if (chunkingRegex == null) {
-      throw new InvalidArgumentError({
-        argument: 'chunking',
-        message: `Chunking must be "word", "line", a RegExp, an Intl.Segmenter, or a ChunkDetector function. Received: ${chunking}`,
-      });
-    }
+        : (chunking as RegExp);
 
     detectChunk = buffer => {
       const lastIndex = chunkingRegex.lastIndex;

package/src/generate-text/steering.ts

@@ -135,14 +135,6 @@ class DefaultSteering implements Steering {
         ? { role: 'user', content: message }
         : message;
 
-    if (userMessage.role !== 'user') {
-      throw new InvalidArgumentError({
-        parameter: 'message',
-        value: message,
-        message: 'Steering messages must be user messages.',
-      });
-    }
-
     const outcome =
       this.state === 'ended'
         ? Promise.resolve<SteeringOutcome>({

package/src/generate-text/tool-caller-configuration.ts

@@ -47,33 +47,9 @@ export function resolveToolCallerConfiguration<TOOLS extends ToolSet>({
       });
     }
 
-    if (!Array.isArray(callers)) {
-      throw new InvalidArgumentError({
-        parameter: 'experimental_toolCallers',
-        value: toolCallers,
-        message: `callers for tool "${toolName}" must be an array.`,
-      });
+    if (callers != null) {
+      resolved[toolName] = callers;
     }
-
-    resolved[toolName] = callers.map(caller => {
-      if (caller === DIRECT_TOOL_CALL) {
-        return caller;
-      }
-
-      if (
-        typeof caller !== 'string' ||
-        !Object.prototype.hasOwnProperty.call(tools, caller) ||
-        experimental_getToolCaller(tools[caller]) == null
-      ) {
-        throw new InvalidArgumentError({
-          parameter: 'experimental_toolCallers',
-          value: toolCallers,
-          message: `tool "${toolName}" contains an invalid caller.`,
-        });
-      }
-
-      return caller;
-    });
   }
 
   return resolved;

package/src/prompt/prepare-language-model-call-options.ts

@@ -33,56 +33,6 @@ export function prepareLanguageModelCallOptions({
     }
   }
 
-  if (temperature != null) {
-    if (typeof temperature !== 'number') {
-      throw new InvalidArgumentError({
-        parameter: 'temperature',
-        value: temperature,
-        message: 'temperature must be a number',
-      });
-    }
-  }
-
-  if (topP != null) {
-    if (typeof topP !== 'number') {
-      throw new InvalidArgumentError({
-        parameter: 'topP',
-        value: topP,
-        message: 'topP must be a number',
-      });
-    }
-  }
-
-  if (topK != null) {
-    if (typeof topK !== 'number') {
-      throw new InvalidArgumentError({
-        parameter: 'topK',
-        value: topK,
-        message: 'topK must be a number',
-      });
-    }
-  }
-
-  if (presencePenalty != null) {
-    if (typeof presencePenalty !== 'number') {
-      throw new InvalidArgumentError({
-        parameter: 'presencePenalty',
-        value: presencePenalty,
-        message: 'presencePenalty must be a number',
-      });
-    }
-  }
-
-  if (frequencyPenalty != null) {
-    if (typeof frequencyPenalty !== 'number') {
-      throw new InvalidArgumentError({
-        parameter: 'frequencyPenalty',
-        value: frequencyPenalty,
-        message: 'frequencyPenalty must be a number',
-      });
-    }
-  }
-
   if (seed != null) {
     if (!Number.isInteger(seed)) {
       throw new InvalidArgumentError({

package/src/prompt/standardize-prompt.ts

@@ -1,11 +1,5 @@
 import { InvalidPromptError } from '@ai-sdk/provider';
-import {
-  asArray,
-  safeValidateTypes,
-  type ModelMessage,
-} from '@ai-sdk/provider-utils';
-import { z } from '../util/zod';
-import { modelMessageSchema } from './message';
+import type { ModelMessage } from '@ai-sdk/provider-utils';
 import type { Instructions, Prompt } from './prompt';
 
 export type StandardizedPrompt = {
@@ -21,8 +15,7 @@ export type StandardizedPrompt = {
 };
 
 /**
- * Converts a prompt input into a standardized prompt with validated model
- * messages.
+ * Converts a prompt input into a standardized prompt with model messages.
  *
  * @param prompt - The prompt definition to standardize.
  * Set `allowSystemInMessages` to true to allow system messages in the
@@ -38,42 +31,13 @@ export async function standardizePrompt({
   prompt,
   messages,
 }: Prompt): Promise<StandardizedPrompt> {
-  if (prompt == null && messages == null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: 'prompt or messages must be defined',
-    });
-  }
-
-  if (prompt != null && messages != null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: 'prompt and messages cannot be defined at the same time',
-    });
-  }
-
-  // validate that instructions is a string or a SystemModelMessage
-  if (
-    typeof instructions !== 'string' &&
-    !asArray(instructions).every(message => message.role === 'system')
-  ) {
-    throw new InvalidPromptError({
-      prompt,
-      message:
-        'instructions must be a string, SystemModelMessage, or array of SystemModelMessage',
-    });
-  }
-
-  if (prompt != null && typeof prompt === 'string') {
-    messages = [{ role: 'user', content: prompt }];
-  } else if (prompt != null && Array.isArray(prompt)) {
-    messages = prompt;
-  } else if (messages == null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: 'prompt or messages must be defined',
-    });
-  }
+  // `Prompt` requires exactly one of `prompt` or `messages`:
+  messages =
+    prompt == null
+      ? messages!
+      : typeof prompt === 'string'
+        ? [{ role: 'user', content: prompt }]
+        : prompt;
 
   if (messages.length === 0) {
     throw new InvalidPromptError({
@@ -95,18 +59,5 @@ export async function standardizePrompt({
     });
   }
 
-  const validationResult = await safeValidateTypes({
-    value: messages,
-    schema: z.array(modelMessageSchema),
-  });
-
-  if (!validationResult.success) {
-    throw new InvalidPromptError({
-      prompt,
-      message: 'The messages do not match the ModelMessage[] schema.',
-      cause: validationResult.error,
-    });
-  }
-
   return { messages, instructions };
 }

package/src/test/mock-sandbox.ts

@@ -1,10 +1,7 @@
-import type {
-  Experimental_SandboxSession,
-  Experimental_SandboxProcess,
-} from '@ai-sdk/provider-utils';
+import type { Experimental_SandboxSession } from '@ai-sdk/provider-utils';
 
 /**
- * No-op stubs for the file and spawn methods on `Experimental_SandboxSession`,
+ * File stubs and an unimplemented spawn method on `Experimental_SandboxSession`,
  * intended to be spread into test fixtures that only care about `run`.
  */
 export const mockSandboxSessionFileStubs: Pick<
@@ -23,10 +20,7 @@ export const mockSandboxSessionFileStubs: Pick<
   writeFile: async () => {},
   writeBinaryFile: async () => {},
   writeTextFile: async () => {},
-  spawn: async (): Promise<Experimental_SandboxProcess> => ({
-    stdout: new ReadableStream<Uint8Array>({ start: c => c.close() }),
-    stderr: new ReadableStream<Uint8Array>({ start: c => c.close() }),
-    wait: async () => ({ exitCode: 0 }),
-    kill: async () => {},
-  }),
+  spawn: async () => {
+    throw new Error('spawn is not implemented in this mock.');
+  },
 };