Build a research agent with Stagehand + Vercel

import {
  browserbase as stagehandBrowserbase,
  Stagehand,
  type StagehandBrowser,
} from "@browserbasehq/stagehand";
import Browserbase from "@browserbasehq/sdk";

const browserbase = new Browserbase();

async function createStagehandSession(source: string) {
  const session = await browserbase.sessions.create();
  const browser = await stagehandBrowserbase.connect({
    apiKey: process.env.BROWSERBASE_API_KEY,
    sessionId: session.id,
  });
  const stagehand = await Stagehand.create({
    browser,
    model: { modelName: "anthropic/claude-sonnet-4-6" },
    logging: { level: "info", format: "pretty", onLog: console.log },
  });

  const sessionId = session.id;
  const { debuggerFullscreenUrl } = await browserbase.sessions.debug(sessionId);

  return {
    browser,
    stagehand,
    sessionId,
    liveViewUrl: debuggerFullscreenUrl,
    source,
  };
}

import { z } from "zod";

async function researchGoogle(
  stagehand: Stagehand,
  browser: StagehandBrowser,
  query: string,
  onFinding: (finding: Finding) => void,
) {
  const page = await browser.context.activePage();

  await page.goto(`https://duckduckgo.com/?q=${encodeURIComponent(query)}`);
  await page.waitForTimeout(2000);

  const searchResults = await stagehand.extract(
    "Extract the top 5 organic search result links with their titles and URLs. Skip any ads.",
    z.object({
      results: z
        .array(
          z.object({
            title: z.string(),
            url: z.string(),
          }),
        )
        .max(5),
    }),
  );

  for (const result of searchResults.data.results.slice(0, 3)) {
    if (!result.url || result.url.includes("duckduckgo.com")) continue;

    await page.goto(result.url, {
      waitUntil: "domcontentloaded",
      timeoutMs: 15000,
    });

    const content = await stagehand.extract(
      `Extract the key information about "${query}" from this article.`,
      z.object({
        summary: z.string(),
        keyFacts: z.array(z.string()),
      }),
    );

    if (content.data.summary) {
      onFinding({
        title: result.title,
        source: new URL(result.url).hostname.replace("www.", ""),
        url: result.url,
        summary: content.data.summary,
        relevance: "high",
      });
    }
  }
}

import { generateObject } from "ai";
import { anthropic } from "@ai-sdk/anthropic";

export const maxDuration = 300;

const ResearchSummarySchema = z.object({
  overview: z.string().describe("2-3 sentence direct answer to the query"),
  keyFacts: z
    .array(z.string())
    .describe("3-6 specific facts with dates, numbers, or names"),
  recentDevelopments: z
    .string()
    .nullable()
    .describe("Latest news if applicable"),
  sourcesSummary: z
    .string()
    .describe("Brief note on the types of sources consulted"),
});

export async function POST(req: Request) {
  const { query } = await req.json();

  const encoder = new TextEncoder();
  const stream = new TransformStream();
  const writer = stream.writable.getWriter();

  const sendEvent = async (event: string, data: unknown) => {
    await writer.write(
      encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`),
    );
  };

  (async () => {
    const sessions = [];
    const allFindings: Finding[] = [];

    const researchFunctions = [
      { source: "News", fn: researchGoogleNews },
      { source: "Hacker News", fn: researchHackerNews },
      { source: "YouTube", fn: researchYouTube },
      { source: "Wikipedia", fn: researchWikipedia },
      { source: "Search", fn: researchGoogle },
    ];

    try {
      await sendEvent("status", {
        message: "Starting browser sessions...",
        phase: "init",
      });

      // Create all Stagehand sessions in parallel
      const sessionPromises = researchFunctions.map(({ source }) =>
        createStagehandSession(source),
      );
      const createdSessions = await Promise.all(sessionPromises);
      sessions.push(...createdSessions);

      // Send live view URLs to frontend
      await sendEvent("liveViews", {
        sessions: sessions.map((s) => ({
          source: s.source,
          liveViewUrl: s.liveViewUrl,
          sessionId: s.sessionId,
        })),
      });

      // Run all research in parallel
      await Promise.allSettled(
        researchFunctions.map(({ source, fn }, index) =>
          fn(
            sessions[index].stagehand,
            sessions[index].browser,
            query,
            (finding) => {
              allFindings.push(finding);
              sendEvent("findings", { findings: allFindings });
            },
          ),
        ),
      );

      // Synthesize findings with AI
      if (allFindings.length > 0) {
        const findingsText = allFindings
          .map((f) => `Source: ${f.source}\n${f.summary}`)
          .join("\n\n---\n\n");

        const { object: summary } = await generateObject({
          model: anthropic("claude-sonnet-4-6"),
          schema: ResearchSummarySchema,
          prompt: `Based on these research findings about "${query}", create a structured summary.\n\n${findingsText}`,
        });

        await sendEvent("complete", { findings: allFindings, summary });
      }
    } finally {
      for (const session of sessions) {
        try {
          await session.stagehand.close();
        } catch {}
        try {
          await session.browser.close();
        } catch {}
      }
      await writer.close();
    }
  })();

  return new Response(stream.readable, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
    },
  });
}

async function getProjectConcurrency(): Promise<number> {
  const projects = await browserbase.projects.list();
  if (!projects?.length) return 1;
  const project = await browserbase.projects.retrieve(projects[0].id);
  return project.concurrency ?? 1;
}

// In your POST handler:
const concurrency = await getProjectConcurrency();

if (concurrency === 1) {
  // Run browsers one at a time, closing each before starting the next
  for (const { source, fn } of researchFunctions) {
    const session = await createStagehandSession(source);
    await fn(session.stagehand, session.browser, query, onFinding);
    await session.stagehand.close();
    await session.browser.close();
  }
} else {
  // Run all browsers in parallel
  const sessions = await Promise.all(
    researchFunctions.map(({ source }) => createStagehandSession(source)),
  );
  await Promise.allSettled(
    researchFunctions.map(({ fn }, i) =>
      fn(sessions[i].stagehand, sessions[i].browser, query, onFinding),
    ),
  );
}