Migrate from an AI SDK route handler

Migrate this app's AI chat from a Vercel AI SDK route handler to Trigger.dev `chat.agent`.

Before you edit anything:

1. Run `npx trigger.dev@latest skills`. That installs the `trigger-authoring-chat-agent`
   and `trigger-chat-agent-advanced` skills, which are version-pinned to the
   `@trigger.dev/sdk` in this project, so they describe the exact API surface we have.
   Load both before you plan the change.
2. Read these pages in full:
   - https://trigger.dev/docs/ai-chat/quick-start.md
   - https://trigger.dev/docs/ai-chat/frontend.md
   - https://trigger.dev/docs/ai-chat/reference.md
   Use https://trigger.dev/docs/llms.txt as the index if you need anything else
   (persistence, tools, lifecycle hooks). Do not fetch llms-full.txt.
3. Find and read the current chat code: the `useChat` component, the chat route handler
   (`app/api/chat/route.ts` or equivalent), the tool definitions, and anything that
   persists messages or resumes streams.

Then make these changes:

- Create a `chat.agent` task in `trigger/chat.ts`. Move the existing `streamText` call
  into its `run` function UNCHANGED — same model, same `system`, same `temperature`,
  same `stopWhen`, same provider options. Do not rewrite the prompt or swap the model.
- Spread `...chat.toStreamTextOptions({ tools })` as the FIRST property of that
  `streamText` call, so the explicit options after it still win.
- `run` receives `ModelMessage[]` already. Delete the `convertToModelMessages` call.
- Forward the `signal` from `run` as `abortSignal` so Stop works.
- Move the existing tool set onto `chat.agent({ tools })` as well, and read it back from
  the `run` payload. Keep every tool's schema, `execute`, and `toModelOutput` as-is.
- Add two server actions: `chat.createStartSessionAction("<task-id>")` to start the
  session, and an access-token mint using `auth.createPublicToken` scoped to
  `read: { sessions: chatId }` and `write: { sessions: chatId }`. Move the route
  handler's auth check into them.
- Replace the client's `DefaultChatTransport` / `api` URL with `useTriggerChatTransport`
  from `@trigger.dev/sdk/chat/react`, wired to those two actions. Leave the rest of the
  `useChat` usage and all message rendering alone.
- Move message persistence out of the route handler. If this app's database should stay
  the source of truth for history, use a `hydrateMessages` hook; otherwise persist from
  `onTurnStart` and `onTurnComplete`. Write `lastEventId` alongside the messages in the
  same transaction.
- Delete the route handler, any resumable-stream / Redis stream-resumption plumbing, and
  the separate stream-resume GET route. The transport resumes from `lastEventId`.

Constraints:

- Import from `@trigger.dev/sdk`, `@trigger.dev/sdk/ai`, and `@trigger.dev/sdk/chat/react`.
  Never `@trigger.dev/sdk/v3`.
- Import the agent into client components with `import type` only.
- Never mint a token in the browser or expose `TRIGGER_SECRET_KEY` client-side.
- Do not change the model, prompt, tool schemas, or UI components beyond what the
  transport swap requires.

Do NOT attempt this unless I ask for it separately:

- Head Start (`chat.headStart`), which keeps a route handler around to run the first
  turn's opening model call in the warm server process. It's a follow-on change with its
  own constraint — tool schemas have to be split away from tool executes so the route
  handler's bundle stays light. Read https://trigger.dev/docs/ai-chat/fast-starts.md
  before touching it.

When you're done, list what you deleted and show the diff for the agent task, the server
actions, and the client component.

import { anthropic } from "@ai-sdk/anthropic";
import { convertToModelMessages, stepCountIs, streamText, type UIMessage } from "ai";
import { auth } from "@/lib/auth";
import { saveChat } from "@/lib/chat-store";
import { tools } from "@/lib/tools";

export const maxDuration = 60;

export async function POST(req: Request) {
  const { id, messages }: { id: string; messages: UIMessage[] } = await req.json();

  const session = await auth();
  if (!session) return new Response("Unauthorized", { status: 401 });

  const result = streamText({
    model: anthropic("claude-sonnet-4-5"),
    system: "You are a helpful assistant.",
    messages: convertToModelMessages(messages),
    tools,
    stopWhen: stepCountIs(15),
    abortSignal: req.signal,
  });

  return result.toUIMessageStreamResponse({
    originalMessages: messages,
    onFinish: ({ messages }) => saveChat({ id, userId: session.user.id, messages }),
  });
}

import { chat } from "@trigger.dev/sdk/ai";
import { anthropic } from "@ai-sdk/anthropic";
import { stepCountIs, streamText } from "ai";
import { tools } from "@/lib/tools";

export const myChat = chat.agent({
  id: "my-chat",
  tools,
  run: async ({ messages, tools, signal }) =>
    streamText({
      // Spread first, so every option below still wins.
      ...chat.toStreamTextOptions({ tools }),
      model: anthropic("claude-sonnet-4-5"),
      system: "You are a helpful assistant.",
      messages,
      abortSignal: signal,
      stopWhen: stepCountIs(15),
    }),
});

import { tool } from "ai";
import { z } from "zod";
import { renderToPng } from "@/lib/charts";

export const tools = {
  renderChart: tool({
    description: "Render a chart and return it as an image.",
    inputSchema: z.object({ spec: z.string() }),
    execute: async ({ spec }) => renderToPng(spec),
    toModelOutput: ({ output }) => ({
      type: "content",
      value: [{ type: "media", mediaType: "image/png", data: output.base64 }],
    }),
  }),
};

"use server";

import { auth as triggerAuth } from "@trigger.dev/sdk";
import { chat, type ChatStartSessionParams } from "@trigger.dev/sdk/ai";
import { auth } from "@/lib/auth";
import { assertChatOwner, claimChat } from "@/lib/chat-access";
import type { myChat } from "@/trigger/chat";

const start = chat.createStartSessionAction<typeof myChat>("my-chat");

// Creates the session and triggers its first run, then returns a
// session-scoped token. Idempotent on (environment, chatId).
export async function startChatSession(params: ChatStartSessionParams<typeof myChat>) {
  const session = await auth();
  if (!session) throw new Error("Unauthorized");

  await claimChat(params.chatId, session.user.id);

  return start(params);
}

// Pure mint. The transport calls this on a 401/403 to refresh.
export async function mintChatAccessToken(chatId: string) {
  const session = await auth();
  if (!session) throw new Error("Unauthorized");

  await assertChatOwner(chatId, session.user.id);

  return triggerAuth.createPublicToken({
    scopes: {
      read: { sessions: chatId },
      write: { sessions: chatId },
    },
    expirationTime: "1h",
  });
}

import { chat, upsertIncomingMessage } from "@trigger.dev/sdk/ai";
import { anthropic } from "@ai-sdk/anthropic";
import { stepCountIs, streamText } from "ai";
import { db } from "@/lib/db";
import { tools } from "@/lib/tools";

export const myChat = chat.agent({
  id: "my-chat",
  tools,
  hydrateMessages: async ({ chatId, trigger, incomingMessages }) => {
    const record = await db.chat.findUnique({ where: { id: chatId } });
    const stored = record?.messages ?? [];

    // Pushes a fresh user message; no-ops on tool-approval continuations.
    if (upsertIncomingMessage(stored, { trigger, incomingMessages })) {
      await db.chat.upsert({
        where: { id: chatId },
        create: { id: chatId, messages: stored },
        update: { messages: stored },
      });
    }

    return stored;
  },
  onTurnComplete: async ({ chatId, uiMessages, chatAccessToken, lastEventId }) => {
    // One transaction: a refresh between these two writes would resume
    // from a stale cursor and re-render the assistant message twice.
    await db.$transaction([
      db.chat.update({ where: { id: chatId }, data: { messages: uiMessages } }),
      db.chatSession.upsert({
        where: { id: chatId },
        create: { id: chatId, publicAccessToken: chatAccessToken, lastEventId },
        update: { publicAccessToken: chatAccessToken, lastEventId },
      }),
    ]);
  },
  run: async ({ messages, tools, signal }) =>
    streamText({
      ...chat.toStreamTextOptions({ tools }),
      model: anthropic("claude-sonnet-4-5"),
      system: "You are a helpful assistant.",
      messages,
      abortSignal: signal,
      stopWhen: stepCountIs(15),
    }),
});