ai

Abstracts text generation across 15+ LLM providers (OpenAI, Anthropic, Google, Azure, Mistral, Cohere, etc.) through a single generateText() and streamText() API. Uses a provider-agnostic message format that normalizes differences in API schemas, token counting, and finish reasons across providers. Internally converts to provider-specific formats via adapter layers (e.g., convert-to-openai-messages.ts, convert-to-anthropic-messages.ts) and handles streaming via unified ReadableStream abstraction.

Generates JSON or structured data matching a Zod schema or TypeScript type definition using the Output API. Works by embedding the schema into the prompt or using provider-native structured output modes (OpenAI's JSON mode, Anthropic's tool_choice=required with a single tool). Validates responses against the schema and automatically retries on validation failure. Provides full TypeScript type inference so the returned object is properly typed.

Provides accurate token counting for inputs and outputs across different providers, enabling cost estimation before or after API calls. Uses provider-specific tokenizers (OpenAI's cl100k_base, Anthropic's Claude tokenizer, Google's tokenizer) to count tokens accurately. Integrates with pricing data to estimate costs. Works with both streaming and non-streaming responses.

Implements automatic retry logic with exponential backoff for transient errors (rate limits, timeouts, temporary provider outages). Distinguishes between retryable errors (429, 503) and non-retryable errors (401, 404). Configurable retry count and backoff strategy. Integrates with middleware for custom error handling and recovery logic.

Enables defining tool functions with full type safety using Zod schemas for parameter validation. Converts Zod schemas to JSON Schema for provider function calling APIs. Provides TypeScript type inference on function parameters and return types. Validates function arguments at runtime and provides detailed error messages on validation failure.

Designed to run on edge runtimes (Cloudflare Workers, Vercel Edge Functions, Deno Deploy) and serverless platforms (AWS Lambda, Google Cloud Functions) with minimal dependencies. Uses only standard Web APIs (fetch, ReadableStream, TextEncoder) to ensure compatibility. Avoids Node.js-specific APIs that aren't available in edge runtimes. Supports streaming responses in edge environments.

Enables streaming AI-generated React components to the client in real-time using React Server Components and createStreamableUI(). The LLM generates component code or descriptions, which are converted to React components and streamed to the client as they're generated. Supports progressive rendering where UI updates arrive incrementally, improving perceived performance.

Enables LLMs to call external tools (functions, APIs) through a schema-based function registry. The SDK manages the agentic loop: LLM decides which tool to call, SDK executes the tool, returns results to LLM, LLM reasons about results and calls next tool, etc. Uses provider-native function calling APIs (OpenAI's function_calling, Anthropic's tool_use) with automatic message formatting. Supports parallel tool calls, tool result streaming, and custom tool execution logic via middleware.

Provides hooks and composables for React, Vue, Svelte, and Angular that manage chat state (messages, loading, errors) and handle streaming responses from the server. The @ai-sdk/react package exports useChat() hook that manages message history, sends requests to a server endpoint, streams responses, and updates UI reactively. Similar composables exist for Vue (useChat), Svelte (createChat), and Angular. Handles optimistic message updates, automatic scroll-to-bottom, and attachment management.

The @ai-sdk/rsc package enables streaming AI responses directly from React Server Components to the client, bypassing traditional API endpoints. Uses React's experimental createStreamableUI() and createStreamableValue() APIs to stream JSX and data updates. Allows rendering AI-generated UI components on the server and streaming them to the client as they're generated, enabling real-time progressive rendering.

Supports multimodal inputs (images, videos, audio) through provider-specific APIs. For images: accepts base64, URLs, or file buffers and passes them to OpenAI Vision, Google Gemini, or Anthropic Claude with vision capabilities. For audio: transcribes via OpenAI Whisper or Google Speech-to-Text. For video: some providers support video frames or direct video input. Handles format conversion and provider-specific constraints (e.g., image size limits, supported formats).

Implements a middleware system that intercepts LLM calls and tool executions, enabling logging, monitoring, and tracing without modifying application code. Middleware receives request/response metadata (tokens, latency, cost, errors) and can send it to observability platforms (Langfuse, OpenTelemetry, custom backends). Built on a chain-of-responsibility pattern where each middleware can log, modify, or reject requests. Integrates with Vercel AI Gateway for centralized monitoring.

A managed gateway service that routes LLM requests across multiple providers, enabling automatic failover, load balancing, and cost optimization. Sits between the application and LLM providers, intercepting requests and deciding which provider to use based on cost, latency, or availability. Provides centralized monitoring, rate limiting, and caching. Requires minimal code changes; applications point to the gateway instead of individual providers.

Provides adapters that allow AI SDK models and tools to be used within LangChain and LlamaIndex ecosystems. Exposes AI SDK providers as LangChain LanguageModel objects and LlamaIndex LLM objects, enabling seamless integration with existing LangChain chains or LlamaIndex pipelines. Allows using AI SDK's unified provider abstraction within LangChain's agent framework or LlamaIndex's RAG pipeline.

Normalizes message content across different formats and providers, handling text, images, tool calls, and tool results in a unified structure. Converts between provider-specific message formats (OpenAI's content arrays, Anthropic's content blocks, Google's parts) transparently. Supports multimodal messages with mixed text and image content, and manages tool call/result message types for agentic workflows.