@reclaimprotocol/agent 0.1.28 → 0.1.31

package/lib/mcp/tools/agent/live-view.js

@@ -1,57 +1,45 @@
 /**
- * `share_browser_view` / `stop_browser_view` — put the attached container
- * browser's built-in viewer behind a public URL so someone who is not at this
- * machine can watch it and optionally drive it.
+ * `share_browser_view` — gives the calling agent what it needs to put the
+ * attached container browser's built-in viewer behind a public URL, so someone
+ * who is not at this machine can watch it and optionally drive it.
  *
- * Scoped to `container` mode on purpose. A `builder`-mode browser already has
- * a hosted live view at `attach_browser`'s `liveViewUrl`; tunnelling a second
- * one would duplicate it, so this refuses and points at the existing URL.
+ * The server never runs, downloads or resolves cloudflared: the agent runs it
+ * itself and passes the resulting `trycloudflare.com` URL back to get the link
+ * to hand out.
  *
- * The share is deliberately explicit and single-instance: one live view per
- * attached browser, started only when asked for, and torn down by
- * `stop_browser_view`, `dispose_browser`, or `reset_session`.
+ * Scoped to `container` mode on purpose. A `builder`-mode browser already has
+ * a hosted live view at `attach_browser`'s `liveViewUrl`.
  */
-import { badRequest, conflict } from '@hapi/boom';
+import { badRequest } from '@hapi/boom';
 import assert from 'node:assert';
-import { startTunnel } from "../../../live/tunnel.js";
-import { LOGGER } from "../../../logger.js";
 import { defineTool } from "../../server.js";
 import { SHAREABLE_MODES } from "./attach.js";
 import { ensureLiveViewUrl } from "./live-view-url.js";
-/** Tear down whatever share is running. Safe when none is. Exported so the
- *  session tools can call it from `dispose_browser` / `reset_session`. */
-export async function stopLiveShare(ref) {
-    const share = ref.current;
-    if (!share) {
-        return false;
-    }
-    ref.current = undefined;
-    // Only the tunnel is ours to close. The browser and its viewer belong to the
-    // container, which keeps running until the browser is disposed.
-    await share.tunnel.stop().catch((err) => {
-        LOGGER.warn({ err }, 'live view: tunnel stop failed');
-    });
-    return true;
-}
-export function liveViewTools(attachRef, shareRef, openTunnel = startTunnel) {
+/** Quick-tunnel hostnames only: `https://<words>.trycloudflare.com`. */
+const QUICK_TUNNEL_HOST = /\.trycloudflare\.com$/i;
+export function liveViewTools(attachRef) {
     return [
         defineTool({
             name: 'share_browser_view',
-            description: 'Opens a public HTTPS tunnel to the attached `container` browser '
-                + 'viewer. Use it when someone else must sign in or control it. '
-                + 'Returns `url` with `liveview.html?magnify=1`; relay it verbatim '
-                + 'on its own line. '
-                + 'Only `container` supports this. For `builder`, relay '
-                + 'the `liveViewUrl` from attach_browser; local modes '
-                + '(`dedicated`, `attach`, `custom`) '
-                + 'cannot be shared. The URL is a credential: anyone with it can '
-                + 'control the signed-in browser. Share it only with the intended '
-                + 'person and call stop_browser_view when done. `propagating: true` '
-                + 'means the tunnel remains live while the Cloudflare edge starts; '
-                + 'reuse the URL and reload after a few seconds rather than creating '
-                + 'another tunnel.',
-            inputSchema: { type: 'object', properties: {} },
-        }, async () => {
+            description: 'Shares an attached `container` browser with someone who is not at '
+                + 'this machine. Step 1: call with no arguments to get the local '
+                + 'viewer URL and the `cloudflared` command to run yourself (this '
+                + 'server does not run it). Step 2: after cloudflared prints its '
+                + '`https://*.trycloudflare.com` URL, call again with it as '
+                + '`publicUrl` to get the link to relay. Treat the link as a '
+                + 'credential. For `builder`, use the `liveViewUrl` from '
+                + '`attach_browser`.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    publicUrl: {
+                        type: 'string',
+                        description: 'The `https://*.trycloudflare.com` URL that '
+                            + 'cloudflared printed.',
+                    },
+                },
+            },
+        }, async (parsed) => {
             const attached = attachRef.current;
             assert(attached, badRequest('No browser attached. Call attach_browser first.'));
             const hostedViewUrl = attached.liveViewUrl
@@ -66,67 +54,54 @@ export function liveViewTools(attachRef, shareRef, openTunnel = startTunnel) {
                         + 'Reclaim runtime in Docker — free, needs Docker) or '
                         + '"builder" (hosted, no install, chargeable)')
                 + '.'));
-            assert(!shareRef.current, conflict('A live view is already running at '
-                + `${shareRef.current?.url}. Call stop_browser_view first, or `
-                + 'reuse that URL.'));
             // The container publishes its viewer on loopback and its full CDP
-            // port beside it. Only the VIEWER is ever tunnelled: the CDP port is
-            // unauthenticated, total control of the browser, and putting it on a
-            // public URL would hand that to anyone with the link.
+            // port beside it. Only the VIEWER may be exposed: the CDP port is
+            // unauthenticated, total control of the browser.
             const viewerPort = attached.viewerPort;
             assert(viewerPort, badRequest('This browser reports no live-view port. Re-attach with mode '
                 + '"container".'));
-            const tunnel = await openTunnel(viewerPort, {
-                probePath: '/liveview.html?magnify=1',
-            });
-            // The path is the runtime's own viewer page; `magnify=1` is what makes
-            // it lay out for the device that opens it.
-            const url = ensureLiveViewUrl(tunnel.url);
-            const share = {
-                tunnel, url,
-            };
-            shareRef.current = share;
-            LOGGER.info({ mode: attached.mode }, 'live view shared');
+            if (parsed.publicUrl) {
+                const publicUrl = parseQuickTunnelUrl(parsed.publicUrl);
+                return {
+                    url: ensureLiveViewUrl(publicUrl.origin),
+                    _notes: [
+                        'Relay `url` to the developer verbatim, on its own line.',
+                        'The URL is a credential: it needs no login, and anyone with '
+                            + 'it can see this browser and act in it as the signed-in user.',
+                        'It shows the whole browser, so a sign-in that opens a '
+                            + 'separate window is visible too.',
+                        'Opening it on a phone lays the page out for that phone, with '
+                            + 'touch, pinch-zoom and the soft keyboard.',
+                        'When they are done, stop the cloudflared process you started. '
+                            + 'The browser keeps running until `dispose_browser`.',
+                    ],
+                };
+            }
+            const localUrl = `http://localhost:${viewerPort}`;
             return {
-                url,
-                ...(share.tunnel.ready
-                    ? {}
-                    : {
-                        propagating: true,
-                        cloudflaredLog: share.tunnel.cloudflaredLog,
-                    }),
-                ...(share.tunnel.binary.source === 'downloaded'
-                    ? { cloudflaredInstalled: true }
-                    : {}),
+                localViewerUrl: ensureLiveViewUrl(localUrl),
+                port: viewerPort,
+                command: `cloudflared tunnel --url ${localUrl}`,
                 _notes: [
-                    ...(share.tunnel.binary.source === 'downloaded'
-                        ? ['cloudflared was not installed, so it was downloaded once '
-                                + 'to ~/.reclaim/bin. Mention that; later shares reuse it.']
-                        : []),
-                    ...(share.tunnel.ready
-                        ? []
-                        : ['The tunnel hostname exists but the public viewer is still '
-                                + 'propagating. Relay the URL now; if it errors, wait a few '
-                                + 'seconds and reload. Do not start a second tunnel.']),
-                    'Relay `url` to the developer verbatim, on its own line.',
-                    'The URL is a credential: it needs no login, and anyone with it '
-                        + 'can see this browser and act in it as the signed-in user.',
-                    'It shows the whole browser, so a sign-in that opens a separate '
-                        + 'window is visible too — unlike a single-tab stream.',
-                    'Opening it on a phone lays the page out for that phone, with '
-                        + 'touch, pinch-zoom and the soft keyboard.',
-                    'Call stop_browser_view when they are done. That closes the '
-                        + 'tunnel only — the browser keeps running.',
+                    'Run `command` yourself in a background process. If `cloudflared` '
+                        + 'is not installed, tell the developer and ask them to install '
+                        + 'it (https://developers.cloudflare.com/cloudflare-one/'
+                        + 'connections/connect-networks/downloads/) — do not install it '
+                        + 'without their approval.',
+                    'Read its output for a line containing '
+                        + '`https://<words>.trycloudflare.com`. That is the public URL.',
+                    'Call share_browser_view again with that value as `publicUrl` '
+                        + 'to get the link to relay. Never guess or reconstruct the '
+                        + 'hostname.',
+                    'Expose only this port. Never tunnel the browser\'s CDP port.',
                 ],
             };
         }),
-        defineTool({
-            name: 'stop_browser_view',
-            description: 'Stops the public tunnel opened by share_browser_view; the URL stops '
-                + 'resolving. Call it when the viewer is done. The browser stays '
-                + 'attached, its local viewer keeps serving, and capture continues. '
-                + 'Returns `stopped: false` when no public share is active.',
-            inputSchema: { type: 'object', properties: {} },
-        }, async () => ({ stopped: await stopLiveShare(shareRef) })),
     ];
 }
+function parseQuickTunnelUrl(value) {
+    const url = URL.parse(value);
+    assert(url?.protocol === 'https:' && QUICK_TUNNEL_HOST.test(url.hostname), badRequest('publicUrl must be the https://*.trycloudflare.com URL printed by '
+        + 'cloudflared.'));
+    return url;
+}

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

@@ -13,29 +13,13 @@ import { defineTool } from "../../../tools/registry.js";
 export function proposeTool(resolveBackend) {
     return defineTool({
         name: 'propose_provider',
-        description: 'Draft a provider from ONE captured request. Pass `targets` (an '
-            + 'array): one entry per value to extract, each with its `value` '
-            + '(verbatim) and a distinct `name` (its param). The provider gets '
-            + 'one match + redaction per target. Returns a draftId + recipe '
-            + '(never secrets). Prefer a SINGLE request holding ALL values. '
-            + 'Single-value shorthand: `target` + `name`. Per-target `hash` '
-            + 'OPRF-hashes that value. BY DEFAULT each `name` is shortened to '
-            + 'its last alphanumeric token, lowercased, to form the param key '
-            + '(for example, "employer_name" → "name") — pick names that stay '
-            + 'distinct '
-            + 'after shortening ("firstName"/"surname", not "first_name"/'
-            + '"last_name"). Pass `shortenNames: false` to use each `name` '
-            + 'VERBATIM as the param key instead — it becomes both a regex '
-            + 'capture-group name and a paramValues key, so it must be a plain '
-            + 'identifier (letters/digits/underscore, not starting with a '
-            + 'digit); we recommend lower_snake_case (for example, '
-            + '"employer_name"), '
-            + 'but you choose the exact name. For a parameter used only to build a '
-            + 'later claim request, preserve a `REQ_` prefix (body, header, or '
-            + 'intermediate value) or `URL_` prefix (path or query value) by '
-            + 'setting `shortenNames: false`. The prefix hides that internal '
-            + 'parameter from the data-point UI; it remains available to named '
-            + 'regexes and `{{param}}` substitutions.',
+        description: 'Drafts a provider from one authenticated captured request and '
+            + 'keeps captured secrets server-side. Use `targets` for every value '
+            + 'available in the same response; the result contains a `draftId` '
+            + 'and secret-free recipe. Set `shortenNames: false` to preserve an '
+            + 'explicit parameter name, including a hidden `REQ_` or `URL_` '
+            + 'prefix. For matching and naming guidance, call '
+            + 'how_it_works({ topic: "draft" }) and topic `params`.',
         inputSchema: objectSchema({
             requestId: { type: 'string' },
             name: { type: 'string' },

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

@@ -101,27 +101,80 @@ const ALLOWED_JS_REQUEST_SCHEMA = {
     },
     required: ['url', 'method'],
 };
+const BROWSER_REQUEST_ACTION_SCHEMA = {
+    type: 'object',
+    description: 'Portal-only authenticated browser action. The page supplies the action ' +
+        'id and declared primitive inputs; this object fixes the HTTPS origin, ' +
+        'request template, and returned fields.',
+    properties: {
+        id: { type: 'string', pattern: '^[A-Za-z][A-Za-z0-9_-]{0,99}$' },
+        origin: { type: 'string', pattern: '^https://[^/?#]+$' },
+        path: { type: 'string', pattern: '^/(?:$|[^/\\\\][^\\\\]*)$' },
+        pathTemplate: {
+            type: 'string',
+            pattern: '^/(?:$|[^/\\\\][^\\\\]*)$',
+            description: 'Origin-relative path/query template using `{{name}}` inputs.',
+        },
+        method: {
+            type: 'string',
+            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+        },
+        transport: { type: 'string', enum: ['fetch', 'navigate'] },
+        userAgent: {
+            type: 'string',
+            minLength: 1,
+            maxLength: 300,
+            pattern: '^[^\\r\\n]+$',
+            description: 'Browser User-Agent applied before the isolated action page navigates.',
+        },
+        omitOriginHeader: {
+            type: 'boolean',
+            description: 'Remove Chromium\'s automatic Origin header from a fetch action. ' +
+                'Unsupported for navigate actions.',
+        },
+        headers: {
+            type: 'object',
+            additionalProperties: { type: 'string' },
+        },
+        headersTemplate: {
+            type: 'object',
+            description: 'Header values may interpolate declared `{{name}}` inputs.',
+            additionalProperties: { type: 'string' },
+        },
+        bodyTemplate: {
+            type: 'string',
+            description: 'JSON template using declared `{{name}}` inputs.',
+        },
+        cookieValueHeader: {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                cookieName: { type: 'string' },
+            },
+            required: ['name', 'cookieName'],
+        },
+        includeBody: { type: 'boolean' },
+        inputKeys: {
+            type: 'array',
+            items: { type: 'string', pattern: '^[A-Za-z][A-Za-z0-9_]{0,99}$' },
+        },
+        responseFields: {
+            type: 'array',
+            items: { type: 'string', pattern: '^[A-Za-z][A-Za-z0-9_]{0,99}$' },
+        },
+    },
+    required: ['id', 'origin', 'path', 'method'],
+};
 export function createVersionFromCaptureTool(client, attachRef) {
     return defineTool({
         name: 'create_provider_version_from_capture',
-        description: 'Persist drafted ReclaimProvider(s) as a provider version, after ' +
-            'run_proof succeeds. Pass the `provider` object(s) from ' +
-            'propose_provider VERBATIM — this tool builds the version body ' +
-            '(requests[], webSettings, …) for you; do NOT hand-construct that ' +
-            'shape or call create_provider_version directly. Exactly one of ' +
-            '`provider` (one request) or `providers` (a multi-request provider — ' +
-            'every entry is required at verification time). This tool always ' +
-            'creates a new immutable version; never edit an existing version. ' +
-            'Omit `version` and `bump` for a patch bump, pass `bump` for a ' +
-            'major/minor/patch bump, or pass the exact higher `version` the user ' +
-            'directed. The version lands on the ' +
-            'draft branch: call `publish_provider_version` (PRIVATE) or ' +
-            '`submit_provider_version_for_review` (PUBLIC) to go live. ' +
-            '`requiredContext` is derived from any {{context.<name>}} ' +
-            'placeholders and returned on the created version — relay it to the ' +
-            'dev verbatim, since a session missing those fields is a 400. Always ' +
-            'read the response\'s `_notes`. ' +
-            'Full walkthrough: how_it_works({ topic: "publish" }).',
+        description: 'Creates a new immutable provider version after `run_proof` succeeds. '
+            + 'Pass exactly one `provider` or `providers` value returned by '
+            + '`propose_provider`; do not rebuild the recipe. The default is a '
+            + 'patch bump, or use `bump` or an explicitly requested higher '
+            + '`version`. The new version remains a draft until published or '
+            + 'submitted for review. Read `_notes` and '
+            + 'how_it_works({ topic: "publish" }).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -195,6 +248,14 @@ export function createVersionFromCaptureTool(client, attachRef) {
                         ALLOWED_REQUESTS_HINT,
                     items: ALLOWED_JS_REQUEST_SCHEMA,
                 },
+                browserRequestActions: {
+                    type: 'array',
+                    description: 'Portal-only actions available to jsUserScripts through ' +
+                        'window.Reclaim.browserRequest. Use these for bounded ' +
+                        'same-origin requests that need the browser cookie jar. ' +
+                        'Other Verification Clients currently ignore them.',
+                    items: BROWSER_REQUEST_ACTION_SCHEMA,
+                },
                 interceptorOptions: {
                     type: 'object',
                     description: 'In-app interception settings, stored as ' +
@@ -247,6 +308,7 @@ export function createVersionFromCaptureTool(client, attachRef) {
             requiredContext: args.requiredContext,
             jsUserScripts: args.jsUserScripts,
             allowedJsRequests: args.allowedJsRequests,
+            browserRequestActions: args.browserRequestActions,
             interceptorOptions: args.interceptorOptions,
         });
         const result = await client.call('CreateProviderVersion', {

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

@@ -2,22 +2,19 @@ import type { 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 LiveShareRef } from './live-view.ts';
 export declare function sessionTools(attachRef: {
     current?: AttachState;
     config: ConfigStore;
-}, captures: CaptureStore, liveShare: LiveShareRef): RegisteredTool[];
+}, captures: CaptureStore): RegisteredTool[];
 /**
- * Release everything a session holds: the public tunnel, the captures, and the
- * browser itself.
+ * Release everything a session holds: the captures and the browser itself.
  *
  * Exported because a session can end WITHOUT anyone calling `dispose_browser` —
  * the developer closes their agent, the client kills the server, the transport
  * drops. Nothing runs on its own then, so `start.ts` runs this. Without it a
- * container keeps running and, worse, a public URL to a live browser outlives
- * the session that created it.
+ * container keeps running.
  */
 export declare function resetAll(attachRef: {
     current?: AttachState;
     config: ConfigStore;
-}, captures: CaptureStore, liveShare: LiveShareRef): Promise<void>;
+}, captures: CaptureStore): Promise<void>;

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

@@ -1,8 +1,7 @@
 import { defineTool } from "../../server.js";
 import { disposeAttached } from "./attach.js";
 import { resetCaptures } from "./capture.js";
-import { stopLiveShare } from "./live-view.js";
-export function sessionTools(attachRef, captures, liveShare) {
+export function sessionTools(attachRef, captures) {
     return [
         defineTool({
             name: 'get_session',
@@ -20,51 +19,37 @@ export function sessionTools(attachRef, captures, liveShare) {
             orgId: attachRef.current?.orgId,
             captures: [...captures.sessions.keys()],
             activeTab: captures.activeTab,
-            // The public share, when one is open — so a caller that lost the
-            // URL can recover it instead of opening a second tunnel.
-            ...(liveShare.current
-                ? {
-                    sharedView: { url: liveShare.current.url },
-                }
-                : {}),
         })),
         defineTool({
             name: 'dispose_browser',
             description: 'Stop captures, disconnect the current browser, and immediately '
                 + 'delete a Builder-hosted Popcorn session. Custom CDP sessions '
-                + 'are disconnected but never deleted by Reclaim. Also closes a '
-                + 'public live view opened by share_browser_view.',
+                + 'are disconnected but never deleted by Reclaim.',
             inputSchema: { type: 'object', properties: {} },
         }, async () => {
-            await resetAll(attachRef, captures, liveShare);
+            await resetAll(attachRef, captures);
             return { disposed: true };
         }),
         defineTool({
             name: 'reset_session',
             description: 'Stop all captures and clear capture state — drops every '
-                + 'session\'s drafts and their in-memory secrets, and closes a '
-                + 'public live view opened by share_browser_view.',
+                + 'session\'s drafts and their in-memory secrets.',
             inputSchema: { type: 'object', properties: {} },
         }, async () => {
-            await resetAll(attachRef, captures, liveShare);
+            await resetAll(attachRef, captures);
             return { reset: true };
         }),
     ];
 }
 /**
- * Release everything a session holds: the public tunnel, the captures, and the
- * browser itself.
+ * Release everything a session holds: the captures and the browser itself.
  *
  * Exported because a session can end WITHOUT anyone calling `dispose_browser` —
  * the developer closes their agent, the client kills the server, the transport
  * drops. Nothing runs on its own then, so `start.ts` runs this. Without it a
- * container keeps running and, worse, a public URL to a live browser outlives
- * the session that created it.
+ * container keeps running.
  */
-export async function resetAll(attachRef, captures, liveShare) {
-    // Before the captures: a public URL must never outlive the browser it points
-    // at.
-    await stopLiveShare(liveShare);
+export async function resetAll(attachRef, captures) {
     await resetCaptures(captures);
     await disposeAttached(attachRef);
 }

package/lib/mcp/tools/verification/result.d.ts

@@ -6,6 +6,7 @@ import { type RegisteredTool } from '../../server.ts';
  * plaintext signed JWS (when the org's encryption is off) or an ECIES
  * ciphertext that we decrypt here with the optional eth key
  * (`RECLAIM_DECRYPT_KEY` or the `reclaim-decrypt.key` hex file). The Builder
- * only ever relays the payload — decryption, when needed, happens here.
+ * creates, signs, optionally encrypts, and stores the delivery payload.
+ * Decryption, when needed, happens here.
  */
 export declare function verificationResultTool(): RegisteredTool;

package/lib/mcp/tools/verification/result.js

@@ -1,11 +1,16 @@
-import { createReclaim, decryptCallback, } from '@reclaimprotocol/client';
+import { decryptCallback, ReclaimVerification, } from '@reclaimprotocol/client';
 import assert from 'node:assert';
 import { apiUrl, orgSecret } from "../../../consts.js";
 import { defineTool } from "../../server.js";
 import { resolveDecryptionKey } from "../authenticate/decrypt-key.js";
-/** Statuses that can carry a submitted (terminal) result. `expired`/`pending`
- *  never have one. */
-const TERMINAL = new Set(['success', 'rejected', 'error']);
+/** Statuses that can carry a Builder-managed terminal result. */
+const TERMINAL = new Set([
+    'success',
+    'rejected',
+    'error',
+    'cancelled',
+    'expired',
+]);
 /**
  * Resolve the org secret used to authenticate verification reads. Auth is a
  * single per-org bearer secret (`rorg_…`), not an eth signature — read it from
@@ -25,25 +30,23 @@ function resolveOrgSecret() {
  * plaintext signed JWS (when the org's encryption is off) or an ECIES
  * ciphertext that we decrypt here with the optional eth key
  * (`RECLAIM_DECRYPT_KEY` or the `reclaim-decrypt.key` hex file). The Builder
- * only ever relays the payload — decryption, when needed, happens here.
+ * creates, signs, optionally encrypts, and stores the delivery payload.
+ * Decryption, when needed, happens here.
  */
 export function verificationResultTool() {
     return defineTool({
         name: 'get_verification_result',
-        description: 'Reads a verification session and locally checks each submitted ' +
-            'result. Requires RECLAIM_ORG_SECRET. Encrypted ECIES deliveries ' +
-            'also require the matching optional eth key ' +
-            '(RECLAIM_DECRYPT_KEY or reclaim-decrypt.key); plaintext deliveries ' +
-            'are read directly. Returns `ready: false` until the session is ' +
-            'terminal and at least one payload is readable. When `ready: true`, ' +
-            'act only on result entries where `valid` is true; `ready` means a ' +
-            'payload was read, not that verification succeeded. Use ' +
-            'list_verification_events to diagnose an unfinished session.',
+        description: 'Fetches and verifies a terminal Builder result for one session. '
+            + 'Requires `RECLAIM_ORG_SECRET`; encrypted deliveries also require '
+            + 'the matching ETH decryption key. Returns `ready: false` until a '
+            + 'payload is available. Invalid results fail verification and are not '
+            + 'returned. Use `list_verification_events` to diagnose '
+            + 'an unfinished session.',
         inputSchema: {
             type: 'object',
-            required: ['sessionId'],
+            required: ['reclaimSessionId'],
             properties: {
-                sessionId: {
+                reclaimSessionId: {
                     type: 'string',
                     description: 'The verification session id from create_verification_session.',
                 },
@@ -53,31 +56,31 @@ export function verificationResultTool() {
         const secret = resolveOrgSecret();
         // Optional eth decryption key — absent ⇒ plaintext-only.
         const decryptionKey = await resolveDecryptionKey();
-        const reclaim = createReclaim({
+        const reclaim = ReclaimVerification.create({
             baseUrl: apiUrl(),
             orgSecret: secret,
         });
         const sessionRes = await reclaim.api('GetVerificationSession', {
-            params: { sessionId: args.sessionId },
+            params: { sessionId: args.reclaimSessionId },
         });
         const status = sessionRes.data.status;
         if (!TERMINAL.has(status)) {
-            return { sessionId: args.sessionId, status, ready: false };
+            return { reclaimSessionId: args.reclaimSessionId, status, ready: false };
         }
         const resultRes = await reclaim.api('GetVerificationResult', {
-            params: { sessionId: args.sessionId },
+            params: { sessionId: args.reclaimSessionId },
         });
         const { items } = resultRes.data;
         if (!items.length) {
             return {
-                sessionId: args.sessionId,
+                reclaimSessionId: args.reclaimSessionId,
                 status,
                 ready: false,
                 note: 'Session is terminal but no result has been submitted yet.',
             };
         }
-        // Each item's `payload` is an ECIES ciphertext (encrypted to the org's
-        // credential) or the plaintext signed JWS, as raw text. `decryptCallback`
+        // Each item's `payload` is an ECIES ciphertext encrypted to the org's
+        // public key, or the plaintext signed JWS. `decryptCallback`
         // branches on the body shape; an encrypted delivery with no key throws
         // a clear error, which we surface per-subscription rather than skip.
         const results = [];
@@ -93,19 +96,17 @@ export function verificationResultTool() {
                 continue;
             }
             const outcome = await reclaim.results.verify(jws, {
-                expectedReclaimSessionId: args.sessionId,
+                reclaimSessionId: args.reclaimSessionId,
             });
             results.push({
                 subscriptionId: item.subscriptionId,
-                valid: outcome.valid,
-                reason: outcome.reason,
                 payload: outcome.payload,
                 proofs: outcome.proofs,
             });
         }
         if (!results.length) {
             return {
-                sessionId: args.sessionId,
+                reclaimSessionId: args.reclaimSessionId,
                 status,
                 ready: false,
                 note: 'A result was stored, but no payload could be read — it is ' +
@@ -115,7 +116,7 @@ export function verificationResultTool() {
             };
         }
         return {
-            sessionId: args.sessionId,
+            reclaimSessionId: args.reclaimSessionId,
             status,
             ready: true,
             results,

package/lib/old/client.d.ts

@@ -48,9 +48,9 @@ export interface RegisterProviderBody {
      *  controller's destructure + its `providerConfig` write, both of which
      *  include it alongside `pageTitle`/`userAgent`. */
     stepsToFollow?: string;
-    /** Interception mechanism (`NONE` = standard replay flow, the default;
+    /** Interception mechanism (`NONE` disables interception;
      *  `HAWKEYE`/`MSWJS`/`XHOOK` = JS-context interception; `CDP` = browser-
-     *  level). Column default is `HAWKEYE` when omitted entirely — unlike
+     *  level). The column defaults to `HAWKEYE` when omitted — unlike
      *  `stepsToFollow`, and so on. above, whether the register endpoint actually
      *  PERSISTS this field is UNVERIFIED (no source access to confirm); sent
      *  here on the chance it does, but the publish tool always follows up

package/lib/old/flag.d.ts

@@ -2,11 +2,8 @@
  * `USE_OLD_DEVTOOLS` — single source of truth for which backend the MCP
  * server targets.
  *
- * Defaults to OLD devtools (the system still in production) while the new
- * "builder" backend is under development. Builder mode must be opted into
- * EXPLICITLY by setting `USE_OLD_DEVTOOLS=false`. Anything else — unset,
- * empty, `true`, `1`, a typo — keeps old mode on, so a forgotten env var
- * can never silently route a developer at the half-built builder backend.
+ * Builder is the default. Only `true` or `1` explicitly selects old devtools;
+ * an unset value or typo stays on Builder.
  *
  * The actual env read lives in `../consts.ts` (the single env-access module);
  * this widely-imported path re-exports it for back-compat.