@@ -0,0 +1,7 @@
+---
+'ai': patch
+---
+
+chore(ai): remove runtime validation of inputs that TypeScript types already guarantee
+
+`streamText`, `generateText`, `generateObject` and `streamObject` no longer validate messages against the `ModelMessage` schema. This removes a cost that grew linearly with message history and was paid on every `streamText` step. Type checks on call settings, steering messages, tool caller configuration, `smoothStream` chunking, `experimental_streamSpeech` text input, the shape of `decide` state and questions, and the batch reference version have also been removed. Value constraints that types cannot express, such as integer ranges, non-empty collections, unknown keys, and non-finite numbers or cycles in `decide` JSON input, are still validated.
@@ -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
 
@@ -661,18 +661,6 @@ describe('getBatchStatus', () => {
       }),
     ).rejects.toBeInstanceOf(InvalidArgumentError);
   });
-
-  it('rejects a version 1 batch reference', async () => {
-    await expect(
-      getBatchStatus({
-        provider: createMockBatchApi(),
-        batch: {
-          ...batchReference,
-          version: 1,
-        } as unknown as BatchReference,
-      }),
-    ).rejects.toBeInstanceOf(InvalidArgumentError);
-  });
 });
 
 describe('getBatchResults', () => {
 
@@ -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',
 
@@ -13,6 +13,7 @@ import type { Telemetry } from '../telemetry/telemetry';
 import { DecisionMockModelV4 } from '../test/decision-mock-model-v4';
 import { experimental_decide as decide } from '../index';
 import { VERSION } from '../version';
+import type { DecisionStatePart } from './decision-state';
 
 const questions = {
   topic: {
@@ -273,74 +274,76 @@ describe('input validation', () => {
   const cyclic: Record<string, unknown> = {};
   cyclic.self = cyclic;
   it.each([
-    null,
-    true,
-    42,
-    new Date(),
-    { value: undefined },
     { value: NaN },
-    { fn: () => true },
+    { value: Infinity },
     cyclic,
-    [undefined],
-    new Array(2),
-  ])('rejects non-JSON state %s before I/O', async state => {
+    { value: new Array(2) },
+    [{ type: 'json', value: { bad: NaN } }],
+    [{ type: 'json', value: cyclic }],
+  ])('rejects non-serializable JSON state %s before I/O', async state => {
     const { model, doDecide } = setup();
     await expect(
       decide({ model, state: state as never, questions }),
     ).rejects.toBeInstanceOf(InvalidArgumentError);
     expect(doDecide).not.toHaveBeenCalled();
   });
 
+  const outOfOrder: DecisionStatePart[] = [];
+  outOfOrder[2] = { type: 'text', text: 'third' };
+  const deleted: DecisionStatePart[] = [
+    { type: 'text', text: 'first' },
+    { type: 'json', value: {} },
+  ];
+  delete deleted[0];
+  it.each([new Array(2), outOfOrder, deleted].map(state => [state]))(
+    'rejects state parts with array holes %j before I/O',
+    async state => {
+      const { model, doDecide } = setup();
+      await expect(
+        decide({ model, state: state as never, questions }),
+      ).rejects.toBeInstanceOf(InvalidArgumentError);
+      expect(doDecide).not.toHaveBeenCalled();
+    },
+  );
+
+  it('allows repeated JSON references without treating them as cycles', async () => {
+    const shared = { text: 'hello' };
+    await expect(
+      decide({
+        ...setup(),
+        state: [{ type: 'json', value: [shared, shared] }],
+        questions,
+      }),
+    ).resolves.toBeDefined();
+  });
+
   it.each([
     {},
     [],
-    null,
-    { test: { type: 'other', instructions: 'test' } },
     { test: { type: 'boolean', instructions: null } },
-    { test: { type: 'box' } },
-    { test: { type: 'box', instructions: null } },
-    { test: { type: 'choice', instructions: 42, criteria: { a: null } } },
-    { test: { type: 'score', instructions: false, criteria: ['Low', 'High'] } },
-    {
-      test: {
-        type: 'boolean',
-        instructions: () => true,
-        criteria: { true: 'Yes' },
-      },
-    },
-    { test: { type: 'boolean', criteria: { true: 42 } } },
     { test: { type: 'boolean', criteria: { yes: 'Yes' } } },
     {
       test: { type: 'boolean', instructions: 'test', criteria: { yes: 'yes' } },
     },
-    { test: { type: 'choice', instructions: 'test', criteria: {} } },
-    { test: { type: 'choice', instructions: 'test', criteria: { a: 42 } } },
-    { test: { type: 'score', instructions: 'test', criteria: [] } },
+    {
+      test: { type: 'choice', instructions: { n: NaN }, criteria: { a: null } },
+    },
     {
       test: {
-        type: 'score',
+        type: 'choice',
         instructions: 'test',
-        criteria: ['Low', undefined],
+        criteria: { a: [Infinity] },
       },
     },
+    { test: { type: 'choice', instructions: 'test', criteria: {} } },
+    { test: { type: 'score', instructions: 'test', criteria: [] } },
   ])('rejects invalid questions %s before I/O', async invalidQuestions => {
     const { model, doDecide } = setup();
     await expect(
       decide({ model, state: 'text', questions: invalidQuestions as never }),
     ).rejects.toBeInstanceOf(InvalidArgumentError);
     expect(doDecide).not.toHaveBeenCalled();
   });
-
-  it('allows repeated JSON references without treating them as cycles', async () => {
-    const shared = { text: 'hello' };
-    await expect(
-      decide({
-        ...setup(),
-        state: [{ type: 'json', value: [shared, shared] }],
-        questions,
-      }),
-    ).resolves.toBeDefined();
-  });
 });
 
 describe('response validation', () => {
@@ -834,24 +837,6 @@ it('treats an empty array as an empty list of state parts', async () => {
   expect(doDecide.mock.calls[0][0].state).toEqual([]);
 });
 
-it.each(
-  [
-    ['legacy JSON array'],
-    [{ arbitrary: 'object' }],
-    [{ type: 'image', image: 'iVBORw==' }],
-    [{ type: 'text', text: 42 }],
-    [{ type: 'file', mediaType: 'image/png' }],
-    [{ type: 'json', value: undefined }],
-    [{ type: 'json', value: { bad: NaN } }],
-  ].map(state => [state]),
-)('rejects malformed state parts before I/O: %j', async state => {
-  const { model, doDecide } = setup();
-  await expect(
-    decide({ model, questions, state: state as never }),
-  ).rejects.toBeInstanceOf(InvalidArgumentError);
-  expect(doDecide).not.toHaveBeenCalled();
-});
-
 it('downloads image URLs and sends their bytes to the decision model', async () => {
   const { model, doDecide } = setup();
   const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);