browserbase_screenshot

Instructions

Implementation Reference

• src/tools/screenshot.ts:20-77 (handler)

  The `handleScreenshot` function implements the core logic of the browserbase_screenshot tool: captures a screenshot of the active page, converts it to base64, generates a name, stores it in the screenshots resource map, notifies the server of resource changes, and returns both a text message and the image content.

  async function handleScreenshot(
    context: Context,
    params: ScreenshotInput,
  ): Promise<ToolResult> {
    const action = async (): Promise<ToolActionResult> => {
      try {
        const page = await context.getActivePage();
        if (!page) {
          throw new Error("No active page available");
        }
  
        const screenshotBuffer = await page.screenshot({
          fullPage: false,
        });
  
        // Convert buffer to base64 string and store in memory
        const screenshotBase64 = screenshotBuffer.toString("base64");
        const name = params.name
          ? `screenshot-${params.name}-${new Date()
              .toISOString()
              .replace(/:/g, "-")}`
          : `screenshot-${new Date().toISOString().replace(/:/g, "-")}` +
            context.config.browserbaseProjectId;
        screenshots.set(name, screenshotBase64);
  
        // Notify the client that the resources changed
        const serverInstance = context.getServer();
  
        if (serverInstance) {
          serverInstance.notification({
            method: "notifications/resources/list_changed",
          });
        }
  
        return {
          content: [
            {
              type: "text",
              text: `Screenshot taken with name: ${name}`,
            },
            {
              type: "image",
              data: screenshotBase64,
              mimeType: "image/png",
            },
          ],
        };
      } catch (error) {
        const errorMsg = error instanceof Error ? error.message : String(error);
        throw new Error(`Failed to take screenshot: ${errorMsg}`);
      }
    };
  
    return {
      action,
      waitForNetwork: false,
    };
  }

• src/tools/screenshot.ts:7-18 (schema)

  Defines the input schema (ScreenshotInputSchema) using Zod with optional 'name' parameter, infers the type, and defines the tool schema (screenshotSchema) including the tool name 'browserbase_screenshot', description, and reference to inputSchema for validation.

  const ScreenshotInputSchema = z.object({
    name: z.string().optional().describe("The name of the screenshot"),
  });
  
  type ScreenshotInput = z.infer<typeof ScreenshotInputSchema>;
  
  const screenshotSchema: ToolSchema<typeof ScreenshotInputSchema> = {
    name: "browserbase_screenshot",
    description:
      "Takes a screenshot of the current page. Use this tool to learn where you are on the page when controlling the browser with Stagehand. Only use this tool when the other tools are not sufficient to get the information you need.",
    inputSchema: ScreenshotInputSchema,
  };

• src/tools/screenshot.ts:79-85 (registration)

  Registers the tool by creating the `screenshotTool` object that combines the capability, schema, and handler function, and exports it as default for use in tool collections like src/tools/index.ts.

  const screenshotTool: Tool<typeof ScreenshotInputSchema> = {
    capability: "core",
    schema: screenshotSchema,
    handle: handleScreenshot,
  };
  
  export default screenshotTool;