---
title: Error Handling
description: Learn how to handle errors in the AI SDK UI
url: "https://ai-sdk.dev/v5/docs/ai-sdk-ui/error-handling"
docs_index: /llms.txt
---

> For an index of all documentation, see [/llms.txt](/llms.txt).

## Warnings

The AI SDK shows warnings when something might not work as expected. These warnings help you fix problems before they cause errors.

### When Warnings Appear

Warnings are shown in the browser console when:

- **Unsupported settings**: You use a setting that the AI model doesn't support
- **Unsupported tools**: You use a tool that the AI model can't use
- **Other issues**: The AI model reports other problems

### Warning Messages

All warnings start with "AI SDK Warning:" so you can easily find them. For example:

```
AI SDK Warning: The "temperature" setting is not supported by this model
AI SDK Warning: The tool "calculator" is not supported by this model
```

### Turning Off Warnings

By default, warnings are shown in the console. You can control this behavior:

#### Turn Off All Warnings

Set a global variable to turn off warnings completely:

```ts
globalThis.AI_SDK_LOG_WARNINGS = false;
```

#### Custom Warning Handler

You can also provide your own function to handle warnings:

```ts
globalThis.AI_SDK_LOG_WARNINGS = warnings => {
  // Handle warnings your own way
  warnings.forEach(warning => {
    // Your custom logic here
    console.log('Custom warning:', warning);
  });
};
```

If your application loads multiple AI SDK versions in the same runtime, they all
share `globalThis.AI_SDK_LOG_WARNINGS`. Each version calls the logger with its own
arguments and warning types. The merged global type declarations prevent
TypeScript declaration conflicts, but do not convert these arguments at runtime.
A handler typed for only one version may therefore fail when another version
calls it.

Import the warning logger type from every installed version that can call the
logger and accept a union of their parameter types. For example, with AI SDK 5
installed as `ai` and AI SDK 6 installed under the package alias `ai-v6`
(`npm:ai@6`):

```ts
import type { Experimental_LogWarningsFunction as LogWarningsFunctionV5 } from 'ai';
import type { LogWarningsFunction as LogWarningsFunctionV6 } from 'ai-v6';

type LoggerArguments =
  | Parameters<LogWarningsFunctionV5>[0]
  | Parameters<LogWarningsFunctionV6>[0];

const logger = (args: LoggerArguments) => {
  const warnings = Array.isArray(args) ? args : args.warnings;

  for (const warning of warnings) {
    console.warn('AI SDK Warning:', warning);
  }
};

globalThis.AI_SDK_LOG_WARNINGS = logger;
```

Check the argument shape and warning type before accessing version-specific
fields. If AI SDK 7 is also installed, include its `LogWarningsFunction` parameter
type in the union.

Custom warning functions are experimental and can change in patch releases
without notice.

## Error Handling

### Error Helper Object

Each AI SDK UI hook also returns an [error](/v5/docs/reference/ai-sdk-ui/use-chat#error) object that you can use to render the error in your UI.
You can use the error object to show an error message, disable the submit button, or show a retry button.

We recommend showing a generic error message to the user, such as "Something
went wrong." This is a good practice to avoid leaking information from the
server.

```tsx title="app/page.tsx" {8,28-35,41}
'use client';

import { useChat } from '@ai-sdk/react';
import { useState } from 'react';

export default function Chat() {
  const [input, setInput] = useState('');
  const { messages, sendMessage, error, regenerate } = useChat();

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    sendMessage({ text: input });
    setInput('');
  };

  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}:{' '}
          {m.parts
            .filter(part => part.type === 'text')
            .map(part => part.text)
            .join('')}
        </div>
      ))}

      {error && (
        <>
          <div>An error occurred.</div>
          <button type="button" onClick={() => regenerate()}>
            Retry
          </button>
        </>
      )}

      <form onSubmit={handleSubmit}>
        <input
          value={input}
          onChange={e => setInput(e.target.value)}
          disabled={error != null}
        />
      </form>
    </div>
  );
}
```

#### Alternative: replace last message

Alternatively you can write a custom submit handler that replaces the last message when an error is present.

```tsx title="app/page.tsx" {13-15,17-18,35}
'use client';

import { useChat } from '@ai-sdk/react';
import { useState } from 'react';

export default function Chat() {
  const [input, setInput] = useState('');
  const { sendMessage, error, messages, setMessages } = useChat();

  function customSubmit(event: React.FormEvent<HTMLFormElement>) {
    event.preventDefault();

    if (error != null) {
      setMessages(messages.slice(0, -1)); // remove last message
    }

    sendMessage({ text: input });
    setInput('');
  }

  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}:{' '}
          {m.parts
            .filter(part => part.type === 'text')
            .map(part => part.text)
            .join('')}
        </div>
      ))}

      {error && <div>An error occurred.</div>}

      <form onSubmit={customSubmit}>
        <input value={input} onChange={e => setInput(e.target.value)} />
      </form>
    </div>
  );
}
```

### Error Handling Callback

Errors can be processed by passing an [`onError`](/v5/docs/reference/ai-sdk-ui/use-chat#on-error) callback function as an option to the [`useChat`](/v5/docs/reference/ai-sdk-ui/use-chat) or [`useCompletion`](/v5/docs/reference/ai-sdk-ui/use-completion) hooks.
The callback function receives an error object as an argument.

```tsx title="app/page.tsx" {6-9}
import { useChat } from '@ai-sdk/react';

export default function Page() {
  const {
    /* ... */
  } = useChat({
    // handle error:
    onError: error => {
      console.error(error);
    },
  });
}
```

### Injecting Errors for Testing

You might want to create errors for testing.
You can easily do so by throwing an error in your route handler:

```ts title="app/api/chat/route.ts"
export async function POST(req: Request) {
  throw new Error('This is a test error');
}
```

---

For a semantic overview of all documentation, see [/sitemap.md](/sitemap.md)

For an index of all available documentation, see [/llms.txt](/llms.txt)

For agent-facing discovery, including API and MCP surfaces, see [/agents.md](/agents.md)