@reclaimprotocol/agent 0.1.1-dev.1 → 0.1.2

package/src/mcp/tools/authenticate/import.ts

@@ -0,0 +1,73 @@
+import { readFileSync } from 'node:fs'
+import { findProjectRoot } from '../../../paths.ts'
+import { defineTool, type RegisteredTool } from '../../server.ts'
+import { writeEthKey } from './eth-key.ts'
+
+export function importTool(): RegisteredTool {
+	return defineTool<{
+		privateKey?: string
+		keyFile?: string
+		projectDir?: string
+	}>(
+		{
+			name: 'import_credentials',
+			description:
+				'Import an eth proof-owner key the dev already holds and persist it ' +
+				'to the project `.env` as RECLAIM_PRIVATE_KEY=0x… (mode 0600; `.env` ' +
+				'added to .gitignore). Provide EITHER `privateKey` (raw 0x-hex, 64 ' +
+				'chars) OR `keyFile` (path to a file holding the raw 0x-hex key). ' +
+				'The address is derived locally; the private key is never ' +
+				'returned. This is a local signing key only (not registered ' +
+				'with any server, ' +
+				'unrelated to org auth or encryption).',
+			inputSchema: {
+				type: 'object',
+				properties: {
+					privateKey: {
+						type: 'string',
+						pattern: '^0x?[0-9a-fA-F]{64}$',
+						description:
+							'Raw Ethereum private key, 0x-prefixed hex (64 hex chars).',
+					},
+					keyFile: {
+						type: 'string',
+						description:
+							'Path to a file containing the raw 0x-hex private key ' +
+							'(absolute or project-relative).',
+					},
+					projectDir: {
+						type: 'string',
+						description:
+							'Project directory whose `.env` the key is written to. ' +
+							'Defaults to the closest ancestor of cwd containing .git or ' +
+							'package.json.',
+					},
+				},
+			},
+		},
+		async(args) => {
+			if(!args.privateKey && !args.keyFile) {
+				throw new Error('Provide either `privateKey` (0x-hex) or `keyFile`.')
+			}
+
+			if(args.privateKey && args.keyFile) {
+				throw new Error('Provide only one of `privateKey` or `keyFile`.')
+			}
+
+			const projectDir = findProjectRoot(args.projectDir || process.cwd())
+			const privateKeyHex = args.keyFile
+				? readFileSync(args.keyFile, 'utf8')
+				: args.privateKey!
+			const { path, address } = writeEthKey(privateKeyHex, projectDir)
+
+			return {
+				address,
+				path,
+				note:
+					'Eth proof-owner key written to .env as RECLAIM_PRIVATE_KEY ' +
+					'(mode 0600). resolve_owner_key resolves it from .env. Keep .env ' +
+					'secret — it has been added to .gitignore.',
+			}
+		},
+	)
+}

package/src/mcp/tools/authenticate/index.ts

@@ -0,0 +1,4 @@
+// Barrel for the credential tool group: local eth proof-owner key (env/PEM)
+// and the org-token-authenticated builder tools. Import from here.
+export { buildCredentialTools, buildLocalCredentialTools } from './build.ts'
+export { readSession } from './session-cache.ts'

package/src/mcp/tools/authenticate/issue.ts

@@ -0,0 +1,50 @@
+import { generateKeypair } from '@reclaimprotocol/client'
+import { findProjectRoot } from '../../../paths.ts'
+import { defineTool, type RegisteredTool } from '../../server.ts'
+import { writeEthKey } from './eth-key.ts'
+
+export function issueTool(): RegisteredTool {
+	return defineTool<{ projectDir?: string }>(
+		{
+			name: 'issue_credentials',
+			description:
+				'Generate a fresh secp256k1 eth proof-owner key-pair (the key ' +
+				'that signs local claim creation) and write the raw private key to ' +
+				'the project `.env` as RECLAIM_PRIVATE_KEY=0x… (mode 0600; `.env` ' +
+				'added to .gitignore). This is a LOCAL signing key only — it is NOT ' +
+				'registered with any server and is unrelated to org auth (the org ' +
+				'secret) or encryption (the eth decrypt key). ALWAYS confirm with ' +
+				'the dev before generating a new key. After writing, run_proof picks ' +
+				'it up automatically via resolve_owner_key. The private key is never ' +
+				'returned in the response.',
+			inputSchema: {
+				type: 'object',
+				properties: {
+					projectDir: {
+						type: 'string',
+						description:
+							'Project directory whose `.env` the key is written to. ' +
+							'Defaults to the closest ancestor of cwd containing .git or ' +
+							'package.json.',
+					},
+				},
+			},
+		},
+		async(args) => {
+			const projectDir = findProjectRoot(args.projectDir || process.cwd())
+			const keypair = generateKeypair()
+			const { path, address } = writeEthKey(keypair.privateKey, projectDir)
+
+			return {
+				address,
+				path,
+				note:
+					'Eth proof-owner key written to .env as RECLAIM_PRIVATE_KEY ' +
+					'(mode 0600); the private key is NOT in this response on purpose. ' +
+					'resolve_owner_key will now resolve it from .env (or set ' +
+					'RECLAIM_PRIVATE_KEY in the environment to override). Keep .env ' +
+					'secret — it has been added to .gitignore.',
+			}
+		},
+	)
+}

package/src/mcp/tools/authenticate/resolve-owner-key.ts

@@ -0,0 +1,60 @@
+import { join } from 'node:path'
+import { findProjectRoot } from '../../../paths.ts'
+import { defineTool, type RegisteredTool } from '../../server.ts'
+import { ENV_FILE, resolveEthKey } from './eth-key.ts'
+
+/**
+ * Decide which eth proof-owner key `run_proof` should sign with, BEFORE
+ * calling it. The key is a raw 0x-hex Ethereum private key, resolved (no
+ * `~/.reclaim` cache) from:
+ *   1. `RECLAIM_PRIVATE_KEY` in the MCP env
+ *   2. a `RECLAIM_PRIVATE_KEY=0x…` line in the project `.env`
+ *   3. a file at `RECLAIM_PRIVATE_KEY_FILE` holding the raw hex
+ *   4. none → ask the dev to generate (issue_credentials) or provide one
+ *      (import_credentials), then call again.
+ * Never returns the private key — only the derived address.
+ */
+export function resolveOwnerKeyTool(): RegisteredTool {
+	return defineTool<Record<string, never>>(
+		{
+			name: 'resolve_owner_key',
+			description:
+				'Resolve which eth proof-owner key run_proof should sign with — ' +
+				'call this BEFORE run_proof. Checks, in order: RECLAIM_PRIVATE_KEY ' +
+				'in the MCP env, a RECLAIM_PRIVATE_KEY=0x… line in the project .env, ' +
+				'then a file at RECLAIM_PRIVATE_KEY_FILE holding the raw hex. ' +
+				'Returns { ready: true, address, source } when one is ' +
+				'available — pass `address` to run_proof as `ownerAddress`. ' +
+				'Returns { ready: false } ' +
+				'when none exists: then ask the dev to generate one ' +
+				'(issue_credentials) or import one they already hold ' +
+				'(import_credentials, accepts 0x-hex or a key-file path), and call ' +
+				'resolve_owner_key again. Never exposes the private key.',
+			inputSchema: { type: 'object', properties: {} },
+		},
+		async() => {
+			const projectDir = findProjectRoot(process.cwd())
+			const resolved = resolveEthKey(projectDir)
+			if(resolved) {
+				return {
+					ready: true,
+					address: resolved.address,
+					source: resolved.source,
+					...(resolved.path ? { path: resolved.path } : {}),
+				}
+			}
+
+			return {
+				ready: false,
+				message:
+					'No eth proof-owner key available — no RECLAIM_PRIVATE_KEY in the ' +
+					`env, no RECLAIM_PRIVATE_KEY in ${join(projectDir, ENV_FILE)}, and ` +
+					'no RECLAIM_PRIVATE_KEY_FILE. Ask the dev to generate one via ' +
+					'issue_credentials, or import one they already hold via ' +
+					'import_credentials (0x-hex or a key-file path). Then call ' +
+					'resolve_owner_key again and pass its address to run_proof as ' +
+					'ownerAddress.',
+			}
+		},
+	)
+}

package/src/mcp/tools/index.ts

@@ -0,0 +1,6 @@
+// Top-level barrel for every MCP tool group. The MCP server (start.ts) and the
+// package entry (src/index.ts) import tool builders from here, never from the
+// individual tool files.
+export * from './agent/index.ts'
+export * from './authenticate/index.ts'
+export * from './verification/index.ts'

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

@@ -0,0 +1,16 @@
+import type { RegisteredTool } from '../../server.ts'
+import { verificationResultTool } from './result.ts'
+
+/**
+ * Builder-mode verification tools: higher-level orchestrations over the
+ * generated API surface. `get_verification_result` authenticates with the org
+ * token, checks status, pulls the stored payload, and decrypts it locally with
+ * the optional eth key — a flow the generated raw-API tools can't express
+ * (the decryption key never leaves the consumer). Diagnosis is left to the
+ * agent over the generated tools (`get_verification_session`,
+ * `list_verification_events`, `list_verification_deliveries`), whose
+ * descriptions carry the lifecycle and delivery semantics.
+ */
+export function buildVerificationTools(): RegisteredTool[] {
+	return [verificationResultTool()]
+}

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

@@ -0,0 +1,2 @@
+// Barrel for the verification tool group (result retrieval + decryption).
+export { buildVerificationTools } from './build.ts'

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

@@ -0,0 +1,154 @@
+import {
+	createReclaim,
+	decryptCallback,
+	type DecryptionKey,
+	verifyResultFull,
+} 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'])
+
+/**
+ * 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
+ * `RECLAIM_ORG_SECRET`.
+ */
+function resolveOrgSecret(): string {
+	const secret = orgSecret()?.trim()
+	assert(
+		secret,
+		new Error(
+			'RECLAIM_ORG_SECRET is not set. Verification reads authenticate with ' +
+				'the org secret (rorg_…) — issue one from the dashboard ' +
+				'(POST /orgs/{orgId}/token) and export it as RECLAIM_ORG_SECRET.',
+		),
+	)
+	return secret
+}
+
+/**
+ * `get_verification_result` — check a session's status and, once a result has
+ * been submitted, pull the stored payload(s) and verify locally. Auth is the
+ * org token; delivery is org-scoped. Each stored payload is either the
+ * 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.
+ */
+export function verificationResultTool(): RegisteredTool {
+	return defineTool<{ sessionId: string }>(
+		{
+			name: 'get_verification_result',
+			description:
+				'Check a verification session and return its result when ready. ' +
+				'Authenticates with the org secret (RECLAIM_ORG_SECRET). Fetches the ' +
+				'session status; if it is terminal and a result has been submitted, ' +
+				'pulls the stored result(s) and verifies them locally. Encrypted ' +
+				'deliveries (ECIES over secp256k1) are decrypted with your optional ' +
+				'eth key (RECLAIM_DECRYPT_KEY or reclaim-decrypt.key); plaintext ' +
+				'deliveries are read directly. Returns ' +
+				'`ready: false` while the session is still pending or no result has ' +
+				'been delivered yet. Use list_verification_events for the full ' +
+				'lifecycle log.',
+			inputSchema: {
+				type: 'object',
+				required: ['sessionId'],
+				properties: {
+					sessionId: {
+						type: 'string',
+						description:
+							'The verification session id from create_verification_session.',
+					},
+				},
+			},
+		},
+		async(args) => {
+			const secret = resolveOrgSecret()
+			// Optional eth decryption key — absent ⇒ plaintext-only.
+			const decryptionKey: DecryptionKey | undefined =
+				await resolveDecryptionKey()
+
+			const reclaim = createReclaim({
+				baseUrl: apiUrl(),
+				orgSecret: secret,
+			})
+
+			const sessionRes = await reclaim.api('GetVerificationSession', {
+				params: { sessionId: args.sessionId },
+			})
+			const status = sessionRes.data.status
+
+			if(!TERMINAL.has(status)) {
+				return { sessionId: args.sessionId, status, ready: false }
+			}
+
+			const resultRes = await reclaim.api('GetVerificationResult', {
+				params: { sessionId: args.sessionId },
+			})
+			const { items } = resultRes.data
+
+			if(!items.length) {
+				return {
+					sessionId: args.sessionId,
+					status,
+					ready: false,
+					note: 'Session is terminal but no result has been submitted yet.',
+				}
+			}
+
+			// Each item's `payload` is a compact JWE (encrypted to the org's
+			// credential) or the plaintext signed JWS, as raw text. `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[] = []
+			const undecryptable: string[] = []
+			for(const item of items) {
+				let jws
+				try {
+					jws = await decryptCallback(decryptionKey, item.payload)
+				} catch(err) {
+					undecryptable.push(item.subscriptionId)
+					void err
+					continue
+				}
+
+				const outcome = await verifyResultFull(jws, {
+					expectedReclaimSessionId: args.sessionId,
+				})
+				results.push({
+					subscriptionId: item.subscriptionId,
+					valid: outcome.valid,
+					reason: outcome.reason,
+					payload: outcome.payload,
+					proofs: outcome.proofs,
+				})
+			}
+
+			if(!results.length) {
+				return {
+					sessionId: args.sessionId,
+					status,
+					ready: false,
+					note:
+						'A result was stored, but no payload could be read — it is ' +
+						'corrupt, or encrypted (ECIES) to a key this consumer does not ' +
+						'hold. Set RECLAIM_DECRYPT_KEY (or reclaim-decrypt.key) to the ' +
+						'eth private key matching the org keypair.',
+				}
+			}
+
+			return {
+				sessionId: args.sessionId,
+				status,
+				ready: true,
+				results,
+				...(undecryptable.length ? { undecryptable } : {}),
+			}
+		},
+	)
+}

package/src/old/client.ts

@@ -25,6 +25,9 @@ export interface RegisterProviderBody {
 	description?: string
 	loginUrl: string
 	geoLocation?: string
+	/** Provider-level flag on the old backend (defaults false there; the
+	 *  translator sends `true` to match the builder default). */
+	useProxy?: boolean
 	providerType?: 'PRIVATE' | 'PUBLIC'
 	requestData: unknown[]
 }

package/src/old/flag.ts

@@ -7,7 +7,8 @@
  * 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.
+ *
+ * The actual env read lives in `../consts.ts` (the single env-access module);
+ * this widely-imported path re-exports it for back-compat.
  */
-export function useOldDevtools(): boolean {
-	return (process.env.USE_OLD_DEVTOOLS ?? '').trim().toLowerCase() !== 'false'
-}
+export { useOldDevtools } from '../consts.ts'

package/src/old/identity.ts

@@ -1,5 +1,6 @@
 import { deriveFromPrivateKey } from '@reclaimprotocol/client'
 import { ConfigStore } from '../config/store.ts'
+import { oldApiToken, oldEthUid, privateKey } from '../consts.ts'
 import type { OldIdentity } from './client.ts'
 
 /** Normalize an eth uid input to `eth:<lowercase-address>`. Accepts a bare
@@ -17,27 +18,27 @@ export function toEthUid(addressOrUid: string): OldIdentity {
  *   3. `RECLAIM_PRIVATE_KEY`   — derive the eth uid from the local app key.
  * Returns undefined when none is set.
  */
-export function resolveIdentityFromEnv(): OldIdentity | undefined {
-	const token = process.env.RECLAIM_OLD_API_TOKEN?.trim()
+function resolveIdentityFromEnv(): OldIdentity | undefined {
+	const token = oldApiToken()?.trim()
 	if(token) {
 		return { kind: 'bearer', token }
 	}
 
-	const ethUid = process.env.RECLAIM_OLD_ETH_UID?.trim()
+	const ethUid = oldEthUid()?.trim()
 	if(ethUid) {
 		return toEthUid(ethUid)
 	}
 
-	const privateKey = process.env.RECLAIM_PRIVATE_KEY?.trim()
-	if(privateKey) {
-		return toEthUid(deriveFromPrivateKey(privateKey).address)
+	const key = privateKey()?.trim()
+	if(key) {
+		return toEthUid(deriveFromPrivateKey(key).address)
 	}
 
 	return undefined
 }
 
 /** Read the identity persisted by a prior `reclaim_authenticate` call. */
-export function loadPersistedIdentity(): OldIdentity | undefined {
+function loadPersistedIdentity(): OldIdentity | undefined {
 	return new ConfigStore().read()?.old_devtools
 }
 

package/src/old/instructions.ts

@@ -2,29 +2,14 @@
  * MCP server instructions shown to the LLM when running in OLD-devtools mode
  * (`USE_OLD_DEVTOOLS` unset or not `false`). Describes the REDUCED tool
  * surface — there are no org/credential-link/review flows and no generated
- * API tools here. Must not mention disabled tools.
+ * API tools here. The prose lives in `skill/old-mode.md` (published via the
+ * `files` array); the path resolves identically from `src/old` (dev) and
+ * `lib/old` (published).
  */
-export const OLD_MODE_INSTRUCTIONS =
-	'This server is running against the LEGACY Reclaim devtools backend ' +
-	'(temporary, while the new builder backend is in development), so its ' +
-	'capabilities are intentionally limited.\n\n' +
-	'Provider-authoring flow:\n' +
-	'1. `reclaim_authenticate` — by default opens the dashboard in Chrome, ' +
-	'waits for you to sign in, captures the token automatically, and closes ' +
-	'the tab (or paste a `token` / pass an eth `ethAddress` to skip the ' +
-	'browser). Do this once before publishing or listing.\n' +
-	'2. `attach_chrome` → `start_capture` → drive the page (`navigate`, ' +
-	'`wait_for_page`) → inspect (`list_requests`, `get_request`, ' +
-	'`find_requests_containing`).\n' +
-	'3. `propose_provider` to draft a provider, `replay_request` to ' +
-	'pre-flight, `run_proof` to verify with the attestor. OPRF/`hash` ' +
-	'redactions are optional and supported.\n' +
-	'4. `create_provider_version_from_capture` to publish. With NO ' +
-	'`providerId` it REGISTERS A NEW provider (re-running creates a ' +
-	'duplicate); pass a ' +
-	'`providerId` from `get_me_providers` to add a new version to an existing ' +
-	'provider instead.\n' +
-	'5. `get_me_providers` lists the providers you own (the only ' +
-	'provider-listing tool available in this mode).\n\n' +
-	'Only GET/POST endpoints can be captured into providers here. There is no ' +
-	'organization, credential-linking, or public-review workflow in this mode.'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+export const OLD_MODE_INSTRUCTIONS = readFileSync(
+	fileURLToPath(new URL('../../skill/old-mode.md', import.meta.url)),
+	'utf8',
+).trim()

package/src/old/login-cdp.ts

@@ -5,10 +5,7 @@ import {
 	waitForCdpReady,
 } from '../cdp/launcher.ts'
 import { ConfigStore } from '../config/store.ts'
-
-/** The devtools dashboard login page. Override per-call or via
- *  `RECLAIM_OLD_LOGIN_URL`. */
-export const DEFAULT_LOGIN_URL = 'https://dev.reclaimprotocol.org'
+import { DEFAULT_LOGIN_URL, oldLoginUrl } from '../consts.ts'
 
 /**
  * Read the Firebase ID token the dashboard persisted after login.
@@ -84,7 +81,7 @@ export async function captureFirebaseTokenViaCdp(opts: {
 	pollMs?: number
 }): Promise<CdpLoginResult> {
 	const loginUrl =
-		opts.loginUrl || process.env.RECLAIM_OLD_LOGIN_URL || DEFAULT_LOGIN_URL
+		opts.loginUrl || oldLoginUrl() || DEFAULT_LOGIN_URL
 	const timeoutMs = opts.timeoutMs ?? 180_000
 	const pollMs = opts.pollMs ?? 1000
 

package/src/old/to-register.ts

@@ -4,6 +4,13 @@ import type {
 	UpdateProviderConfigBody,
 } from './client.ts'
 
+/** Default web settings, mirroring the builder openapi defaults
+ *  (`ProviderWebSettings.geoLocation`, `PortalClientOptions.useProxy`). The old
+ *  backend accepts both: `geoLocation` lives on the providerConfig, `useProxy`
+ *  is a Provider-level flag (register only). */
+const DEFAULT_GEO_LOCATION = '{{DYNAMIC_GEO}}'
+const DEFAULT_USE_PROXY = true
+
 /**
  * Translate a drafted `ReclaimProvider` (from `propose_provider`) into the
  * OLD devtools backend shapes. Deliberately a SEPARATE module from
@@ -22,7 +29,10 @@ import type {
 export interface OldProviderOpts {
 	initialUrl: string
 	description?: string
+	/** Defaults to `{{DYNAMIC_GEO}}` when omitted. */
 	geoLocation?: string
+	/** Defaults to `true` when omitted. Register only (Provider-level flag). */
+	useProxy?: boolean
 	providerType?: 'PRIVATE' | 'PUBLIC'
 }
 
@@ -63,6 +73,20 @@ function requestDataFromProvider(provider: ReclaimProvider): OldRequestData {
 		)
 	}
 
+	// The old backend has no dotted interpolation: consumer-supplied params
+	// must use the `{{context_<name>}}` form here, not the builder's
+	// `{{context.<name>}}`. Catch the mix-up at publish with a clear error
+	// instead of a template that silently never resolves.
+	const dotted = `${provider.url}\n${provider.body ?? ''}`
+		.match(/\{\{context\.[A-Za-z_][A-Za-z0-9_]*\}\}/)
+	if(dotted) {
+		throw new Error(
+			`Old devtools does not support ${dotted[0]} — rename ` +
+			'consumer-supplied params to the {{context_<name>}} form ' +
+			'for this backend.',
+		)
+	}
+
 	const responseMatches: OldResponseMatch[] = provider.responseMatches.map(
 		(m, i) => ({
 			value: m.value,
@@ -72,29 +96,37 @@ function requestDataFromProvider(provider: ReclaimProvider): OldRequestData {
 		}),
 	)
 
-	const responseRedactions: OldResponseRedaction[] = (
-		provider.responseRedactions ?? []
-	).map((r, i) => {
-		const out: OldResponseRedaction = { order: i }
-		if(r.xPath !== undefined) {
-			out.xPath = r.xPath
-		}
+	// Old devtools wants `responseMatches` and `responseRedactions` as PARALLEL
+	// arrays — same shape the builder uses, so pass them through directly. We do
+	// NOT enforce any match/redaction count relationship here (and never pad —
+	// empty placeholder matches break proof generation): the author keeps full
+	// control. The publish tool surfaces a non-blocking warning when matches <
+	// redactions (see `matchRedactionWarnings`), and the dev decides.
+	const sourceRedactions = provider.responseRedactions ?? []
 
-		if(r.jsonPath !== undefined) {
-			out.jsonPath = r.jsonPath
-		}
+	const responseRedactions: OldResponseRedaction[] = sourceRedactions.map(
+		(r, i) => {
+			const out: OldResponseRedaction = { order: i }
+			if(r.xPath !== undefined) {
+				out.xPath = r.xPath
+			}
 
-		if(r.regex !== undefined) {
-			out.regex = r.regex
-		}
+			if(r.jsonPath !== undefined) {
+				out.jsonPath = r.jsonPath
+			}
 
-		// OPRF redactions are supported — pass the mode through unchanged.
-		if(r.hash !== undefined) {
-			out.hash = r.hash
-		}
+			if(r.regex !== undefined) {
+				out.regex = r.regex
+			}
 
-		return out
-	})
+			// OPRF redactions are supported — pass the mode through unchanged.
+			if(r.hash !== undefined) {
+				out.hash = r.hash
+			}
+
+			return out
+		},
+	)
 
 	const requestData: OldRequestData = {
 		url: provider.url,
@@ -127,16 +159,15 @@ export function providerToRegisterBody(
 		name: provider.name,
 		loginUrl: opts.initialUrl,
 		providerType: opts.providerType ?? 'PRIVATE',
+		// Web-settings defaults mirror the builder openapi defaults.
+		geoLocation: opts.geoLocation ?? DEFAULT_GEO_LOCATION,
+		useProxy: opts.useProxy ?? DEFAULT_USE_PROXY,
 		requestData: [requestDataFromProvider(provider)],
 	}
 	if(opts.description !== undefined) {
 		body.description = opts.description
 	}
 
-	if(opts.geoLocation !== undefined) {
-		body.geoLocation = opts.geoLocation
-	}
-
 	return body
 }
 
@@ -149,13 +180,14 @@ export function providerToConfigBody(
 	version: string,
 	versionInfo: string,
 ): UpdateProviderConfigBody {
+	// `useProxy` is a Provider-level flag on the old backend, not part of a
+	// version's providerConfig — so the config (new-version) path only carries
+	// `geoLocation`. It defaults the same way as register.
 	const providerConfig: Record<string, unknown> = {
 		loginUrl: opts.initialUrl,
+		geoLocation: opts.geoLocation ?? DEFAULT_GEO_LOCATION,
 		requestData: [requestDataFromProvider(provider)],
 	}
-	if(opts.geoLocation !== undefined) {
-		providerConfig.geoLocation = opts.geoLocation
-	}
 
 	return { providerConfig, version, versionInfo }
 }

package/src/old/tools/authenticate.ts

@@ -1,3 +1,4 @@
+import { agentDisabled } from '../../consts.ts'
 import { defineTool, type RegisteredTool } from '../../mcp/server.ts'
 import type { OldIdentity, ReclaimOldClient } from '../client.ts'
 import { persistIdentity, toEthUid } from '../identity.ts'
@@ -128,7 +129,7 @@ export function authenticateTool(client: ReclaimOldClient): RegisteredTool {
 			}
 
 			// CDP browser login (the default headline flow).
-			if(process.env.RECLAIM_AGENT_DISABLED === '1') {
+			if(agentDisabled()) {
 				throw new Error(
 					'Browser login is unavailable (RECLAIM_AGENT_DISABLED=1). Pass a ' +
 					'`token` (Firebase ID token) or `ethAddress` instead.',