@reclaimprotocol/agent 0.1.0-dev.1

package/lib/mcp/api/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ReclaimClient } from '@reclaimprotocol/client';
+export declare function registerTools(server: McpServer, client: ReclaimClient): void;

package/lib/mcp/api/tools.js

@@ -0,0 +1,36 @@
+import { remapErrorAsResponse } from "../remap_errors.js";
+import { MCP_TOOLS } from "./operations.gen.js";
+/**
+ * The generated `MCP_TOOLS` are keyed by OpenAPI `operationId` (PascalCase,
+ * e.g. `GetMe`). MCP tools are conventionally snake_case, matching the
+ * hand-written tools in this server. Convert the public tool name here while
+ * still dispatching to the API with the original operationId — doing this in
+ * the (non-generated) registration keeps it from being reverted on regen.
+ */
+function toSnakeCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+export function registerTools(server, client) {
+    for (const [opId, shape] of Object.entries(MCP_TOOLS)) {
+        // snake_case to match the hand-written tools. A name that collides with
+        // a hand-written tool throws here at startup — intentional: hand-written
+        // and generated names must stay disjoint (see start.ts), so a clash is a
+        // bug to surface, not silently shadow.
+        server.registerTool(toSnakeCase(opId), shape, async (args) => {
+            try {
+                const result = (await client.call(opId, args));
+                return {
+                    content: [{
+                            type: 'text', text: JSON.stringify(result.data, null, 2)
+                        }],
+                };
+            }
+            catch (err) {
+                return remapErrorAsResponse(err);
+            }
+        });
+    }
+}

package/lib/mcp/remap_errors.d.ts

@@ -0,0 +1,2 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare const remapErrorAsResponse: (err: unknown) => CallToolResult;

package/lib/mcp/remap_errors.js

@@ -0,0 +1,27 @@
+import { isBoom } from '@hapi/boom';
+// Remap all errors here if we return different response based on error.
+// Doing this so we can reuse tool error handler that returns same response
+// across different tools or error.
+// For every other error, let them get thrown so the main try-catch
+// handles them in tool registration.
+export const remapErrorAsResponse = (err) => {
+    // The client throws a Boom-style ProblemError, so the status lives on
+    // `output.statusCode` / `problem.status`, not `status`.
+    if (!isBoom(err) || !err.output?.statusCode) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: err.message }],
+        };
+    }
+    const problemError = err;
+    return {
+        isError: true,
+        structuredContent: problemError.data,
+        content: [
+            {
+                type: 'text',
+                text: `${problemError.message}: ${problemError.data?.detail}`
+            }
+        ],
+    };
+};

package/lib/mcp/server.d.ts

@@ -0,0 +1,38 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type JSONSchema } from 'zod-from-json-schema';
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: JSONSchema;
+}
+export interface RegisteredTool {
+    definition: ToolDefinition;
+    /**
+     * @param args Tool arguments
+     * @returns A JSON stringifiable content to be returned to the llm
+     * @throws Any error encountered during tool execution will be caught and
+     * returned as a response using
+     * [remapErrorAsResponse](./src/mcp/remap_errors.ts).
+     */
+    handler: (args: unknown) => Promise<unknown>;
+}
+/**
+ * Define a tool with a single inputSchema (JSON Schema) used as the
+ * source of truth. The handler receives args already parsed and
+ * type-narrowed via a Zod schema derived from that same JSON Schema —
+ * so the description sent to the MCP client and the validation applied
+ * to inbound args cannot drift.
+ */
+export declare function defineTool<TArgs>(definition: ToolDefinition, handler: (args: TArgs) => Promise<unknown>): RegisteredTool;
+/**
+ * Registers a list of RegisteredTool entries on a high-level McpServer.
+ * Converts JSON Schema definitions to Zod and provides consistent
+ * stringification and error catching for tool execution.
+ */
+export declare function registerToolList(server: McpServer, tools: RegisteredTool[]): void;
+export declare class ReclaimMcpServer {
+    #private;
+    constructor();
+    register(tool: RegisteredTool): void;
+    listen(): Promise<void>;
+}

package/lib/mcp/server.js

@@ -0,0 +1,76 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { convertJsonSchemaToZod } from 'zod-from-json-schema';
+import { remapErrorAsResponse } from "./remap_errors.js";
+/**
+ * Define a tool with a single inputSchema (JSON Schema) used as the
+ * source of truth. The handler receives args already parsed and
+ * type-narrowed via a Zod schema derived from that same JSON Schema —
+ * so the description sent to the MCP client and the validation applied
+ * to inbound args cannot drift.
+ */
+export function defineTool(definition, handler) {
+    const schema = convertJsonSchemaToZod(definition.inputSchema);
+    return {
+        definition,
+        handler: async (raw) => {
+            const args = schema.parse(raw);
+            return await handler(args);
+        },
+    };
+}
+/**
+ * Registers a list of RegisteredTool entries on a high-level McpServer.
+ * Converts JSON Schema definitions to Zod and provides consistent
+ * stringification and error catching for tool execution.
+ */
+export function registerToolList(server, tools) {
+    for (const tool of tools) {
+        server.registerTool(tool.definition.name, {
+            description: tool.definition.description,
+            inputSchema: convertJsonSchemaToZod(tool.definition.inputSchema),
+        }, async (args) => {
+            try {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(await tool.handler(args), null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                return remapErrorAsResponse(err);
+            }
+        });
+    }
+}
+export class ReclaimMcpServer {
+    #tools = new Map();
+    #server;
+    constructor() {
+        this.#server = new Server({ name: 'reclaim-agent', version: '0.1.0' }, { capabilities: { tools: {} } });
+        this.#server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            // Double-cast: our `ToolDefinition` carries the same fields as the
+            // SDK's `Tool` but the SDK's type is strict-narrowed and won't
+            // accept ours without going through `unknown`.
+            tools: [...this.#tools.values()].map((t) => t.definition),
+        }));
+        this.#server.setRequestHandler(CallToolRequestSchema, async (req) => {
+            const tool = this.#tools.get(req.params.name);
+            if (!tool) {
+                throw new Error(`unknown tool: ${req.params.name}`);
+            }
+            const result = await tool.handler(req.params.arguments ?? {});
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        });
+    }
+    register(tool) {
+        this.#tools.set(tool.definition.name, tool);
+    }
+    async listen() {
+        await this.#server.connect(new StdioServerTransport());
+    }
+}

package/lib/mcp/start.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;

package/lib/mcp/start.js

@@ -0,0 +1,63 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { DEFAULT_BASE_URL, ReclaimClient } from '@reclaimprotocol/client';
+import { DEFAULT_OLD_API_URL, ReclaimOldClient } from "../old/client.js";
+import { useOldDevtools } from "../old/flag.js";
+import { resolveInitialIdentity } from "../old/identity.js";
+import { OLD_MODE_INSTRUCTIONS } from "../old/instructions.js";
+import { buildOldBackendTools } from "../old/tools/build.js";
+import { NAME, VERSION } from "../pkg.js";
+import { registerTools } from "./api/tools.js";
+import { buildAgentTools } from "./tools/agent/build.js";
+import { buildCredentialTools, buildLocalCredentialTools, } from "./tools/credentials/build.js";
+import { readSession } from "./tools/credentials/session-cache.js";
+import { registerToolList } from "./server.js";
+export async function startMcpServer() {
+    const oldMode = useOldDevtools();
+    const server = new McpServer({ name: NAME, version: VERSION }, oldMode ? { instructions: OLD_MODE_INSTRUCTIONS } : undefined);
+    // Agent tools (Chrome CDP capture, provider synthesis, replay, proof) are
+    // backend-independent and registered in both modes. Skipped in hosted
+    // deployments — set RECLAIM_AGENT_DISABLED=1 to register only the API
+    // surface.
+    const agentToolsEnabled = process.env.RECLAIM_AGENT_DISABLED !== '1';
+    if (oldMode) {
+        // OLD-devtools mode (the default): the legacy backend is still in
+        // production while builder is built. All auto-generated builder tools
+        // are disabled; a small ReclaimOldClient serves authenticate / publish /
+        // get_me_providers instead.
+        const oldClient = new ReclaimOldClient({
+            baseUrl: process.env.RECLAIM_OLD_API_URL || DEFAULT_OLD_API_URL,
+            identity: resolveInitialIdentity(),
+        });
+        registerToolList(server, buildLocalCredentialTools());
+        registerToolList(server, buildOldBackendTools(oldClient));
+        if (agentToolsEnabled) {
+            // No builder client → no builder publish tool (old mode has its own).
+            registerToolList(server, buildAgentTools());
+        }
+        // NOTE: registerTools() is intentionally NOT called — generated tools off.
+    }
+    else {
+        const client = new ReclaimClient({
+            baseUrl: process.env.RECLAIM_API_URL || DEFAULT_BASE_URL,
+            // Priority: explicit env var → cached session token → unauthenticated
+            token: process.env.RECLAIM_API_TOKEN || readSession()?.token,
+            headers: { 'User-Agent': `${NAME}/${VERSION}` },
+        });
+        // Tool names must stay disjoint across these three groups: hand-written
+        // tools are higher-level orchestrations (multi-call flows, ReclaimProvider
+        // translation) and must NOT reuse a generated operation's snake_case name.
+        // A clash throws at startup on purpose — it surfaces an accidental
+        // collision instead of one tool silently shadowing the other.
+        // Register credential tools for ETH credential management.
+        registerToolList(server, buildCredentialTools(client));
+        // Add auto-generated tools with snake_case wrappers
+        // for every MCP-tagged operation.
+        registerTools(server, client);
+        if (agentToolsEnabled) {
+            registerToolList(server, buildAgentTools(client));
+        }
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/lib/mcp/tools/agent/analyze.d.ts

@@ -0,0 +1,3 @@
+import { type RegisteredTool } from '../../server.ts';
+import type { CaptureStore } from './capture.ts';
+export declare function analyzeTool(captures: CaptureStore): RegisteredTool;

package/lib/mcp/tools/agent/analyze.js

@@ -0,0 +1,26 @@
+import { detectConcerns } from "../../../provider/constraints.js";
+import { defineTool } from "../../server.js";
+export function analyzeTool(captures) {
+    return defineTool({
+        name: 'analyze_request_constraints',
+        description: 'Flag potential provider-authoring concerns for a captured request.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                captureId: { type: 'string' },
+                requestId: { type: 'string' },
+            },
+            required: ['captureId', 'requestId'],
+        },
+    }, async ({ captureId, requestId }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        const r = session.requests.get(requestId);
+        if (!r) {
+            throw new Error(`no request ${requestId} in capture ${captureId}`);
+        }
+        return { concerns: detectConcerns(r) };
+    });
+}

package/lib/mcp/tools/agent/attach.d.ts

@@ -0,0 +1,11 @@
+import { type CdpHandles } from '../../../cdp/client.ts';
+import type { ConfigStore } from '../../../config/store.ts';
+import { type RegisteredTool } from '../../server.ts';
+export interface AttachState {
+    handles: CdpHandles;
+    port: number;
+}
+export declare function attachTool(state: {
+    current?: AttachState;
+    config: ConfigStore;
+}): RegisteredTool;

package/lib/mcp/tools/agent/attach.js

@@ -0,0 +1,72 @@
+import { connectCdp } from "../../../cdp/client.js";
+import { defaultProfileDir, launchChrome, waitForCdpReady, } from "../../../cdp/launcher.js";
+import { defaultConfigPath } from "../../../config/store.js";
+import { defineTool } from "../../server.js";
+export function attachTool(state) {
+    return defineTool({
+        name: 'attach_chrome',
+        description: 'Attach to a Chrome instance via CDP. ' +
+            'Auto-launches a dedicated-profile Chrome ' +
+            'on first call if no attachMode is persisted. ' +
+            'Persists the chosen mode in ~/.reclaim/config.json.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                attachMode: { type: 'string', enum: ['dedicated', 'attach'] },
+                port: { type: 'number' },
+            },
+        },
+    }, async (parsed) => {
+        let cfg = state.config.read()?.browser_agent;
+        if (parsed.attachMode || parsed.port) {
+            cfg = {
+                attachMode: parsed.attachMode ?? cfg?.attachMode ?? 'dedicated',
+                port: parsed.port ?? cfg?.port ?? 9222,
+            };
+            state.config.write({ browser_agent: cfg });
+        }
+        if (!cfg) {
+            return {
+                needsChoice: true,
+                message: 'First-run: choose attach mode. ' +
+                    'Call attach_chrome again with attachMode="dedicated" ' +
+                    '(auto-launch a Chrome profile under ~/.reclaim/chrome-profile) ' +
+                    'or attachMode="attach" ' +
+                    '(connect to a Chrome you launched yourself with ' +
+                    'BOTH --remote-debugging-port=9222 AND ' +
+                    '--user-data-dir=<some-non-default-path>; ' +
+                    'since Chrome 136 the debug-port flag is silently ' +
+                    'ignored if the default profile is in use).',
+                configPath: defaultConfigPath(),
+            };
+        }
+        if (cfg.attachMode === 'dedicated') {
+            try {
+                await waitForCdpReady(cfg.port, 500);
+            }
+            catch {
+                launchChrome({ port: cfg.port, profileDir: defaultProfileDir() });
+                await waitForCdpReady(cfg.port, 10_000);
+            }
+        }
+        else {
+            await waitForCdpReady(cfg.port, 2_000).catch(() => {
+                throw new Error(`attach mode: nothing answering CDP on port ${cfg.port}. ` +
+                    'Chrome must be launched with BOTH ' +
+                    `--remote-debugging-port=${cfg.port} AND ` +
+                    '--user-data-dir=<some-non-default-path>. ' +
+                    'Since Chrome 136 (May 2025), the debug-port flag is ' +
+                    'silently ignored when the default ' +
+                    "user profile is in use — that's why nothing opens the port. " +
+                    'Either re-launch Chrome with ' +
+                    'a custom --user-data-dir, or switch to attachMode="dedicated".');
+            });
+        }
+        if (state.current) {
+            await state.current.handles.close().catch(() => { });
+        }
+        const handles = await connectCdp(cfg.port);
+        state.current = { handles, port: cfg.port };
+        return { attached: true, port: cfg.port, mode: cfg.attachMode };
+    });
+}

package/lib/mcp/tools/agent/build.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Factory entry-point for embedding the reclaim-agent's MCP tools into
+ * a host MCP server. Two consumers:
+ *
+ *   - The agent's own standalone `src/index.ts` (uses `ReclaimMcpServer`,
+ *     the low-level wrapper around `@modelcontextprotocol/sdk`'s Server).
+ *   - `@reclaimprotocol/client`'s MCP server (uses `McpServer`, the
+ *     high-level SDK wrapper). Calls `registerAgentTools` to fold the
+ *     agent's 16 tools alongside its auto-generated API tools.
+ *
+ * Shared state — Chrome attach state, capture store, secret store — is
+ * built once per server and threaded through every tool factory.
+ */
+import type { ReclaimClient } from '@reclaimprotocol/client';
+import { ConfigStore } from '../../../config/store.ts';
+import { type RegisteredTool } from '../../server.ts';
+import { type AttachState } from './attach.ts';
+import { type CaptureStore } from './capture.ts';
+import { type SecretStore } from './propose.ts';
+export interface AgentState {
+    attach: {
+        current?: AttachState;
+        config: ConfigStore;
+    };
+    captures: CaptureStore;
+    secrets: SecretStore;
+}
+/** Build the flat list of `RegisteredTool` entries. Useful when the host
+ *  uses our internal `ReclaimMcpServer` interface (`.register(tool)`).
+ *  Pass `client` to include the builder `create_provider_version_from_capture`;
+ *  omit it (e.g. OLD-devtools mode) to register only the backend-independent
+ *  capture/proof tools — old mode supplies its own publish tool. */
+export declare function buildAgentTools(client?: ReclaimClient): RegisteredTool[];

package/lib/mcp/tools/agent/build.js

@@ -0,0 +1,74 @@
+/**
+ * Factory entry-point for embedding the reclaim-agent's MCP tools into
+ * a host MCP server. Two consumers:
+ *
+ *   - The agent's own standalone `src/index.ts` (uses `ReclaimMcpServer`,
+ *     the low-level wrapper around `@modelcontextprotocol/sdk`'s Server).
+ *   - `@reclaimprotocol/client`'s MCP server (uses `McpServer`, the
+ *     high-level SDK wrapper). Calls `registerAgentTools` to fold the
+ *     agent's 16 tools alongside its auto-generated API tools.
+ *
+ * Shared state — Chrome attach state, capture store, secret store — is
+ * built once per server and threaded through every tool factory.
+ */
+import { setCryptoImplementation } from '@reclaimprotocol/tls';
+import { webcryptoCrypto } from '@reclaimprotocol/tls/webcrypto';
+import { ConfigStore } from "../../../config/store.js";
+import { analyzeTool } from "./analyze.js";
+import { attachTool } from "./attach.js";
+import { captureTools } from "./capture.js";
+import { browserTools } from "./eval.js";
+import { findTool } from "./find.js";
+import { proofTool } from "./proof.js";
+import { makeSecretStore, proposeTool, } from "./propose.js";
+import { createVersionFromCaptureTool } from "./publish.js";
+import { replayTool } from "./replay.js";
+import { sessionTools } from "./session.js";
+let cryptoInitialized = false;
+/** One-time crypto backend init for @reclaimprotocol/tls. The package
+ *  ships with an empty `crypto = {}` and defers backend choice to the
+ *  caller; without this, the first proof call dies inside the SDK with
+ *  `crypto.randomBytes is not a function`. */
+function ensureCryptoInit() {
+    if (cryptoInitialized) {
+        return;
+    }
+    setCryptoImplementation(webcryptoCrypto);
+    cryptoInitialized = true;
+}
+function buildAgentState() {
+    return {
+        attach: { config: new ConfigStore() },
+        captures: { sessions: new Map() },
+        secrets: makeSecretStore(),
+    };
+}
+/** Build the flat list of `RegisteredTool` entries. Useful when the host
+ *  uses our internal `ReclaimMcpServer` interface (`.register(tool)`).
+ *  Pass `client` to include the builder `create_provider_version_from_capture`;
+ *  omit it (e.g. OLD-devtools mode) to register only the backend-independent
+ *  capture/proof tools — old mode supplies its own publish tool. */
+export function buildAgentTools(client) {
+    const state = buildAgentState();
+    ensureCryptoInit();
+    const tools = [];
+    tools.push(attachTool(state.attach));
+    for (const t of captureTools(state.attach, state.captures)) {
+        tools.push(t);
+    }
+    tools.push(findTool(state.captures));
+    for (const t of browserTools(state.attach)) {
+        tools.push(t);
+    }
+    for (const t of sessionTools(state.attach, state.captures, state.secrets)) {
+        tools.push(t);
+    }
+    tools.push(analyzeTool(state.captures));
+    tools.push(proposeTool(state.captures, state.secrets));
+    tools.push(replayTool(state.secrets));
+    tools.push(proofTool(state.secrets));
+    if (client) {
+        tools.push(createVersionFromCaptureTool(client));
+    }
+    return tools;
+}

package/lib/mcp/tools/agent/capture.d.ts

@@ -0,0 +1,10 @@
+import { type CaptureSession } from '../../../cdp/capture.ts';
+import { type RegisteredTool } from '../../server.ts';
+import type { AttachState } from './attach.ts';
+export interface CaptureStore {
+    sessions: Map<string, CaptureSession>;
+    activeTab?: string;
+}
+export declare function captureTools(attachRef: {
+    current?: AttachState;
+}, captures: CaptureStore): RegisteredTool[];

package/lib/mcp/tools/agent/capture.js

@@ -0,0 +1,142 @@
+import { startCapture } from "../../../cdp/capture.js";
+import { defineTool } from "../../server.js";
+export function captureTools(attachRef, captures) {
+    const requireAttached = () => {
+        if (!attachRef.current) {
+            throw new Error('Not attached. Call attach_chrome first.');
+        }
+        return attachRef.current;
+    };
+    const startTool = defineTool({
+        name: 'start_capture',
+        description: 'Begin recording network requests on the specified tab. ' +
+            'Returns a captureId.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabId: { type: 'string' } },
+            required: ['tabId'],
+        },
+    }, async ({ tabId }) => {
+        const attached = requireAttached();
+        const tabClient = await attached.handles.attachToTab(tabId);
+        const session = await startCapture(tabClient);
+        captures.sessions.set(session.captureId, session);
+        captures.activeTab = tabId;
+        return { captureId: session.captureId };
+    });
+    const stopTool = defineTool({
+        name: 'stop_capture',
+        description: 'Stop recording on the given capture. ' +
+            'Captured data remains queryable until reset_session.',
+        inputSchema: {
+            type: 'object',
+            properties: { captureId: { type: 'string' } },
+            required: ['captureId'],
+        },
+    }, async ({ captureId }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        await session.stop();
+        return { stopped: true, requestCount: session.requests.size };
+    });
+    const listTool = defineTool({
+        name: 'list_requests',
+        description: 'List metadata for captured requests. ' +
+            'Filter by method, URL glob, status, content-type, ' +
+            'or graphqlOp. Returns only metadata, never bodies — ' +
+            'use get_request for those.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                captureId: { type: 'string' },
+                filter: {
+                    type: 'object',
+                    properties: {
+                        method: { type: 'string' },
+                        urlGlob: { type: 'string' },
+                        statusMin: { type: 'number' },
+                        statusMax: { type: 'number' },
+                        contentType: { type: 'string' },
+                        graphqlOp: { type: 'string' },
+                    },
+                },
+            },
+            required: ['captureId'],
+        },
+    }, async ({ captureId, filter }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        const out = [];
+        for (const r of session.requests.values()) {
+            if (filter?.method && r.method !== filter.method.toUpperCase()) {
+                continue;
+            }
+            if (filter?.urlGlob && !globMatch(filter.urlGlob, r.url)) {
+                continue;
+            }
+            if (filter?.statusMin !== undefined && r.status < filter.statusMin) {
+                continue;
+            }
+            if (filter?.statusMax !== undefined && r.status > filter.statusMax) {
+                continue;
+            }
+            if (filter?.contentType &&
+                !r.contentType.includes(filter.contentType)) {
+                continue;
+            }
+            if (filter?.graphqlOp && r.graphqlOp !== filter.graphqlOp) {
+                continue;
+            }
+            const item = {
+                requestId: r.requestId,
+                method: r.method,
+                url: r.url,
+                status: r.status,
+                contentType: r.contentType,
+                size: r.size,
+            };
+            if (r.graphqlOp !== undefined) {
+                item.graphqlOp = r.graphqlOp;
+            }
+            out.push(item);
+        }
+        return { requests: out };
+    });
+    const getTool = defineTool({
+        name: 'get_request',
+        description: 'Return full headers + bodies for a specific captured request.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                captureId: { type: 'string' },
+                requestId: { type: 'string' },
+            },
+            required: ['captureId', 'requestId'],
+        },
+    }, async ({ captureId, requestId }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        const r = session.requests.get(requestId);
+        if (!r) {
+            throw new Error(`no request ${requestId} in capture ${captureId}`);
+        }
+        const body = session.bodies.get(requestId);
+        if (!body.available) {
+            return { ...r, bodyAvailable: false, reason: body.reason };
+        }
+        return { ...r, responseBody: body.body, bodyAvailable: true };
+    });
+    return [startTool, stopTool, listTool, getTool];
+}
+function globMatch(pattern, str) {
+    const re = new RegExp('^' +
+        pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') +
+        '$');
+    return re.test(str);
+}

package/lib/mcp/tools/agent/eval.d.ts

@@ -0,0 +1,5 @@
+import { type RegisteredTool } from '../../server.ts';
+import type { AttachState } from './attach.ts';
+export declare function browserTools(attachRef: {
+    current?: AttachState;
+}): RegisteredTool[];