Next.js integration

cd my-next-app
npx glove-foundry init . --target nextjs

cp foundry.env.example .env.local   # or merge into your existing .env.local
pnpm install

pnpm foundry:dev   # terminal 1: Foundry runtime + inspector on http://127.0.0.1:4141
pnpm dev           # terminal 2: Next.js on http://localhost:3000

/**
 * The Next.js app talks to the Foundry runtime over HTTP, so nothing from
 * the agent graph is bundled into your app. `FoundryRoutes` is a type-only
 * import, erased at build time, and it is regenerated on every dev run — so
 * agent("concierge") is checked against the files that actually exist.
 */
import { createFoundryClient } from "glove-foundry/client";
import type { FoundryRoutes } from "../.foundry/routes.js";

export const foundry = createFoundryClient<FoundryRoutes>({
  baseUrl: process.env.FOUNDRY_URL ?? "http://127.0.0.1:4141",
});


// The agents live in foundry/agents. Start the runtime with
// `foundry:dev`; it serves the inspector at http://127.0.0.1:4141.

/**
 * POST /api/concierge — send a message to the agent and wait for its result.
 *
 * This runs on the server, so the Foundry runtime never has to be public.
 * For a streaming UI, subscribe to the runtime's /api/events instead of
 * awaiting run.wait().
 */
import { foundry } from "../../../lib/foundry.js";

export async function POST(request: Request) {
  const { message, workspaceId = "default" } = (await request.json()) as {
    message: string;
    workspaceId?: string;
  };

  // A real app reuses one instance per user rather than creating one per call.
  const agent = await foundry.agent("concierge").create({ workspaceId });
  const conversation = await foundry.createConversation(agent.id);
  const run = await foundry.send(agent.id, conversation.id, message);
  const completed = await run.wait();

  return Response.json({ runId: run.id, output: completed.output });
}

import { foundry } from "./foundry.js";

/** One durable instance and conversation per user. Cache the ids in your user table. */
export async function supportSessionFor(userId: string) {
  const id = `support-${userId}`;
  const agent =
    (await foundry.agentInstances("support")).find((item) => item.id === id) ??
    (await foundry.agent("support").create({ id, workspaceId: "support", context: { userId } }));
  const [first] = await foundry.conversations(agent.id);
  const conversation = first ?? (await foundry.createConversation(agent.id, { title: "Support" }));
  return { agent, conversation };
}

// your code: resolve the signed-in user from your session or auth library.
export async function currentUserId(request: Request): Promise<string | null> {
  return request.headers.get("x-demo-user");
}

import { foundry } from "../../../lib/foundry.js";
import { currentUserId, supportSessionFor } from "../../../lib/support.js";

export async function POST(request: Request) {
  const userId = await currentUserId(request);
  if (!userId) return Response.json({ error: "Sign in first." }, { status: 401 });
  const { message } = (await request.json()) as { message: string };

  const { agent, conversation } = await supportSessionFor(userId);
  const run = await foundry.send(agent.id, conversation.id, message);
  // Stop polling if the browser goes away; the run itself keeps going.
  const settled = await run.wait({ timeoutMs: 120_000, signal: request.signal });

  if (settled.status !== "completed") {
    return Response.json({ runId: run.id, error: settled.error ?? settled.status }, { status: 502 });
  }
  return Response.json({ runId: run.id, reply: settled.output?.value });
}

import { currentUserId, supportSessionFor } from "../../../../lib/support.js";

const FOUNDRY_URL = process.env.FOUNDRY_URL ?? "http://127.0.0.1:4141";

export async function POST(request: Request) {
  const userId = await currentUserId(request);
  if (!userId) return Response.json({ error: "Sign in first." }, { status: 401 });
  const { message } = (await request.json()) as { message: string };
  const { agent } = await supportSessionFor(userId);

  const upstream = await fetch(`${FOUNDRY_URL}/v1/chat/completions`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      ...(process.env.FOUNDRY_API_TOKEN ? { authorization: `Bearer ${process.env.FOUNDRY_API_TOKEN}` } : {}),
    },
    body: JSON.stringify({
      model: agent.id, // an instance id
      stream: true,
      user: userId, // same user → same durable conversation on that instance
      messages: [{ role: "user", content: message }],
    }),
    signal: request.signal,
  });
  if (!upstream.ok || !upstream.body) {
    return new Response(await upstream.text(), { status: upstream.status });
  }
  return new Response(upstream.body, {
    headers: {
      "content-type": "text/event-stream; charset=utf-8",
      "cache-control": "no-cache, no-transform",
      "x-foundry-conversation-id": upstream.headers.get("x-foundry-conversation-id") ?? "",
    },
  });
}

/** Browser helper: read the OpenAI-style chunks your stream route forwards. */
export async function streamReply(message: string, onText: (text: string) => void) {
  const response = await fetch("/api/support/stream", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ message }),
  });
  if (!response.ok || !response.body) throw new Error(await response.text());
  const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
  let buffer = "";
  for (;;) {
    const { value, done } = await reader.read();
    if (done) return;
    buffer += value;
    const events = buffer.split("\n\n");
    buffer = events.pop() ?? "";
    for (const event of events) {
      const data = event.replace(/^data: /, "");
      if (data === "[DONE]") return;
      const chunk = JSON.parse(data) as { choices: Array<{ delta: { content?: string } }> };
      const text = chunk.choices[0]?.delta.content;
      if (text) onText(text);
    }
  }
}

import { createFoundryClient } from "glove-foundry/client";
import type { FoundryRoutes } from "../.foundry/routes.js";

export const foundry = createFoundryClient<FoundryRoutes>({
  baseUrl: process.env.FOUNDRY_URL ?? "http://127.0.0.1:4141",
  // Only needed when the runtime enforces requestAuthorization.
  ...(process.env.FOUNDRY_API_TOKEN
    ? {
        authorization: {
          identifier: "next-server",
          headers: () => ({ authorization: `Bearer ${process.env.FOUNDRY_API_TOKEN}` }),
        },
      }
    : {}),
});