Defining Agents

import { createAnthropic } from "@ai-sdk/anthropic";
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { InferAgentUIMessage, ToolLoopAgent, stepCountIs, tool } from "ai";
import { z } from "zod";

function required(name: string, value: string | undefined): string {
  if (!value) throw new Error(name + " is required");
  return value;
}

function createModel() {
  const provider = process.env.AI_PROVIDER ?? "compatible";
  const modelName = process.env.AI_MODEL ?? "gpt-5-mini";
  if (provider === "anthropic") {
    const anthropic = createAnthropic({
      apiKey: required("ANTHROPIC_API_KEY or AI_API_KEY", process.env.ANTHROPIC_API_KEY ?? process.env.AI_API_KEY),
    });
    return anthropic(modelName);
  }
  if (provider === "compatible") {
    const compatible = createOpenAICompatible({
      name: "ai-sdk-pro-compatible",
      baseURL: required("AI_BASE_URL", process.env.AI_BASE_URL),
      apiKey: required("AI_API_KEY", process.env.AI_API_KEY),
    });
    return compatible(modelName);
  }
  throw new Error("Unsupported AI_PROVIDER: " + provider);
}

const getCurrentTime = tool({
  description: "Get the current time in an IANA time zone.",
  inputSchema: z.object({
    timeZone: z.string().default("UTC"),
  }),
  execute: async ({ timeZone }) =>
    new Intl.DateTimeFormat("en-US", {
      dateStyle: "full",
      timeStyle: "long",
      timeZone,
    }).format(new Date()),
});

export const assistantAgent = new ToolLoopAgent({
  model: createModel(),
  instructions: "You are a concise assistant for ai-sdk.pro. Cite tool results.",
  tools: { getCurrentTime },
  stopWhen: stepCountIs(20),
});

export type AssistantUIMessage = InferAgentUIMessage<typeof assistantAgent>;

import { tool } from "ai";
import { z } from "zod";
import { docs } from "@/lib/content";

const APPROVED_HOSTS = new Set(["ai-sdk.dev", "v6.ai-sdk.dev", "fumadocs.dev", "www.fumadocs.dev"]);

function approvedUrl(rawUrl: string): URL {
  const url = new URL(rawUrl);
  if (url.protocol !== "https:" || !APPROVED_HOSTS.has(url.hostname)) {
    throw new Error("Only approved HTTPS documentation hosts are allowed");
  }
  return url;
}

async function fetchApprovedUrl(rawUrl: string): Promise<string> {
  let url = approvedUrl(rawUrl);
  for (let redirect = 0; redirect <= 3; redirect += 1) {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 8000);
    let response: Response;
    try {
      response = await fetch(url, { redirect: "manual", signal: controller.signal });
    } finally {
      clearTimeout(timeout);
    }
    if (response.status >= 300 && response.status < 400) {
      const location = response.headers.get("location");
      if (!location) throw new Error("Redirect is missing Location");
      url = approvedUrl(new URL(location, url).toString());
      continue;
    }
    if (!response.ok) throw new Error("HTTP " + response.status);
    return (await response.text()).slice(0, 8000);
  }
  throw new Error("Too many redirects");
}

export const fetchUrl = tool({
  description: "Fetch approved public documentation with timeout and bounded redirects.",
  inputSchema: z.object({ url: z.string().max(2048).describe("Approved HTTPS documentation URL") }),
  execute: fetchApprovedUrl,
});

export const searchDocs = tool({
  description: "Search the local documentation index.",
  inputSchema: z.object({ query: z.string().min(1) }),
  execute: async ({ query }) => {
    const normalized = query.toLowerCase();
    return docs
      .filter((doc) =>
        (doc.title + " " + doc.description + " " + doc.body).toLowerCase().includes(normalized),
      )
      .map(({ slug, title, description }) => ({ slug, title, description }));
  },
});

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

export async function createOptionalMcpTools() {
  const url = process.env.MCP_SERVER_URL;
  if (!url) return { tools: {}, close: async () => {} };

  const secret = process.env.MCP_AUTH_TOKEN;
  const client = await createMCPClient({
    transport: {
      type: "http",
      url,
      headers: secret ? { Authorization: "Bearer " + secret } : undefined,
    },
  });
  return {
    tools: await client.tools(),
    close: () => client.close(),
  };
}