> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/vercel/ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Error Handling

> Learn how to handle errors in the AI SDK Core

# Error Handling

## Handling Regular Errors

Regular errors are thrown and can be handled using the `try/catch` block.

```ts highlight="3,8-10" theme={null}
import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

try {
  const { text } = await generateText({
    model: openai('gpt-4'),
    prompt: 'Write a vegetarian lasagna recipe for 4 people.',
  });
} catch (error) {
  // handle error
}
```

See [Error Types](/docs/reference/ai-sdk-errors) for more information on the different types of errors that may be thrown.

## Handling Streaming Errors (Simple Streams)

When errors occur during streams that do not support error chunks,
the error is thrown as a regular error.
You can handle these errors using the `try/catch` block.

```ts highlight="3,12-14" theme={null}
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

try {
  const { textStream } = streamText({
    model: openai('gpt-4'),
    prompt: 'Write a vegetarian lasagna recipe for 4 people.',
  });

  for await (const textPart of textStream) {
    process.stdout.write(textPart);
  }
} catch (error) {
  // handle error
}
```

## Handling Streaming Errors (Streaming with `error` Support)

Full streams support error parts.
You can handle those parts similar to other parts.
It is recommended to also add a try-catch block for errors that
happen outside of the streaming.

```ts highlight="13-21" theme={null}
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

try {
  const { fullStream } = streamText({
    model: openai('gpt-4'),
    prompt: 'Write a vegetarian lasagna recipe for 4 people.',
  });

  for await (const part of fullStream) {
    switch (part.type) {
      // ... handle other part types

      case 'error': {
        const error = part.error;
        // handle error
        break;
      }

      case 'abort': {
        // handle stream abort
        break;
      }

      case 'tool-error': {
        const error = part.error;
        // handle error
        break;
      }
    }
  }
} catch (error) {
  // handle error
}
```

## Handling Stream Aborts

When streams are aborted (e.g., via chat stop button), you may want to perform cleanup operations like updating stored messages in your UI. Use the `onAbort` callback to handle these cases.

The `onAbort` callback is called when a stream is aborted via `AbortSignal`, but `onFinish` is not called. This ensures you can still update your UI state appropriately.

```ts highlight="5-9" theme={null}
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

const { textStream } = streamText({
  model: openai('gpt-4'),
  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
  onAbort: ({ steps }) => {
    // Update stored messages or perform cleanup
    console.log('Stream aborted after', steps.length, 'steps');
  },
  onFinish: ({ steps, totalUsage }) => {
    // This is called on normal completion
    console.log('Stream completed normally');
  },
});

for await (const textPart of textStream) {
  process.stdout.write(textPart);
}
```

The `onAbort` callback receives:

* `steps`: An array of all completed steps before the abort

You can also handle abort events directly in the stream:

```ts highlight="10-13" theme={null}
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

const { fullStream } = streamText({
  model: openai('gpt-4'),
  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
});

for await (const chunk of fullStream) {
  switch (chunk.type) {
    case 'abort': {
      // Handle abort directly in stream
      console.log('Stream was aborted');
      break;
    }
    // ... handle other part types
  }
}
```

## Common Error Types

The AI SDK provides several error types to help you handle different failure scenarios:

### API Errors

* `APICallError`: Thrown when an API call fails
* `InvalidResponseDataError`: Thrown when the API response is invalid
* `EmptyResponseBodyError`: Thrown when the API returns an empty response

### Content Generation Errors

* `NoContentGeneratedError`: Thrown when no content is generated
* `NoOutputGeneratedError`: Thrown when no output is generated
* `NoImageGeneratedError`: Thrown when no image is generated
* `NoSpeechGeneratedError`: Thrown when no speech is generated
* `NoTranscriptGeneratedError`: Thrown when no transcript is generated
* `NoVideoGeneratedError`: Thrown when no video is generated

### Tool Errors

* `NoSuchToolError`: Thrown when a tool is not found
* `InvalidToolInputError`: Thrown when tool input is invalid
* `MissingToolResultsError`: Thrown when tool results are missing

### Configuration Errors

* `LoadAPIKeyError`: Thrown when loading an API key fails
* `NoSuchModelError`: Thrown when a model is not found
* `UnsupportedFunctionalityError`: Thrown when a feature is not supported

### Validation Errors

* `TypeValidationError`: Thrown when type validation fails
* `InvalidArgumentError`: Thrown when an argument is invalid

You can use `instanceof` checks to handle specific error types:

```ts theme={null}
import { generateText, NoContentGeneratedError } from 'ai';
import { openai } from '@ai-sdk/openai';

try {
  const { text } = await generateText({
    model: openai('gpt-4'),
    prompt: 'Hello',
  });
} catch (error) {
  if (NoContentGeneratedError.isInstance(error)) {
    console.error('No content was generated');
  } else {
    console.error('An unexpected error occurred');
  }
}
```