@reclaimprotocol/agent 0.1.28 → 0.1.31

package/src/mcp/tools/agent/live-view.ts

@@ -1,79 +1,52 @@
 /**
- * `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, type Tunnel } from '../../../live/tunnel.ts'
-import { LOGGER } from '../../../logger.ts'
 import { defineTool, type RegisteredTool } from '../../server.ts'
 import { type AttachState, SHAREABLE_MODES } from './attach.ts'
 import { ensureLiveViewUrl } from './live-view-url.ts'
 
-export interface LiveShare {
-	tunnel: Tunnel
-	/** The public URL handed to whoever is watching. */
-	url: string
-}
-
-export interface LiveShareRef {
-	current?: LiveShare
-}
-
-type TunnelStarter = typeof startTunnel
-
-/** 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: LiveShareRef): Promise<boolean> {
-	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
-}
+/** Quick-tunnel hostnames only: `https://<words>.trycloudflare.com`. */
+const QUICK_TUNNEL_HOST = /\.trycloudflare\.com$/i
 
 export function liveViewTools(
 	attachRef: { current?: AttachState },
-	shareRef: LiveShareRef,
-	openTunnel: TunnelStarter = startTunnel,
 ): RegisteredTool[] {
 	return [
-		defineTool<Record<string, never>>(
+		defineTool<{ publicUrl?: string }>(
 			{
 				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: {} },
+					'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() => {
+			async(parsed) => {
 				const attached = attachRef.current
 				assert(attached, badRequest(
 					'No browser attached. Call attach_browser first.',
@@ -92,79 +65,66 @@ export function liveViewTools(
 							+ '"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: LiveShare = {
-					tunnel, url,
+				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`.',
+						],
+					}
 				}
-				shareRef.current = share
-				LOGGER.info({ mode: attached.mode }, 'live view shared')
 
+				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<Record<string, never>>(
-			{
-				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: string): URL {
+	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/src/mcp/tools/agent/propose.ts

@@ -17,29 +17,13 @@ export function proposeTool(resolveBackend: ResolveBackend): RegisteredTool {
 		{
 			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.',
+				'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' },

package/src/mcp/tools/agent/publish.ts

@@ -137,6 +137,75 @@ const ALLOWED_JS_REQUEST_SCHEMA: JSONSchema.Schema = {
 	required: ['url', 'method'],
 }
 
+const BROWSER_REQUEST_ACTION_SCHEMA: JSONSchema.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'],
+}
+
 interface PublishArgs {
 	providerId: string
 	/** Single-provider back-compat input; normalized to `[provider]`. */
@@ -150,6 +219,9 @@ interface PublishArgs {
 	requiredContext?: CreateProviderVersionRequest['requiredContext']
 	jsUserScripts?: string
 	allowedJsRequests?: AllowedJsRequest[]
+	browserRequestActions?: NonNullable<
+		CreateProviderVersionRequest['webSettings']['browserRequestActions']
+	>
 	interceptorOptions?: {
 		interceptorType: 'HAWKEYE' | 'MSWJS' | 'CDP'
 		interceptorSettings?: string
@@ -165,24 +237,13 @@ export function createVersionFromCaptureTool(
 		{
 			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" }).',
+				'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: {
@@ -264,6 +325,15 @@ export function createVersionFromCaptureTool(
 							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:
@@ -328,6 +398,7 @@ export function createVersionFromCaptureTool(
 				requiredContext: args.requiredContext,
 				jsUserScripts: args.jsUserScripts,
 				allowedJsRequests: args.allowedJsRequests,
+				browserRequestActions: args.browserRequestActions,
 				interceptorOptions: args.interceptorOptions,
 			})
 			const result = await client.call('CreateProviderVersion', {

package/src/mcp/tools/agent/session.ts

@@ -2,12 +2,10 @@ import type { ConfigStore } from '../../../config/store.ts'
 import { defineTool, type RegisteredTool } from '../../server.ts'
 import { type AttachState, disposeAttached } from './attach.ts'
 import { type CaptureStore, resetCaptures } from './capture.ts'
-import { type LiveShareRef, stopLiveShare } from './live-view.ts'
 
 export function sessionTools(
 	attachRef: { current?: AttachState, config: ConfigStore },
 	captures: CaptureStore,
-	liveShare: LiveShareRef,
 ): RegisteredTool[] {
 	return [
 		defineTool<Record<string, never>>(
@@ -29,13 +27,6 @@ export function sessionTools(
 				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<Record<string, never>>(
@@ -44,12 +35,11 @@ export function sessionTools(
 				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 }
 			},
 		),
@@ -58,12 +48,11 @@ export function sessionTools(
 				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 }
 			},
 		),
@@ -71,23 +60,17 @@ export function sessionTools(
 }
 
 /**
- * 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: { current?: AttachState, config: ConfigStore },
 	captures: CaptureStore,
-	liveShare: LiveShareRef,
 ) {
-	// Before the captures: a public URL must never outlive the browser it points
-	// at.
-	await stopLiveShare(liveShare)
 	await resetCaptures(captures)
 	await disposeAttached(attachRef)
 }

package/src/mcp/tools/verification/result.ts

@@ -1,16 +1,21 @@
 import {
-	createReclaim,
 	decryptCallback,
 	type DecryptionKey,
+	ReclaimVerification,
 } from '@reclaimprotocol/client'
 import assert from 'node:assert'
 import { apiUrl, orgSecret } from '../../../consts.ts'
 import { defineTool, type RegisteredTool } from '../../server.ts'
 import { resolveDecryptionKey } from '../authenticate/decrypt-key.ts'
 
-/** 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
@@ -37,27 +42,25 @@ function resolveOrgSecret(): string {
  * 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(): RegisteredTool {
-	return defineTool<{ sessionId: string }>(
+	return defineTool<{ reclaimSessionId: string }>(
 		{
 			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.',
+				'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.',
@@ -71,36 +74,36 @@ export function verificationResultTool(): RegisteredTool {
 			const decryptionKey: DecryptionKey | undefined =
 				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: unknown[] = []
@@ -116,12 +119,10 @@ export function verificationResultTool(): RegisteredTool {
 				}
 
 				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,
 				})
@@ -129,7 +130,7 @@ export function verificationResultTool(): RegisteredTool {
 
 			if(!results.length) {
 				return {
-					sessionId: args.sessionId,
+					reclaimSessionId: args.reclaimSessionId,
 					status,
 					ready: false,
 					note:
@@ -141,7 +142,7 @@ export function verificationResultTool(): RegisteredTool {
 			}
 
 			return {
-				sessionId: args.sessionId,
+				reclaimSessionId: args.reclaimSessionId,
 				status,
 				ready: true,
 				results,

package/src/old/client.ts

@@ -47,9 +47,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