1---
2title: Common Errors
3description: Reference for common AI SDK errors and how to resolve them.
4---
5 
6# Common Errors
7 
8## `maxTokens` → `maxOutputTokens`
9 
10```typescript
11// ❌ Incorrect
12const result = await generateText({
13  model: 'anthropic/claude-opus-4.5',
14  maxTokens: 512, // deprecated: use `maxOutputTokens` instead
15  prompt: 'Write a short story',
16});
17 
18// ✅ Correct
19const result = await generateText({
20  model: 'anthropic/claude-opus-4.5',
21  maxOutputTokens: 512,
22  prompt: 'Write a short story',
23});
24```
25 
26## `maxSteps` → `stopWhen: isStepCount(n)`
27 
28```typescript
29// ❌ Incorrect
30const result = await generateText({
31  model: 'anthropic/claude-opus-4.5',
32  tools: { weather },
33  maxSteps: 5, // deprecated: use `stopWhen: isStepCount(n)` instead
34  prompt: 'What is the weather in NYC?',
35});
36 
37// ✅ Correct
38import { generateText, isStepCount } from 'ai';
39 
40const result = await generateText({
41  model: 'anthropic/claude-opus-4.5',
42  tools: { weather },
43  stopWhen: isStepCount(5),
44  prompt: 'What is the weather in NYC?',
45});
46```
47 
48## `parameters` → `inputSchema` (in tool definition)
49 
50```typescript
51// ❌ Incorrect
52const weatherTool = tool({
53  description: 'Get weather for a location',
54  parameters: z.object({
55    // deprecated: use `inputSchema` instead
56    location: z.string(),
57  }),
58  execute: async ({ location }) => ({ location, temp: 72 }),
59});
60 
61// ✅ Correct
62const weatherTool = tool({
63  description: 'Get weather for a location',
64  inputSchema: z.object({
65    location: z.string(),
66  }),
67  execute: async ({ location }) => ({ location, temp: 72 }),
68});
69```
70 
71## `generateObject` → `generateText` with `output`
72 
73`generateObject` is deprecated. Use `generateText` with the `output` option instead.
74 
75```typescript
76// ❌ Deprecated
77import { generateObject } from 'ai'; // deprecated: use `generateText` with `output` instead
78 
79const result = await generateObject({
80  // deprecated function
81  model: 'anthropic/claude-opus-4.5',
82  schema: z.object({
83    // deprecated: use `Output.object({ schema })` instead
84    recipe: z.object({
85      name: z.string(),
86      ingredients: z.array(z.string()),
87    }),
88  }),
89  prompt: 'Generate a recipe for chocolate cake',
90});
91 
92// ✅ Correct
93import { generateText, Output } from 'ai';
94 
95const result = await generateText({
96  model: 'anthropic/claude-opus-4.5',
97  output: Output.object({
98    schema: z.object({
99      recipe: z.object({
100        name: z.string(),
101        ingredients: z.array(z.string()),
102      }),
103    }),
104  }),
105  prompt: 'Generate a recipe for chocolate cake',
106});
107 
108console.log(result.output); // typed object
109```
110 
111## Manual JSON parsing → `generateText` with `output`
112 
113```typescript
114// ❌ Incorrect
115const result = await generateText({
116  model: 'anthropic/claude-opus-4.5',
117  prompt: `Extract the user info as JSON: { "name": string, "age": number }
118 
119  Input: John is 25 years old`,
120});
121const parsed = JSON.parse(result.text);
122 
123// ✅ Correct
124import { generateText, Output } from 'ai';
125 
126const result = await generateText({
127  model: 'anthropic/claude-opus-4.5',
128  output: Output.object({
129    schema: z.object({
130      name: z.string(),
131      age: z.number(),
132    }),
133  }),
134  prompt: 'Extract the user info: John is 25 years old',
135});
136 
137console.log(result.output); // { name: 'John', age: 25 }
138```
139 
140## Other `output` options
141 
142```typescript
143// Output.array - for generating arrays of items
144const result = await generateText({
145  model: 'anthropic/claude-opus-4.5',
146  output: Output.array({
147    element: z.object({
148      city: z.string(),
149      country: z.string(),
150    }),
151  }),
152  prompt: 'List 5 capital cities',
153});
154 
155// Output.choice - for selecting from predefined options
156const result = await generateText({
157  model: 'anthropic/claude-opus-4.5',
158  output: Output.choice({
159    options: ['positive', 'negative', 'neutral'] as const,
160  }),
161  prompt: 'Classify the sentiment: I love this product!',
162});
163 
164// Output.json - for untyped JSON output
165const result = await generateText({
166  model: 'anthropic/claude-opus-4.5',
167  output: Output.json(),
168  prompt: 'Return some JSON data',
169});
170```
171 
172## `toDataStreamResponse` → `createUIMessageStreamResponse`
173 
174When using `useChat` on the frontend, use `createUIMessageStreamResponse()` with `toUIMessageStream()` instead of `toDataStreamResponse()`. The UI message stream format is designed to work with the chat UI components and handles message state correctly.
175 
176```typescript
177// ❌ Incorrect (when using useChat)
178const result = streamText({
179  // config
180});
181 
182return result.toDataStreamResponse(); // deprecated for useChat: use createUIMessageStreamResponse
183 
184// ✅ Correct
185const result = streamText({
186  // config
187});
188 
189return createUIMessageStreamResponse({
190  stream: toUIMessageStream({ stream: result.stream }),
191});
192```
193 
194## Removed managed input state in `useChat`
195 
196The `useChat` hook no longer manages input state internally. You must now manage input state manually.
197 
198```tsx
199// ❌ Deprecated
200import { useChat } from '@ai-sdk/react';
201 
202export default function Page() {
203  const {
204    input, // deprecated: manage input state manually with useState
205    handleInputChange, // deprecated: use custom onChange handler
206    handleSubmit, // deprecated: use sendMessage() instead
207  } = useChat({
208    api: '/api/chat', // deprecated: use `transport: new DefaultChatTransport({ api })` instead
209  });
210 
211  return (
212    <form onSubmit={handleSubmit}>
213      <input value={input} onChange={handleInputChange} />
214      <button type="submit">Send</button>
215    </form>
216  );
217}
218 
219// ✅ Correct
220import { useChat } from '@ai-sdk/react';
221import { DefaultChatTransport } from 'ai';
222import { useState } from 'react';
223 
224export default function Page() {
225  const [input, setInput] = useState('');
226  const { sendMessage } = useChat({
227    transport: new DefaultChatTransport({ api: '/api/chat' }),
228  });
229 
230  const handleSubmit = e => {
231    e.preventDefault();
232    sendMessage({ text: input });
233    setInput('');
234  };
235 
236  return (
237    <form onSubmit={handleSubmit}>
238      <input value={input} onChange={e => setInput(e.target.value)} />
239      <button type="submit">Send</button>
240    </form>
241  );
242}
243```
244 
245## `tool-invocation` → `tool-{toolName}` (typed tool parts)
246 
247When rendering messages with `useChat`, use the typed tool part names (`tool-{toolName}`) instead of the generic `tool-invocation` type. This provides better type safety and access to tool-specific input/output types.
248 
249> For end-to-end type-safety, see [Type-Safe Agents](type-safe-agents.md).
250 
251Typed tool parts also use different property names:
252 
253- `part.args` → `part.input`
254- `part.result` → `part.output`
255 
256```tsx
257// ❌ Incorrect - using generic tool-invocation
258{
259  message.parts.map((part, i) => {
260    switch (part.type) {
261      case 'text':
262        return <div key={`${message.id}-${i}`}>{part.text}</div>;
263      case 'tool-invocation': // deprecated: use typed tool parts instead
264        return (
265          <pre key={`${message.id}-${i}`}>
266            {JSON.stringify(part.toolInvocation, null, 2)}
267          </pre>
268        );
269    }
270  });
271}
272 
273// ✅ Correct - using typed tool parts (recommended)
274{
275  message.parts.map(part => {
276    switch (part.type) {
277      case 'text':
278        return part.text;
279      case 'tool-askForConfirmation':
280        // handle askForConfirmation tool
281        break;
282      case 'tool-getWeatherInformation':
283        // handle getWeatherInformation tool
284        break;
285    }
286  });
287}
288 
289// ✅ Alternative - using isToolUIPart as a catch-all
290import { isToolUIPart } from 'ai';
291 
292{
293  message.parts.map(part => {
294    if (part.type === 'text') {
295      return part.text;
296    }
297    if (isToolUIPart(part)) {
298      // handle any tool part generically
299      return (
300        <div key={part.toolCallId}>
301          {part.toolName}: {part.state}
302        </div>
303      );
304    }
305  });
306}
307```
308 
309## `useChat` state-dependent property access
310 
311Tool part properties are only available in certain states. TypeScript will error if you access them without checking state first.
312 
313```tsx
314// ❌ Incorrect - input may be undefined during streaming
315// TS18048: 'part.input' is possibly 'undefined'
316if (part.type === 'tool-getWeather') {
317  const location = part.input.location;
318}
319 
320// ✅ Correct - check for input-available or output-available
321if (
322  part.type === 'tool-getWeather' &&
323  (part.state === 'input-available' || part.state === 'output-available')
324) {
325  const location = part.input.location;
326}
327 
328// ❌ Incorrect - output is only available after execution
329// TS18048: 'part.output' is possibly 'undefined'
330if (part.type === 'tool-getWeather') {
331  const weather = part.output;
332}
333 
334// ✅ Correct - check for output-available
335if (part.type === 'tool-getWeather' && part.state === 'output-available') {
336  const location = part.input.location;
337  const weather = part.output;
338}
339```
340 
341## `part.toolInvocation.args` → `part.input`
342 
343```tsx
344// ❌ Incorrect
345if (part.type === 'tool-invocation') {
346  // deprecated: use `part.input` on typed tool parts instead
347  const location = part.toolInvocation.args.location;
348}
349 
350// ✅ Correct
351if (
352  part.type === 'tool-getWeather' &&
353  (part.state === 'input-available' || part.state === 'output-available')
354) {
355  const location = part.input.location;
356}
357```
358 
359## `part.toolInvocation.result` → `part.output`
360 
361```tsx
362// ❌ Incorrect
363if (part.type === 'tool-invocation') {
364  // deprecated: use `part.output` on typed tool parts instead
365  const weather = part.toolInvocation.result;
366}
367 
368// ✅ Correct
369if (part.type === 'tool-getWeather' && part.state === 'output-available') {
370  const weather = part.output;
371}
372```
373 
374## `part.toolInvocation.toolCallId` → `part.toolCallId`
375 
376```tsx
377// ❌ Incorrect
378if (part.type === 'tool-invocation') {
379  // deprecated: use `part.toolCallId` on typed tool parts instead
380  const id = part.toolInvocation.toolCallId;
381}
382 
383// ✅ Correct
384if (part.type === 'tool-getWeather') {
385  const id = part.toolCallId;
386}
387```
388 
389## Tool invocation states renamed
390 
391```tsx
392// ❌ Incorrect
393switch (part.toolInvocation.state) {
394  case 'partial-call': // deprecated: use `input-streaming` instead
395    return <div>Loading...</div>;
396  case 'call': // deprecated: use `input-available` instead
397    return <div>Executing...</div>;
398  case 'result': // deprecated: use `output-available` instead
399    return <div>Done</div>;
400}
401 
402// ✅ Correct
403switch (part.state) {
404  case 'input-streaming':
405    return <div>Loading...</div>;
406  case 'input-available':
407    return <div>Executing...</div>;
408  case 'output-available':
409    return <div>Done</div>;
410}
411```
412 
413## `addToolResult` → `addToolOutput`
414 
415```tsx
416// ❌ Incorrect
417addToolResult({
418  // deprecated: use `addToolOutput` instead
419  toolCallId: part.toolInvocation.toolCallId,
420  result: 'Yes, confirmed.', // deprecated: use `output` instead
421});
422 
423// ✅ Correct
424addToolOutput({
425  tool: 'askForConfirmation',
426  toolCallId: part.toolCallId,
427  output: 'Yes, confirmed.',
428});
429```
430 
431## `messages` → `uiMessages` in `createAgentUIStreamResponse`
432 
433```typescript
434// ❌ Incorrect
435return createAgentUIStreamResponse({
436  agent: myAgent,
437  messages, // incorrect: use `uiMessages` instead
438});
439 
440// ✅ Correct
441return createAgentUIStreamResponse({
442  agent: myAgent,
443  uiMessages: messages,
444});
445```
446