browserbase_screenshot

Instructions

Implementation Reference

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

  The handler function that takes a screenshot of the active page using Puppeteer, stores the base64 image in resources, notifies the client, and returns text and 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:13-18 (schema)

  The tool schema defining the name, description, and input schema (ScreenshotInputSchema with optional 'name') for the browserbase_screenshot tool.

  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/index.ts:43-52 (registration)

  The screenshotTool is included in the TOOLS array exported from tools/index.ts, which is used to register all tools with the MCP server.

  export const TOOLS = [
    ...multiSessionTools,
    ...sessionTools,
    navigateTool,
    actTool,
    extractTool,
    observeTool,
    screenshotTool,
    getUrlTool,
  ];

• src/index.ts:192-222 (registration)

  The loop that registers every tool from the TOOLS array (including browserbase_screenshot) with the MCP server by calling server.tool() for each.

  const tools: MCPToolsArray = [...TOOLS];
  
  // Register each tool with the Smithery server
  tools.forEach((tool) => {
    if (tool.schema.inputSchema instanceof z.ZodObject) {
      server.tool(
        tool.schema.name,
        tool.schema.description,
        tool.schema.inputSchema.shape,
        async (params: z.infer<typeof tool.schema.inputSchema>) => {
          try {
            const result = await context.run(tool, params);
            return result;
          } catch (error) {
            const errorMessage =
              error instanceof Error ? error.message : String(error);
            process.stderr.write(
              `[Smithery Error] ${new Date().toISOString()} Error running tool ${tool.schema.name}: ${errorMessage}\n`,
            );
            throw new Error(
              `Failed to run tool '${tool.schema.name}': ${errorMessage}`,
            );
          }
        },
      );
    } else {
      console.warn(
        `Tool "${tool.schema.name}" has an input schema that is not a ZodObject. Schema type: ${tool.schema.inputSchema.constructor.name}`,
      );
    }
  });