Vercel AI SDK 7 Tutorial for Next.js and Nuxt (2026)

A hands-on Vercel AI SDK 7 tutorial with streaming chat in useChat, tools, generative UI and approvals in Next.js and Nuxt, plus a production checklist.
· 13 min read
The Vercel AI SDK is the TypeScript library most React and Vue teams reach for when they add a chat, an assistant or an agent to a product. Version 7 shipped on 25 June 2026 and renamed a good part of the API, so many tutorials written for version 5 or 6 no longer compile.
I build Nuxt and React front ends with AI features, so for this guide I built the same order-support assistant twice, in Next.js and in Nuxt 4. It streams answers, looks orders up with a tool, renders the result as a card and asks before it cancels anything. Every snippet was type-checked against ai 7.0.173, the current release at the time of writing, with @ai-sdk/react 4.0.177 and @ai-sdk/vue 4.0.173. I also ran both route handlers against the SDK's mock model, so the tool calls and approvals below behave as described.
What is the Vercel AI SDK?
The AI SDK is a free, open-source TypeScript toolkit from Vercel for building AI features and agents with any model provider. Its core calls models (text, structured output, tools, streaming), and its UI packages give React, Vue, Svelte and Angular a useChat hook that renders the streamed reply.
The key facts:
- Who makes it. Vercel. The source is at github.com/vercel/ai under the Apache-2.0 licence, and the docs live at ai-sdk.dev.
- Status. Stable, version 7, released on 25 June 2026. Vercel put it at over 16 million weekly downloads when 7 shipped.
- Requirements. Node.js 22 or newer, and ESM, since version 7 dropped CommonJS.
- Providers. OpenAI, Anthropic, Google and dozens more through provider packages. The Vercel AI Gateway provider ships inside
ai, so a plain string such as"anthropic/claude-sonnet-5.5"works with one gateway key.
| Package | What it does | Used in this guide |
|---|---|---|
ai | AI SDK Core, with streamText, generateText, tools, agents, UI message streams and the AI Gateway provider | Both apps |
@ai-sdk/react | AI SDK UI for React and Next.js, with useChat, useCompletion and useObject | Next.js |
@ai-sdk/vue | The same hooks as Vue composables | Nuxt |
@ai-sdk/svelte, @ai-sdk/angular | The same for Svelte and Angular | No |
@ai-sdk/openai, @ai-sdk/anthropic and others | Direct access to one provider, without the gateway | Optional |
zod | Schemas for tool inputs | Both apps |
Vercel also has a newer, unrelated library with a similar name, UI SDK, which builds accessible components and lets agents operate them. I covered it in Vercel UI SDK Setup Guide for Next.js and Nuxt. This post is about the AI SDK, the one that talks to models.
What's new in AI SDK 7?
AI SDK 7 is about running agents in production, with approvals, typed context, timeouts, durable runs and telemetry. It also renamed common options, which is why older tutorials break.
What it added:
- One
reasoningoption ongenerateTextandstreamText, from"none"to"max", mapped to each provider's own reasoning setting. - Typed tool context. A tool declares
contextSchema, and you pass its values per tool intoolsContext. I use it below to hand tools the signed-in user's ID. - Tool approvals with
toolApprovalongenerateText,streamTextandToolLoopAgent. You can always ask, decide per call with a function, or approve and deny automatically. Approvals can be HMAC-signed so a client can't forge one. - Durable agents.
WorkflowAgentin@ai-sdk/workflowsurvives restarts, deploys and slow approvals. - Timeouts for the whole call, each step, each chunk and each tool, which abort with a
TimeoutError. - Telemetry with
registerTelemetryand integrations such as@ai-sdk/otel. - More, mostly experimental. MCP Apps, a
HarnessAgentthat runs harnesses such as Claude Code and Codex, sandbox sessions, a terminal UI, voice and video.
If you're upgrading from version 6, these are the renames you'll hit first:
| AI SDK 6 | AI SDK 7 |
|---|---|
system: "…" | instructions: "…" |
stopWhen: stepCountIs(5) | stopWhen: isStepCount(5) |
onFinish, onStepFinish | onEnd, onStepEnd |
result.fullStream | result.stream |
return result.toUIMessageStreamResponse() | return createUIMessageStreamResponse({ stream: toUIMessageStream({ stream: result.stream }) }) |
needsApproval on the tool | toolApproval on the call |
experimental_context | context, filled from toolsContext |
new Chat() from @ai-sdk/vue | useChat() from @ai-sdk/vue |
Some old names, such as system, onFinish, toUIMessageStreamResponse() and Vue's Chat class, still work as deprecated aliases. One change can break a working app, though. System messages inside messages are now rejected unless you set allowSystemInMessages: true. The codemod handles most of the renames:
npx @ai-sdk/codemod v7
How does useChat work?
useChat keeps the conversation as an array of UI messages in the browser. On each send, it posts the whole history to /api/chat and renders the streamed reply as typed parts.
sendMessage({ text })adds the user's message and posts all messages to/api/chat.- The route handler turns them into model messages with
convertToModelMessages, callsstreamText, and streams the result back withtoUIMessageStreamandcreateUIMessageStreamResponse. - The hook appends parts to the assistant's message as they arrive, and
statusmoves fromsubmittedtostreamingtoready(orerror). - You render
message.partsin order, one branch per part type.
| Part type | What it holds |
|---|---|
text | The model's text, streamed in |
reasoning | Reasoning tokens, when the model sends them |
tool-<name> | One call of a tool you defined, such as tool-getOrder, with its input, state and output |
dynamic-tool | A tool unknown at compile time, such as one loaded from an MCP server |
data-<name> | Custom data you stream from the server |
source-url, file | Sources and files the model returns |
step-start | The boundary between two steps of a multi-step call |
Because the client sends the full history every time, the server has to treat it as untrusted input. I come back to that in the checklist.
How to set up the AI SDK in Next.js
You install three packages, add an AI Gateway key, write one route handler and one client component. These steps follow the official App Router quickstart.
1. Create the app and install the packages
You need Node.js 22 or newer.
pnpm create next-app@latest my-ai-app
cd my-ai-app
pnpm add ai @ai-sdk/react zod
2. Add your AI Gateway key
Create an API key in the AI Gateway section of your Vercel dashboard and put it in .env.local:
# .env.local
AI_GATEWAY_API_KEY=your-key
The gateway provider reads AI_GATEWAY_API_KEY on its own, so model strings such as "anthropic/claude-sonnet-5.5" just work. To call a provider directly instead, install its package (for example @ai-sdk/openai) and pass its model in place of the string.
3. Create the route handler
// app/api/chat/route.ts
import {
convertToModelMessages,
createUIMessageStreamResponse,
streamText,
toUIMessageStream,
type UIMessage,
} from "ai"
export const maxDuration = 30
export async function POST(req: Request) {
const { messages }: { messages: UIMessage[] } = await req.json()
const result = streamText({
model: "anthropic/claude-sonnet-5.5",
instructions: "You are the support assistant of an online shop. Keep answers short.",
messages: await convertToModelMessages(messages),
})
return createUIMessageStreamResponse({
stream: toUIMessageStream({ stream: result.stream }),
})
}
instructions is the system prompt (it was system before version 7). maxDuration lets the function stream for up to 30 seconds on Vercel.
4. Build the chat page
// app/page.tsx
"use client"
import { useChat } from "@ai-sdk/react"
import { useState } from "react"
export default function ChatPage() {
const [input, setInput] = useState("")
const { messages, sendMessage, status, stop, error } = useChat()
const busy = status === "submitted" || status === "streaming"
return (
<main className="mx-auto max-w-xl p-6">
{messages.map((message) => (
<div key={message.id} className="mb-4">
<strong>{message.role === "user" ? "You" : "Assistant"}</strong>
{message.parts.map((part, i) =>
part.type === "text" ? <p key={i}>{part.text}</p> : null,
)}
</div>
))}
{error && <p role="alert">Something went wrong. Please try again.</p>}
<form
onSubmit={(e) => {
e.preventDefault()
if (!input.trim()) return
sendMessage({ text: input })
setInput("")
}}
>
<input
value={input}
onChange={(e) => setInput(e.target.value)}
placeholder="Ask about an order"
/>
{busy ? (
<button type="button" onClick={() => stop()}>Stop</button>
) : (
<button type="submit">Send</button>
)}
</form>
</main>
)
}
useChat posts to /api/chat by default, so there's nothing to configure. The hook no longer manages the input for you, as it did before version 5, which is why the page keeps it in useState. Run pnpm dev, open http://localhost:3000, and the reply streams in word by word.
How to add tools to an AI SDK chatbot
A tool is a function the model can decide to call. You define it with tool() (a description, a Zod input schema and an execute function), pass it to streamText, and set stopWhen so the model can answer after it sees the result.
1. Stand in for your database
The assistant needs orders to look up. In a real app, this is your database. For the tutorial, an in-memory map does:
// lib/orders.ts: an in-memory stand-in for your database
export type Order = {
id: string
status: "processing" | "shipped" | "delivered"
total: string
eta: string
}
const orders: Record<string, Order & { userId: string }> = {
A1001: { id: "A1001", userId: "u_1", status: "processing", total: "€84.00", eta: "Thursday" },
}
export async function findOrder(userId: string, orderId: string): Promise<Order | undefined> {
const order = orders[orderId]
if (!order || order.userId !== userId) return undefined
return { id: order.id, status: order.status, total: order.total, eta: order.eta }
}
export async function cancelOrder(userId: string, orderId: string): Promise<boolean> {
const order = orders[orderId]
if (!order || order.userId !== userId || order.status !== "processing") return false
delete orders[orderId]
return true
}
Both functions take the user's ID, so nobody reaches someone else's orders.
2. Define the tools
// lib/ai/tools.ts
import { tool, type InferUITools, type UIDataTypes, type UIMessage } from "ai"
import { z } from "zod"
import { cancelOrder, findOrder } from "@/lib/orders"
const userContext = z.object({ userId: z.string() })
export const tools = {
getOrder: tool({
description: "Look up an order by its number. The user sees the result as a card.",
inputSchema: z.object({
orderId: z.string().describe("The order number, for example A1001"),
}),
contextSchema: userContext,
execute: async ({ orderId }, { context }) => {
const order = await findOrder(context.userId, orderId)
if (!order) throw new Error(`No order ${orderId} on this account.`)
return order
},
}),
cancelOrder: tool({
description: "Cancel an order that hasn't shipped yet.",
inputSchema: z.object({ orderId: z.string() }),
contextSchema: userContext,
execute: async ({ orderId }, { context }) => {
const cancelled = await cancelOrder(context.userId, orderId)
return { orderId, cancelled }
},
}),
}
export type ChatMessage = UIMessage<never, UIDataTypes, InferUITools<typeof tools>>
The model chooses orderId, but never userId. That arrives through context, which your server fills in, so a prompt like "show me order A1002" can't reach another customer's order.
ChatMessage is the message type with your tools in it. Pass it to useChat, and every tool part knows its input and output types.
3. Use the tools in the route handler
// app/api/chat/route.ts
import {
convertToModelMessages,
createUIMessageStreamResponse,
isStepCount,
streamText,
toUIMessageStream,
validateUIMessages,
} from "ai"
import { tools, type ChatMessage } from "@/lib/ai/tools"
import { getUserId } from "@/lib/auth"
export const maxDuration = 30
export async function POST(req: Request) {
const userId = await getUserId(req)
if (!userId) return new Response("Unauthorized", { status: 401 })
const body = await req.json()
const messages = await validateUIMessages<ChatMessage>({ messages: body.messages, tools })
const result = streamText({
model: "anthropic/claude-sonnet-5.5",
instructions:
"You are the support assistant of an online shop. Use the tools to look up and cancel orders. Keep answers short.",
messages: await convertToModelMessages(messages),
tools,
toolsContext: {
getOrder: { userId },
cancelOrder: { userId },
},
toolApproval: { cancelOrder: "user-approval" },
stopWhen: isStepCount(5),
})
return createUIMessageStreamResponse({
stream: toUIMessageStream({ stream: result.stream }),
})
}
What changed from the first version:
getUserIdstands for your auth (Auth.js, Clerk, Supabase or your own session). Without a user there is no chat.validateUIMessageschecks the history the client sent, including every tool part, against your tools' schemas.toolsContextgives each tool the user's ID.toolApprovalmakescancelOrderwait for the user. More on that below.stopWhen: isStepCount(5)lets the model call a tool, read the result and keep going, for up to five steps. Without it, the reply ends at the tool call and the user sees no answer.
How to render generative UI from tool results
In AI SDK UI, generative UI means rendering your own components from tool parts. Each tool call reaches the client as a tool-<name> part, and you show something for each of its states, such as a spinner while it runs, a component when the output arrives and an error when it fails.
| State | When | What I render |
|---|---|---|
input-streaming | The model is still writing the tool's input | A placeholder |
input-available | The input is complete and the tool is running | "Looking up the order…" |
approval-requested | The tool needs a person's approval first | Approve and deny buttons |
approval-responded | The person answered, the tool hasn't finished | A short status |
output-available | The tool returned | The component, built from part.output |
output-error | The tool threw or its input was invalid | part.errorText |
output-denied | The approval was refused | "Order kept." |
The component is plain React. It knows nothing about AI:
// components/order-card.tsx
import type { Order } from "@/lib/orders"
export function OrderCard({ order }: { order: Order }) {
return (
<article className="rounded-lg border p-4">
<h3 className="font-semibold">Order {order.id}</h3>
<p>{order.status === "delivered" ? "Delivered" : `Arrives ${order.eta}`}</p>
<p>Total: {order.total}</p>
</article>
)
}
The page renders each part by its type and state:
// app/page.tsx
"use client"
import { useChat } from "@ai-sdk/react"
import { lastAssistantMessageIsCompleteWithApprovalResponses } from "ai"
import { useState } from "react"
import { OrderCard } from "@/components/order-card"
import type { ChatMessage } from "@/lib/ai/tools"
export default function ChatPage() {
const [input, setInput] = useState("")
const { messages, sendMessage, addToolApprovalResponse, status, stop } = useChat<ChatMessage>({
sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithApprovalResponses,
})
const busy = status === "submitted" || status === "streaming"
return (
<main className="mx-auto max-w-xl p-6">
{messages.map((message) => (
<div key={message.id} className="mb-4">
<strong>{message.role === "user" ? "You" : "Assistant"}</strong>
{message.parts.map((part, i) => {
const key = `${message.id}-${i}`
switch (part.type) {
case "text":
return <p key={key}>{part.text}</p>
case "tool-getOrder":
if (part.state === "output-available") {
return <OrderCard key={key} order={part.output} />
}
if (part.state === "output-error") {
return <p key={key} role="alert">{part.errorText}</p>
}
return <p key={key}>Looking up the order…</p>
case "tool-cancelOrder":
if (part.state === "approval-requested") {
return (
<div key={key}>
<p>Cancel order {part.input.orderId}?</p>
<button onClick={() => addToolApprovalResponse({ id: part.approval.id, approved: true })}>
Cancel it
</button>
<button onClick={() => addToolApprovalResponse({ id: part.approval.id, approved: false })}>
Keep it
</button>
</div>
)
}
if (part.state === "output-available") {
return (
<p key={key}>
{part.output.cancelled
? `Order ${part.output.orderId} is cancelled.`
: "That order can no longer be cancelled."}
</p>
)
}
if (part.state === "output-denied") return <p key={key}>Order kept.</p>
return null
default:
return null
}
})}
</div>
))}
<form
onSubmit={(e) => {
e.preventDefault()
if (!input.trim()) return
sendMessage({ text: input })
setInput("")
}}
>
<input value={input} onChange={(e) => setInput(e.target.value)} placeholder="Ask about an order" />
{busy ? (
<button type="button" onClick={() => stop()}>Stop</button>
) : (
<button type="submit">Send</button>
)}
</form>
</main>
)
}
Thanks to useChat<ChatMessage>, TypeScript knows that part.output is an Order in the tool-getOrder branch and that part.input.orderId is a string. When I used the output with the wrong type on purpose, the type check failed, which is what you want when tools and UI change separately.
Ask "Where's order A1001?" and the model calls getOrder, the card replaces the placeholder, and a second step adds a sentence such as "It arrives on Thursday."
You don't need a component library for this. Vercel's AI Elements, a set of chat components built on shadcn/ui, is moving to shadcn/ui and will be deprecated at the end of November 2026, so I'd build on your own components or on shadcn/ui directly.
How to ask for approval before a tool runs
Set toolApproval: { cancelOrder: "user-approval" } on streamText. The tool part then stops in the approval-requested state. Your UI calls addToolApprovalResponse, and useChat sends the answer back so the server runs, or skips, the tool.
This is what happens when the user types "Cancel it":
- The model calls
cancelOrder. The server doesn't run it, and streams atool-cancelOrderpart in theapproval-requestedstate. - The page shows "Cancel order A1001?" with two buttons.
- A click calls
addToolApprovalResponse({ id: part.approval.id, approved }), and the part moves toapproval-responded. - Because of
sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithApprovalResponses,useChatposts the conversation again on its own. - The server sees the approval and runs the tool, or, if it was denied, tells the model the call was refused. The model then writes its answer in the same assistant message.
I tested this flow with the mock model. The order still existed while the part sat in approval-requested, and it was deleted only after the approval came back.
toolApproval takes more than "user-approval". A function per tool can approve small cases automatically and forward the rest to the user, and automatic decisions show up in the same states, with part.approval.isAutomatic set.
There's one catch. The client sends the whole history on every request, so a modified client could fabricate an approval. For anything that moves money or deletes data, add experimental_toolApprovalSecret (shown in the checklist) so the server only accepts approvals it signed. Approvals are also how I'd gate tools that write through an MCP server, which I covered in MCP servers for SaaS. The AI SDK can use any MCP server's tools through createMCPClient from @ai-sdk/mcp.
How to set up the AI SDK in Nuxt
Nuxt uses the same server code with an h3 handler, and @ai-sdk/vue provides useChat as a Vue composable. The tools and the message type don't change.
1. Create the app and install the packages
pnpm create nuxt my-ai-app
cd my-ai-app
pnpm add ai @ai-sdk/vue zod
2. Put the key in runtime config
# .env
NUXT_AI_GATEWAY_API_KEY=your-key
// nuxt.config.ts
export default defineNuxtConfig({
runtimeConfig: {
aiGatewayApiKey: "", // filled from NUXT_AI_GATEWAY_API_KEY
},
})
The NUXT_ prefix lets Nuxt override runtimeConfig.aiGatewayApiKey at runtime, so the key is never in the client bundle.
3. Move the tools to the server
Copy lib/orders.ts and lib/ai/tools.ts from the Next.js section to server/ai/orders.ts and server/ai/tools.ts, and change one import in the tools file:
// server/ai/tools.ts
import { cancelOrder, findOrder } from "./orders"
I keep them out of server/utils on purpose. Nuxt auto-imports everything in that folder across the server, and I'd rather see where tools comes from.
4. Write the API route
// server/api/chat.post.ts
import {
convertToModelMessages,
createGateway,
createUIMessageStreamResponse,
isStepCount,
streamText,
toUIMessageStream,
validateUIMessages,
} from "ai"
import { tools, type ChatMessage } from "~~/server/ai/tools"
export default defineLazyEventHandler(() => {
const apiKey = useRuntimeConfig().aiGatewayApiKey
if (!apiKey) throw new Error("Missing NUXT_AI_GATEWAY_API_KEY")
const gateway = createGateway({ apiKey })
return defineEventHandler(async (event) => {
const userId = await getUserId(event) // your auth, from server/utils
if (!userId) throw createError({ statusCode: 401 })
const body = await readBody(event)
const messages = await validateUIMessages<ChatMessage>({ messages: body.messages, tools })
const result = streamText({
model: gateway("anthropic/claude-sonnet-5.5"),
instructions:
"You are the support assistant of an online shop. Use the tools to look up and cancel orders. Keep answers short.",
messages: await convertToModelMessages(messages),
tools,
toolsContext: {
getOrder: { userId },
cancelOrder: { userId },
},
toolApproval: { cancelOrder: "user-approval" },
stopWhen: isStepCount(5),
})
return createUIMessageStreamResponse({
stream: toUIMessageStream({ stream: result.stream }),
})
})
})
defineLazyEventHandler creates the gateway once, on the first request, and h3 sends the returned Response as it is, stream included. getUserId is a function of yours in server/utils, such as one built on getUserSession from nuxt-auth-utils.
5. Add the card component
<!-- app/components/OrderCard.vue -->
<script setup lang="ts">
import type { Order } from "~~/server/ai/orders"
defineProps<{ order: Order }>()
</script>
<template>
<article class="rounded-lg border p-4">
<h3 class="font-semibold">Order {{ order.id }}</h3>
<p>{{ order.status === "delivered" ? "Delivered" : `Arrives ${order.eta}` }}</p>
<p>Total: {{ order.total }}</p>
</article>
</template>
The type-only import from server/ is erased at build time, so no server code reaches the browser.
6. Build the chat page
<!-- app/pages/index.vue -->
<script setup lang="ts">
import { useChat } from "@ai-sdk/vue"
import { lastAssistantMessageIsCompleteWithApprovalResponses } from "ai"
import type { ChatMessage } from "~~/server/ai/tools"
const input = ref("")
const { messages, sendMessage, addToolApprovalResponse, status, stop } = useChat<ChatMessage>({
sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithApprovalResponses,
})
const busy = computed(() => status.value === "submitted" || status.value === "streaming")
function onSubmit() {
if (!input.value.trim()) return
sendMessage({ text: input.value })
input.value = ""
}
</script>
<template>
<main class="mx-auto max-w-xl p-6">
<div v-for="message in messages" :key="message.id" class="mb-4">
<strong>{{ message.role === "user" ? "You" : "Assistant" }}</strong>
<template v-for="(part, i) in message.parts" :key="`${message.id}-${i}`">
<p v-if="part.type === 'text'">{{ part.text }}</p>
<template v-else-if="part.type === 'tool-getOrder'">
<OrderCard v-if="part.state === 'output-available'" :order="part.output" />
<p v-else-if="part.state === 'output-error'" role="alert">{{ part.errorText }}</p>
<p v-else>Looking up the order…</p>
</template>
<template v-else-if="part.type === 'tool-cancelOrder'">
<div v-if="part.state === 'approval-requested'">
<p>Cancel order {{ part.input.orderId }}?</p>
<button @click="addToolApprovalResponse({ id: part.approval.id, approved: true })">Cancel it</button>
<button @click="addToolApprovalResponse({ id: part.approval.id, approved: false })">Keep it</button>
</div>
<p v-else-if="part.state === 'output-available'">
{{ part.output.cancelled ? `Order ${part.output.orderId} is cancelled.` : "That order can no longer be cancelled." }}
</p>
<p v-else-if="part.state === 'output-denied'">Order kept.</p>
</template>
</template>
</div>
<form @submit.prevent="onSubmit">
<input v-model="input" placeholder="Ask about an order">
<button v-if="busy" type="button" @click="stop()">Stop</button>
<button v-else type="submit">Send</button>
</form>
</main>
</template>
In version 7, useChat in Vue returns refs. messages, status and error are ShallowRefs, unwrapped in the template and read with .value in the script. If the chat depends on reactive values, such as a chat ID from the route, pass a getter, useChat(() => ({ … })), and the composable recreates the chat when they change.
The v-if chain narrows the part type the same way the React switch does, and vue-tsc checks the template too. When I misspelt part.approval.id on purpose, the type check failed.
What differs between Next.js and Nuxt?
Very little. The tools, the message type and the streaming protocol are the same; only the framework glue changes.
| Next.js | Nuxt | |
|---|---|---|
| Client package | @ai-sdk/react | @ai-sdk/vue |
| Chat state | Plain values from useChat | Refs from useChat |
| Route | app/api/chat/route.ts, exporting POST | server/api/chat.post.ts, an h3 handler |
| Reading the body | await req.json() | await readBody(event) |
| Gateway key | AI_GATEWAY_API_KEY, read automatically | NUXT_AI_GATEWAY_API_KEY through runtimeConfig and createGateway |
| Client boundary | "use client" on the page | None; the composable runs where the component runs |
| Rendering parts | switch (part.type) in JSX | A v-if chain in the template |
If you're picking the framework rather than the SDK, I compared them in React vs Vue in 2026.
AI SDK production checklist
A chat that works on localhost is about a third of the job. Before real users get it, I go through this list:
- Authenticate the route and take the user from the session. Pass whatever tools need through
toolsContext, never through the prompt. - Validate the history with
validateUIMessagesand your tools. Return a 400 when it throws, rather than a 500. - Keep tool errors safe. Throw short messages from
execute, and log the details on the server.redactToolErrors: truereplaces the text that reaches the client, with a caveat for reasoning models in the docs. - Gate every write with
toolApproval, and sign approvals withexperimental_toolApprovalSecret. - Cap the loop and the clock with
isStepCount, atimeout, andmaxDurationon Vercel. - Rate-limit per user and record token usage from
onEnd, so one user can't run up the bill. - Save conversations with
originalMessagesandonEndontoUIMessageStream, so a reload doesn't lose the chat. - Trace calls with
registerTelemetryand an integration such as@ai-sdk/otel. - Test without an API key.
MockLanguageModelV4fromai/testandsimulateReadableStreamscript the model's replies, tool calls included. That's how I checked the routes in this post. - Upgrade on purpose. Keep
aiand@ai-sdk/reactor@ai-sdk/vueon the same release line, and run the codemod for major versions.
Items 3, 4, 5 and 7 together look like this. I type-checked it as a full route against ai 7.0.173:
const result = streamText({
// model, instructions, messages, tools, toolsContext and toolApproval as before
experimental_toolApprovalSecret: process.env.TOOL_APPROVAL_SECRET,
stopWhen: isStepCount(5),
timeout: { totalMs: 60_000, stepMs: 20_000, toolMs: 10_000 },
})
return createUIMessageStreamResponse({
stream: toUIMessageStream({
stream: result.stream,
redactToolErrors: true,
originalMessages: messages,
onEnd: ({ messages }) => saveChat({ chatId: body.id, messages }),
}),
})
saveChat is yours to write, for example a table of chats keyed by the chat ID useChat sends with each request. If the app around the chat was itself built quickly with AI tools, my production checklist for vibe-coded apps covers the rest, from auth and data access rules to secrets and monitoring.
Where I can help
I add AI features to Nuxt and React products, from a first assistant to agents with tools and approvals, working from Romania with teams in the EU, UK and US. If you're planning an AI SDK chat, or one that works in a demo and not yet in production, these pages cover how I work:
Tell me what you're building and get a quote. I'll reply within one working day.
FAQ
Is the Vercel AI SDK free?
Yes. It's open source under the Apache-2.0 licence and installs from npm. You pay only for model usage, either to the provider directly or through the Vercel AI Gateway.
Do I need to deploy on Vercel to use the AI SDK?
No. It's a library, and its route handlers return standard Response objects that run on any Node.js 22+ host. The AI Gateway is optional too, since any provider package, such as @ai-sdk/openai, works without it.
Does the AI SDK work with Nuxt and Vue?
Yes. @ai-sdk/vue provides useChat, useCompletion and useObject as composables. Since version 7, Vue uses the useChat composable, which returns refs; the older Chat class is deprecated. The server side is a normal Nuxt API route.
What's the difference between AI SDK Core and AI SDK UI?
AI SDK Core (the ai package) runs on the server and calls models with streamText, generateText, tools and agents. AI SDK UI (@ai-sdk/react, @ai-sdk/vue and the others) runs in the browser, keeps the chat state and renders the streamed reply with useChat.
What is generative UI in the AI SDK?
It's rendering your own components from the model's tool calls. The model calls a tool such as getOrder, the result reaches the client as a typed tool-getOrder part, and you render a component, such as an order card, when its state is output-available.
How do I upgrade from AI SDK 6 to 7?
Move to Node.js 22 and ESM, update ai and your @ai-sdk/* packages together, then run npx @ai-sdk/codemod v7. It renames system to instructions, stepCountIs to isStepCount and onFinish to onEnd, among others. Check anything left by hand against the official migration guide.
