Ask Trigger chat agent

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

const registry = createProviderRegistry({ anthropic });

// A versioned AI Prompt: edit the teaching guidance, model or temperature from
// the dashboard without redeploying. The component reference is generated from
// the catalog at run time, so the prompt can't drift from the code.
const systemPrompt = prompts.define({
  id: "trigger-tutor",
  model: "anthropic:claude-haiku-4-5",
  variables: z.object({ componentReference: z.string() }),
  content: `You are the Trigger.dev tutor... You teach by DRAWING and composing
on-screen components, never walls of text.

## renderVisualization spec reference

{{componentReference}}`,
});

export const triggerChatAgent = chat.agent({
  id: "trigger-chat-agent",
  idleTimeoutInSeconds: 300,
  // Public-demo cost guardrail: throttle how many sessions run at once.
  queue: { concurrencyLimit: 10 },

  // Declaring tools here — not just on streamText — is what lets the SDK
  // re-convert prior turns' history correctly. The docs MCP tools are merged
  // in each turn so their calls survive that re-conversion too.
  tools: async () => {
    const docsTools = await getDocsTools();
    return { renderVisualization, suggestNext, ...docsTools };
  },

  // onTurnStart (not onChatStart) fires on every turn, so the system prompt
  // survives an idle resume. chat.toStreamTextOptions() picks up the system
  // text, model, config AND experimental_telemetry from it — the telemetry is
  // what makes LLM observability (tokens, cost, latency) show up per prompt version.
  onTurnStart: async () => {
    chat.prompt.set(await getResolvedPrompt());
  },

  run: async ({ messages, tools, signal }) => {
    // Escalate only genuinely hard turns to Sonnet; everything else stays on
    // the prompt's base model (Haiku). The override goes AFTER the spread so it wins.
    const escalate = await needsEscalation(messages);
    return streamText({
      model: anthropic("claude-haiku-4-5"),
      ...chat.toStreamTextOptions({ registry, tools }),
      ...(escalate ? { model: anthropic("claude-sonnet-5") } : {}),
      messages,
      stopWhen: stepCountIs(15),
      abortSignal: signal,
    });
  },
});

import { createMCPClient } from "@ai-sdk/mcp";

// Defaults to the hosted Context7 server — point it at another product's docs
// MCP to fork the demo to a different domain.
const DOCS_MCP_URL = process.env.DOCS_MCP_URL ?? "https://mcp.context7.com/mcp";

async function loadDocsTools(): Promise<ToolSet> {
  const client = await createMCPClient({ transport: { type: "http", url: DOCS_MCP_URL } });
  // Kept open for the life of the run process — the tools close over the client.
  return quarantineDocsTools(await client.tools());
}

import { quarantineDocs, renderToolText } from "../lib/quarantine";

function quarantineDocsTools(tools: ToolSet): ToolSet {
  const wrapped: ToolSet = {};
  for (const [name, t] of Object.entries(tools)) {
    wrapped[name] = {
      ...t,
      toModelOutput: ({ output }) => ({
        type: "text",
        value: quarantineDocs(renderToolText(output)),
      }),
    };
  }
  return wrapped;
}

import { defineCatalog } from "@json-render/core";

export const catalog = defineCatalog(schema, {
  components: {
    // Layout & text from the stock shadcn catalog
    Card, Stack, Grid, Heading, Text, Badge,
    // ...plus custom FlowGraph, HeroCard, StatCard, Quiz, Callout,
    // Compare, Steps, Glossary, CodeCard, DiagramCard, PromptCard
  },
});

// Generates the component reference (props as JSON schema, from the same zod
// definitions) for the system prompt — so the prompt can't drift from the code.
export function catalogPromptSection(): string { /* ... */ }

// Validates a spec against the catalog; errors are phrased for the model to
// correct and retry.
export function validateSpec(spec: VisualizationSpec) { /* ... */ }

const renderVisualization = tool({
  description:
    "Render interactive diagrams and cards for the user instead of describing a concept as plain text...",
  inputSchema: z.object({
    spec: z.object({
      root: z.string(),
      elements: z.record(z.string(), z.object({
        type: z.string(),
        props: z.record(z.string(), z.unknown()),
        children: z.array(z.string()).optional(),
      })),
    }),
  }),
  execute: async ({ spec }) => {
    const result = validateSpec(normalizeSpec(spec));
    if (!result.ok) {
      // The model reads these, fixes the spec, and calls the tool again
      return { ok: false, errors: result.errors };
    }
    return { ok: true, note: "Rendered to the user. Add at most a one-sentence takeaway." };
  },
});

"use client";

import { useChat } from "@ai-sdk/react";
import { useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
import { mintChatAccessToken, startChatSession } from "@/app/actions";

const transport = useTriggerChatTransport<typeof triggerChatAgent>({
  task: "trigger-chat-agent",
  accessToken: ({ chatId }) => mintChatAccessToken(chatId),
  startSession: ({ chatId, clientData }) => startChatSession({ chatId, clientData }),
});

const { messages, sendMessage, stop, status } = useChat({ transport });
// Render text parts as markdown; render tool-renderVisualization parts with
// json-render's <Renderer spec={...} registry={registry} />

"use server";

import { auth } from "@trigger.dev/sdk";
import { chat } from "@trigger.dev/sdk/ai";

// Creates the Session + triggers the first run, returns the session token.
// Idempotent on (env, chatId) so concurrent calls converge to the same session.
export const startChatSession = chat.createStartSessionAction("trigger-chat-agent");

// Mints a fresh session-scoped token; the transport calls this on 401/403.
export async function mintChatAccessToken(chatId: string) {
  return auth.createPublicToken({
    scopes: { read: { sessions: chatId }, write: { sessions: chatId } },
    expirationTime: "1h",
  });
}

TRIGGER_PROJECT_REF=proj_xxxxxxxxxxxxxxxxxxxxxxxx
TRIGGER_SECRET_KEY=tr_dev_xxxxxxxxxxxxxxxxxxxxxxxx