@reclaimprotocol/agent 0.1.5 → 0.1.6

package/lib/mcp/server.js

@@ -1,23 +1,9 @@
 import { toZod } from "./api/to-zod.js";
 import { remapErrorAsResponse } from "./remap_errors.js";
-const NOOP_CONTEXT = { reportProgress: async () => { } };
-/**
- * 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 = toZod(definition.inputSchema);
-    return {
-        definition,
-        handler: async (raw, ctx = NOOP_CONTEXT) => {
-            const args = schema.parse(raw);
-            return await handler(args, ctx);
-        },
-    };
-}
+// The tool primitive lives in `../tools/registry.ts` (SDK-free, so the cloud
+// loop can use it too). Re-exported here so the MCP-side tool files can keep
+// importing `defineTool`/`RegisteredTool` from the server module.
+export { defineTool, } from "../tools/registry.js";
 /**
  * Registers a list of RegisteredTool entries on a high-level McpServer.
  * Converts JSON Schema definitions to Zod and provides consistent
@@ -28,27 +14,13 @@ export function registerToolList(server, tools) {
         server.registerTool(tool.definition.name, {
             description: tool.definition.description,
             inputSchema: toZod(tool.definition.inputSchema),
-        }, async (args, extra) => {
+        }, async (args) => {
             try {
-                const progressToken = extra?._meta?.progressToken;
-                let progress = 0;
-                const ctx = {
-                    reportProgress: async (message) => {
-                        if (progressToken === undefined) {
-                            return;
-                        }
-                        progress += 1;
-                        await extra.sendNotification({
-                            method: 'notifications/progress',
-                            params: { progressToken, progress, message },
-                        }).catch(() => { });
-                    },
-                };
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(await tool.handler(args, ctx), null, 2),
+                            text: JSON.stringify(await tool.handler(args), null, 2),
                         },
                     ],
                 };

package/lib/mcp/start.js

@@ -1,10 +1,11 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ReclaimClient } from '@reclaimprotocol/client';
-import { agentDisabled, apiToken, apiUrl, oldApiUrl, oldLogsUrl, useOldDevtools, } from "../consts.js";
+import { agentDisabled, apiToken, apiUrl, oldApiUrl, oldLogsUrl, sdkApiUrl, useOldDevtools, } from "../consts.js";
 import { ReclaimOldClient } from "../old/client.js";
 import { resolveInitialIdentity } from "../old/identity.js";
 import { OLD_MODE_INSTRUCTIONS } from "../old/instructions.js";
+import { ReclaimSdkClient } from "../old/sdk-client.js";
 import { buildOldBackendTools } from "../old/tools/build.js";
 import { NAME, VERSION } from "../pkg.js";
 import { registerTools } from "./api/tools.js";
@@ -33,8 +34,9 @@ export async function startMcpServer() {
             logsBaseUrl: oldLogsUrl(),
             identity: resolveInitialIdentity(),
         });
+        const sdkClient = new ReclaimSdkClient({ baseUrl: sdkApiUrl() });
         registerToolList(server, buildLocalCredentialTools());
-        registerToolList(server, buildOldBackendTools(oldClient));
+        registerToolList(server, buildOldBackendTools(oldClient, sdkClient));
         if (agentToolsEnabled) {
             // No builder client → no builder publish tool (old mode has its own).
             registerToolList(server, buildAgentTools());

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

@@ -13,11 +13,11 @@ export function analyzeTool(captures) {
             required: ['captureId', 'requestId'],
         },
     }, async ({ captureId, requestId }) => {
-        const session = captures.sessions.get(captureId);
-        if (!session) {
+        const entry = captures.sessions.get(captureId);
+        if (!entry) {
             throw new Error(`no capture ${captureId}`);
         }
-        const r = session.requests.get(requestId);
+        const r = entry.session.requests.get(requestId);
         if (!r) {
             throw new Error(`no request ${requestId} in capture ${captureId}`);
         }

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

@@ -4,22 +4,22 @@
  * `@modelcontextprotocol/sdk` `McpServer`. Folds the agent's tools
  * alongside the auto-generated API tools.
  *
- * Shared state — Chrome attach state, capture store, secret store — is
- * built once per server and threaded through every tool factory.
+ * Shared state — Chrome attach state + capture store — is built once per
+ * server and threaded through every tool factory. Per-capture drafts (and the
+ * secrets they hold) live inside each capture entry, so a capture IS the
+ * session for the shared authoring tools.
  */
 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, ready for
  *  `registerToolList`.

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

@@ -4,27 +4,25 @@
  * `@modelcontextprotocol/sdk` `McpServer`. Folds the agent's tools
  * alongside the auto-generated API tools.
  *
- * Shared state — Chrome attach state, capture store, secret store — is
- * built once per server and threaded through every tool factory.
+ * Shared state — Chrome attach state + capture store — is built once per
+ * server and threaded through every tool factory. Per-capture drafts (and the
+ * secrets they hold) live inside each capture entry, so a capture IS the
+ * session for the shared authoring tools.
  */
 import { ConfigStore } from "../../../config/store.js";
 import { ensureAttestorCrypto } from "../../../proof/proof-core.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 { listTabsTool } from "./eval.js";
 import { howItWorksTool } from "./how-it-works.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";
+import { sharedAuthoringTools } from "./shared.js";
 function buildAgentState() {
     return {
         attach: { config: new ConfigStore() },
         captures: { sessions: new Map() },
-        secrets: makeSecretStore(),
     };
 }
 /** Build the flat list of `RegisteredTool` entries, ready for
@@ -40,20 +38,20 @@ export function buildAgentTools(client) {
     // client. No `client` ⇒ old-devtools mode (see `mcp/start.ts`).
     tools.push(howItWorksTool(!client));
     tools.push(attachTool(state.attach));
+    tools.push(listTabsTool(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)) {
+    for (const t of sessionTools(state.attach, state.captures)) {
         tools.push(t);
     }
-    for (const t of sessionTools(state.attach, state.captures, state.secrets)) {
+    tools.push(analyzeTool(state.captures));
+    // navigate / eval_in_page / wait_for_page / get_cookies / list_requests /
+    // find_requests_containing / propose_provider / replay_request / run_proof —
+    // shared with the cloud loop, bound to each capture's local backend.
+    for (const t of sharedAuthoringTools(state.captures)) {
         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));
     }

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

@@ -1,8 +1,20 @@
+import { type DraftStore } from '../../../authoring/index.ts';
 import { type CaptureSession } from '../../../cdp/capture.ts';
 import { type RegisteredTool } from '../../server.ts';
 import type { AttachState } from './attach.ts';
+/**
+ * One capture == a session (network requests) + the tab CDP client it runs on +
+ * a draft store. Bundling the tab client is what lets the shared authoring
+ * tools treat a `captureId` as a full session (drive the browser AND read
+ * capture AND hold drafts) behind one id.
+ */
+export interface CaptureEntry {
+    session: CaptureSession;
+    tabClient: Awaited<ReturnType<AttachState['handles']['attachToTab']>>;
+    drafts: DraftStore;
+}
 export interface CaptureStore {
-    sessions: Map<string, CaptureSession>;
+    sessions: Map<string, CaptureEntry>;
     activeTab?: string;
 }
 export declare function captureTools(attachRef: {

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

@@ -1,3 +1,4 @@
+import { makeDraftStore } from "../../../authoring/index.js";
 import { startCapture } from "../../../cdp/capture.js";
 import { defineTool } from "../../server.js";
 export function captureTools(attachRef, captures) {
@@ -9,8 +10,9 @@ export function captureTools(attachRef, captures) {
     };
     const startTool = defineTool({
         name: 'start_capture',
-        description: 'Begin recording network requests on the specified tab. ' +
-            'Returns a captureId.',
+        description: 'Begin recording network requests on the specified tab. '
+            + 'Returns a captureId — the session handle the authoring tools '
+            + '(navigate, propose_provider, run_proof, …) all take.',
         inputSchema: {
             type: 'object',
             properties: { tabId: { type: 'string' } },
@@ -20,91 +22,28 @@ export function captureTools(attachRef, captures) {
         const attached = requireAttached();
         const tabClient = await attached.handles.attachToTab(tabId);
         const session = await startCapture(tabClient);
-        captures.sessions.set(session.captureId, session);
+        captures.sessions.set(session.captureId, {
+            session, tabClient, drafts: makeDraftStore(),
+        });
         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.',
+        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) {
+        const entry = captures.sessions.get(captureId);
+        if (!entry) {
             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 };
+        await entry.session.stop();
+        return { stopped: true, requestCount: entry.session.requests.size };
     });
     const getTool = defineTool({
         name: 'get_request',
@@ -118,25 +57,19 @@ export function captureTools(attachRef, captures) {
             required: ['captureId', 'requestId'],
         },
     }, async ({ captureId, requestId }) => {
-        const session = captures.sessions.get(captureId);
-        if (!session) {
+        const entry = captures.sessions.get(captureId);
+        if (!entry) {
             throw new Error(`no capture ${captureId}`);
         }
-        const r = session.requests.get(requestId);
+        const r = entry.session.requests.get(requestId);
         if (!r) {
             throw new Error(`no request ${requestId} in capture ${captureId}`);
         }
-        const body = session.bodies.get(requestId);
+        const body = entry.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);
+    return [startTool, stopTool, getTool];
 }

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

@@ -1,5 +1,8 @@
 import { type RegisteredTool } from '../../server.ts';
 import type { AttachState } from './attach.ts';
-export declare function browserTools(attachRef: {
+/** The one browser tool that isn't session-bound: enumerate tabs so the caller
+ *  can pick one to `start_capture` on. Navigate/eval/wait are the shared
+ *  authoring tools (keyed by captureId — see `shared.ts`). */
+export declare function listTabsTool(attachRef: {
     current?: AttachState;
-}): RegisteredTool[];
+}): RegisteredTool;

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

@@ -1,127 +1,17 @@
 import { listTabs } from "../../../cdp/tabs.js";
 import { defineTool } from "../../server.js";
-export function browserTools(attachRef) {
-    const requireAttached = () => {
+/** The one browser tool that isn't session-bound: enumerate tabs so the caller
+ *  can pick one to `start_capture` on. Navigate/eval/wait are the shared
+ *  authoring tools (keyed by captureId — see `shared.ts`). */
+export function listTabsTool(attachRef) {
+    return defineTool({
+        name: 'list_tabs',
+        description: 'List open Chrome tabs.',
+        inputSchema: { type: 'object', properties: {} },
+    }, async () => {
         if (!attachRef.current) {
             throw new Error('Not attached. Call attach_chrome first.');
         }
-        return attachRef.current;
-    };
-    return [
-        defineTool({
-            name: 'list_tabs',
-            description: 'List open Chrome tabs.',
-            inputSchema: { type: 'object', properties: {} },
-        }, async () => {
-            const attached = requireAttached();
-            return { tabs: await listTabs(attached.port) };
-        }),
-        defineTool({
-            name: 'eval_in_page',
-            description: 'Run a JS expression in a tab via Runtime.evaluate ' +
-                'and return the result. ' +
-                'Useful for reading visible values from the DOM.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    tabId: { type: 'string' },
-                    expression: { type: 'string' },
-                },
-                required: ['tabId', 'expression'],
-            },
-        }, async ({ tabId, expression }) => {
-            const attached = requireAttached();
-            const { Runtime } = await attached.handles.attachToTab(tabId);
-            const result = await Runtime.evaluate({
-                expression,
-                returnByValue: true,
-            });
-            if (result.exceptionDetails) {
-                return { error: result.exceptionDetails.text };
-            }
-            return { value: result.result.value };
-        }),
-        defineTool({
-            name: 'navigate',
-            description: 'Navigate a tab to a URL via Page.navigate, ' +
-                'waiting for the load event. ' +
-                'Use this to drive the browser yourself ' +
-                'instead of asking the developer to navigate. ' +
-                'Returns the final URL after navigation ' +
-                '(which may differ from the requested URL due to redirects).',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    tabId: { type: 'string' },
-                    url: { type: 'string' },
-                    timeoutMs: { type: 'number' },
-                },
-                required: ['tabId', 'url'],
-            },
-        }, async ({ tabId, url, timeoutMs }) => {
-            const attached = requireAttached();
-            const { Page, Runtime } = await attached.handles.attachToTab(tabId);
-            await Page.enable();
-            const loadPromise = new Promise((resolve) => {
-                Page.loadEventFired(() => resolve());
-            });
-            const nav = await Page.navigate({ url });
-            if (nav.errorText) {
-                return { ok: false, error: nav.errorText };
-            }
-            const t = timeoutMs ?? 30_000;
-            const raced = await Promise.race([
-                loadPromise.then(() => 'loaded'),
-                new Promise((resolve) => setTimeout(() => resolve('timeout'), t)),
-            ]);
-            const final = await Runtime.evaluate({
-                expression: 'location.href',
-                returnByValue: true,
-            });
-            return {
-                ok: true,
-                loadStatus: raced,
-                finalUrl: final.result.value,
-            };
-        }),
-        defineTool({
-            name: 'wait_for_page',
-            description: 'Poll a JS expression in a tab until it ' +
-                'returns truthy (or timeout). ' +
-                'Use this for steps that require the ' +
-                'developer to do something in the browser — ' +
-                'most commonly waiting for them to finish logging in. ' +
-                'Pass an expression that ' +
-                'evaluates true once the desired state is reached, e.g. ' +
-                '`!!document.querySelector' +
-                '(\'summary[aria-label*="View profile"]\')`' +
-                ' for GitHub post-login.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    tabId: { type: 'string' },
-                    expression: { type: 'string' },
-                    timeoutMs: { type: 'number' },
-                    pollMs: { type: 'number' },
-                },
-                required: ['tabId', 'expression'],
-            },
-        }, async ({ tabId, expression, timeoutMs, pollMs }) => {
-            const attached = requireAttached();
-            const { Runtime } = await attached.handles.attachToTab(tabId);
-            const deadline = Date.now() + (timeoutMs ?? 120_000);
-            const interval = pollMs ?? 1000;
-            while (Date.now() < deadline) {
-                const r = await Runtime.evaluate({ expression, returnByValue: true });
-                if (r.exceptionDetails) {
-                    return { matched: false, error: r.exceptionDetails.text };
-                }
-                if (r.result.value) {
-                    return { matched: true, value: r.result.value };
-                }
-                await new Promise((resolve) => setTimeout(resolve, interval));
-            }
-            return { matched: false, reason: 'timeout' };
-        }),
-    ];
+        return { tabs: await listTabs(attachRef.current.port) };
+    });
 }

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

@@ -1,3 +1,10 @@
-import { type RegisteredTool } from '../../server.ts';
-import type { CaptureStore } from './capture.ts';
-export declare function findTool(captures: CaptureStore): RegisteredTool;
+/**
+ * `find_requests_containing` — search captured responses for any encoding of a
+ * value and rank the requests that return it. Authored once as a plain
+ * {@link RegisteredTool}; the MCP and cloud loop each pass their own backend
+ * resolver (see authoring/tools.ts / shared.ts). Server-side: response bodies
+ * stay here, only metadata + a short snippet leave.
+ */
+import { type ResolveBackend } from '../../../authoring/util.ts';
+import { type RegisteredTool } from '../../../tools/registry.ts';
+export declare function findTool(resolveBackend: ResolveBackend): RegisteredTool;

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

@@ -1,29 +1,26 @@
+/**
+ * `find_requests_containing` — search captured responses for any encoding of a
+ * value and rank the requests that return it. Authored once as a plain
+ * {@link RegisteredTool}; the MCP and cloud loop each pass their own backend
+ * resolver (see authoring/tools.ts / shared.ts). Server-side: response bodies
+ * stay here, only metadata + a short snippet leave.
+ */
+import { objectSchema, publicRequest, } from "../../../authoring/util.js";
 import { normalizeCandidates } from "../../../provider/normalize.js";
-import { defineTool } from "../../server.js";
-export function findTool(captures) {
+import { defineTool } from "../../../tools/registry.js";
+export function findTool(resolveBackend) {
     return defineTool({
         name: 'find_requests_containing',
-        description: 'Search captured responses for any encoding of `value`.' +
-            'Returns a ranked candidate list ' +
-            'with the JSON path (when applicable), score, and a short snippet.' +
-            'Server-side; bodies stay here.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                captureId: { type: 'string' },
-                value: { type: 'string' },
-                limit: { type: 'number' },
-            },
-            required: ['captureId', 'value'],
-        },
-    }, async ({ captureId, value, limit }) => {
-        const session = captures.sessions.get(captureId);
-        if (!session) {
-            throw new Error(`no capture ${captureId}`);
-        }
-        const variants = normalizeCandidates(value);
+        description: 'Search captured responses for any encoding of `value` (raw, '
+            + 'URL/JSON/HTML-escaped, …). Returns a ranked candidate list with '
+            + 'the matched variant, score, and a short snippet — used to locate '
+            + 'the request that returns a target. Server-side; bodies stay here.',
+        inputSchema: objectSchema({ value: { type: 'string' }, limit: { type: 'number' } }, ['value']),
+    }, async (args) => {
+        const backend = resolveBackend(args);
+        const variants = normalizeCandidates(String(args.value));
         const ranked = [];
-        for (const r of session.requests.values()) {
+        for (const r of backend.capture.requests.values()) {
             if (!r.responseBody) {
                 continue;
             }
@@ -40,21 +37,18 @@ export function findTool(captures) {
             if (!hit) {
                 continue;
             }
-            // Score: prefer JSON responses + smaller bodies (likely API endpoints).
-            const score = (r.contentType.includes('json') ? 10 : 0) +
-                Math.max(0, 5 - Math.log10(Math.max(r.size, 1)));
+            // Prefer JSON responses + smaller bodies (likely API endpoints).
+            const score = (r.contentType.includes('json') ? 10 : 0)
+                + Math.max(0, 5 - Math.log10(Math.max(r.size, 1)));
             ranked.push({
-                requestId: r.requestId,
-                url: r.url,
-                method: r.method,
-                status: r.status,
-                contentType: r.contentType,
+                ...publicRequest(r),
                 matchedVariant: hit.variant,
                 snippet: hit.snippet,
                 score,
             });
         }
         ranked.sort((a, b) => b.score - a.score);
-        return { candidates: ranked.slice(0, limit ?? 10) };
+        const limit = Number(args.limit) || 10;
+        return { candidates: ranked.slice(0, limit) };
     });
 }

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

@@ -1,3 +1,13 @@
-import { type RegisteredTool } from '../../server.ts';
-import type { SecretStore } from './propose.ts';
-export declare function proofTool(secrets: SecretStore): RegisteredTool;
+import { type ProofResult } from '../../../proof/attestor.ts';
+/**
+ * The MCP's rich `run_proof` view: persist the full claim to disk, return
+ * identifier + extractedParameters + a prettified claim (request dropped, byte
+ * arrays as base64) + trimmed logs, and — under `RECLAIM_AGENT_TRACE=1` — a
+ * forensic run dump. This is the developer-facing shape; the cloud backend
+ * projects the same {@link ProofResult} to a lean summary instead.
+ */
+export declare function shapeRichProofResult(result: ProofResult, opts: {
+    provider: unknown;
+    hasSecrets: boolean;
+    attestorUrl?: string;
+}): Record<string, unknown>;