@reclaimprotocol/agent 0.1.5 → 0.1.6

package/lib/old/client.d.ts

@@ -32,12 +32,36 @@ export interface RegisterProviderBody {
     useProxy?: boolean;
     providerType?: 'PRIVATE' | 'PUBLIC';
     requestData: unknown[];
+    /** Page-injection script (old-devtools name for the builder's
+     *  `webSettings.jsUserScripts`). Top-level on register; nested under
+     *  `providerConfig` on the config (add-version) body instead. */
+    customInjection?: string;
+    /** Accepted at register too (unlike most `providerConfig` extras, which
+     *  the register controller only reads on config/add-version). */
+    userAgent?: {
+        ios?: string;
+        android?: string;
+    };
+    /** Accepted at register too. */
+    pageTitle?: string;
 }
 export interface UpdateProviderConfigBody {
     providerConfig: Record<string, unknown>;
     version: string;
     versionInfo: string;
 }
+/** Body for `POST /api/providers/:providerId` (`updateProviderMetadata`) —
+ *  a genuine PARTIAL update on the PROVIDER document itself (name/
+ *  description/providerType/tags/isActive), distinct from both `register`
+ *  (creates the provider) and `config` (adds an immutable new version). Only
+ *  the fields present get changed; everything else is left untouched. */
+export interface UpdateProviderMetadataBody {
+    name?: string;
+    description?: string;
+    providerType?: 'PRIVATE' | 'PUBLIC';
+    tags?: string[];
+    isActive?: boolean;
+}
 export interface MyProvidersQuery {
     pageKey?: number;
     pageSize?: number;
@@ -71,6 +95,17 @@ export declare class ReclaimOldClient {
     registerProvider(body: RegisterProviderBody): Promise<unknown>;
     updateProviderConfig(providerId: string, body: UpdateProviderConfigBody): Promise<unknown>;
     listVersions(providerId: string): Promise<unknown>;
+    /** Full `providerConfig` (loginUrl, customInjection, requestData, ...) for
+     *  one version — the latest when `version` is omitted. Readable for ANY
+     *  non-archived provider (not owner-restricted), same as the dashboard's
+     *  edit-form prefill fetch. */
+    getProviderConfig(providerId: string, version?: string): Promise<unknown>;
+    /** Partial update on the PROVIDER document itself — name/description/
+     *  providerType/tags/isActive, after creation. The backend 403s if you
+     *  don't own the provider (and aren't admin); other providerConfig-style
+     *  fields sent here are simply ignored (this endpoint only reads the
+     *  ones above from the body). */
+    updateProviderMetadata(providerId: string, body: UpdateProviderMetadataBody): Promise<unknown>;
     /** Analytics logs for a verification session, from the logs service (a
      *  DIFFERENT host than the devtools API — hence its own fetch, not
      *  `#request`). Attaches the caller identity when one is set; queried

package/lib/old/client.js

@@ -49,6 +49,24 @@ export class ReclaimOldClient {
     listVersions(providerId) {
         return this.#request('GET', `/providers/${encodeURIComponent(providerId)}/versions`, { auth: true });
     }
+    /** Full `providerConfig` (loginUrl, customInjection, requestData, ...) for
+     *  one version — the latest when `version` is omitted. Readable for ANY
+     *  non-archived provider (not owner-restricted), same as the dashboard's
+     *  edit-form prefill fetch. */
+    getProviderConfig(providerId, version) {
+        return this.#request('GET', `/providers/${encodeURIComponent(providerId)}/config`, {
+            auth: true,
+            query: version ? { versionNumber: version } : undefined,
+        });
+    }
+    /** Partial update on the PROVIDER document itself — name/description/
+     *  providerType/tags/isActive, after creation. The backend 403s if you
+     *  don't own the provider (and aren't admin); other providerConfig-style
+     *  fields sent here are simply ignored (this endpoint only reads the
+     *  ones above from the body). */
+    updateProviderMetadata(providerId, body) {
+        return this.#request('POST', `/providers/${encodeURIComponent(providerId)}`, { body, auth: true });
+    }
     /** Analytics logs for a verification session, from the logs service (a
      *  DIFFERENT host than the devtools API — hence its own fetch, not
      *  `#request`). Attaches the caller identity when one is set; queried

package/lib/old/login-cdp.d.ts

@@ -1,3 +1,27 @@
+/**
+ * Read the Firebase ID token the dashboard persisted after login.
+ *
+ * The frontend uses `browserLocalPersistence`, which the Firebase JS SDK
+ * implements on `localStorage` under a `firebase:authUser:<apiKey>:[DEFAULT]`
+ * key whose JSON value carries `stsTokenManager.accessToken`. We scan for any
+ * such key (so we never hard-code the project apiKey) and fall back to the
+ * IndexedDB persistence layout (`firebaseLocalStorageDb` /
+ * `firebaseLocalStorage`) in case a build switches persistence. Returns the
+ * token string, or null when the user has not finished logging in yet.
+ *
+ * The CDP-launched Chrome reuses a PERSISTENT profile dir across runs, so a
+ * stale `firebase:authUser:*` entry from an earlier (now-expired, ~1h TTL)
+ * session is often still sitting in storage the instant the page loads —
+ * before the developer has clicked anything. Returning that immediately
+ * makes the poll "succeed" on tick one, closing the tab before the developer
+ * can sign in, and the captured token then fails backend verification. So
+ * every candidate's JWT `exp` claim is checked here (in-page, where `atob` is
+ * available) and stale ones are skipped — the loop keeps polling until a
+ * genuinely fresh token shows up from an interactive sign-in.
+ *
+ * Evaluated in-page with `awaitPromise` so the async IndexedDB branch resolves.
+ */
+export declare const EXTRACT_TOKEN_JS = "(async () => {\n\tconst isFresh = (token) => {\n\t\ttry {\n\t\t\tconst payload = JSON.parse(\n\t\t\t\tatob(token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/'))\n\t\t\t)\n\t\t\t// No exp claim to check \u2014 don't block a token we can't evaluate.\n\t\t\tif (typeof payload.exp !== 'number') return true\n\t\t\t// 60s buffer so a token that's about to expire isn't treated as fresh.\n\t\t\treturn payload.exp * 1000 > Date.now() + 60000\n\t\t} catch (e) {\n\t\t\treturn true\n\t\t}\n\t}\n\ttry {\n\t\tfor (let i = 0; i < localStorage.length; i++) {\n\t\t\tconst k = localStorage.key(i)\n\t\t\tif (k && k.indexOf('firebase:authUser:') === 0) {\n\t\t\t\tconst v = JSON.parse(localStorage.getItem(k) || 'null')\n\t\t\t\tconst t = v && v.stsTokenManager && v.stsTokenManager.accessToken\n\t\t\t\tif (t && isFresh(t)) return t\n\t\t\t}\n\t\t}\n\t} catch (e) {}\n\ttry {\n\t\treturn await new Promise((resolve) => {\n\t\t\tconst req = indexedDB.open('firebaseLocalStorageDb')\n\t\t\treq.onerror = () => resolve(null)\n\t\t\treq.onsuccess = () => {\n\t\t\t\ttry {\n\t\t\t\t\tconst db = req.result\n\t\t\t\t\tif (!db.objectStoreNames.contains('firebaseLocalStorage')) {\n\t\t\t\t\t\tresolve(null); return\n\t\t\t\t\t}\n\t\t\t\t\tconst store = db\n\t\t\t\t\t\t.transaction('firebaseLocalStorage', 'readonly')\n\t\t\t\t\t\t.objectStore('firebaseLocalStorage')\n\t\t\t\t\tconst all = store.getAll()\n\t\t\t\t\tall.onerror = () => resolve(null)\n\t\t\t\t\tall.onsuccess = () => {\n\t\t\t\t\t\tfor (const row of (all.result || [])) {\n\t\t\t\t\t\t\tconst m = row && row.value && row.value.stsTokenManager\n\t\t\t\t\t\t\tif (m && m.accessToken && isFresh(m.accessToken)) {\n\t\t\t\t\t\t\t\tresolve(m.accessToken); return\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresolve(null)\n\t\t\t\t\t}\n\t\t\t\t} catch (e) { resolve(null) }\n\t\t\t}\n\t\t})\n\t} catch (e) { return null }\n})()";
 export interface CdpLoginResult {
     token: string;
     /** True when we launched (and then closed) a dedicated Chrome just for
@@ -17,9 +41,4 @@ export declare function captureFirebaseTokenViaCdp(opts: {
     loginUrl?: string;
     timeoutMs?: number;
     pollMs?: number;
-    /** Called every ~10s while waiting for the human to finish signing in, so
-     *  MCP clients that track progress on this call can reset their own
-     *  request timeout instead of giving up on a login that's still in
-     *  flight (see `ToolContext` in `mcp/server.ts`). */
-    onProgress?: (message: string) => Promise<void>;
 }): Promise<CdpLoginResult>;

package/lib/old/login-cdp.js

@@ -13,16 +13,39 @@ import { DEFAULT_LOGIN_URL, oldLoginUrl } from "../consts.js";
  * `firebaseLocalStorage`) in case a build switches persistence. Returns the
  * token string, or null when the user has not finished logging in yet.
  *
+ * The CDP-launched Chrome reuses a PERSISTENT profile dir across runs, so a
+ * stale `firebase:authUser:*` entry from an earlier (now-expired, ~1h TTL)
+ * session is often still sitting in storage the instant the page loads —
+ * before the developer has clicked anything. Returning that immediately
+ * makes the poll "succeed" on tick one, closing the tab before the developer
+ * can sign in, and the captured token then fails backend verification. So
+ * every candidate's JWT `exp` claim is checked here (in-page, where `atob` is
+ * available) and stale ones are skipped — the loop keeps polling until a
+ * genuinely fresh token shows up from an interactive sign-in.
+ *
  * Evaluated in-page with `awaitPromise` so the async IndexedDB branch resolves.
  */
-const EXTRACT_TOKEN_JS = `(async () => {
+export const EXTRACT_TOKEN_JS = `(async () => {
+	const isFresh = (token) => {
+		try {
+			const payload = JSON.parse(
+				atob(token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/'))
+			)
+			// No exp claim to check — don't block a token we can't evaluate.
+			if (typeof payload.exp !== 'number') return true
+			// 60s buffer so a token that's about to expire isn't treated as fresh.
+			return payload.exp * 1000 > Date.now() + 60000
+		} catch (e) {
+			return true
+		}
+	}
 	try {
 		for (let i = 0; i < localStorage.length; i++) {
 			const k = localStorage.key(i)
 			if (k && k.indexOf('firebase:authUser:') === 0) {
 				const v = JSON.parse(localStorage.getItem(k) || 'null')
 				const t = v && v.stsTokenManager && v.stsTokenManager.accessToken
-				if (t) return t
+				if (t && isFresh(t)) return t
 			}
 		}
 	} catch (e) {}
@@ -44,7 +67,9 @@ const EXTRACT_TOKEN_JS = `(async () => {
 					all.onsuccess = () => {
 						for (const row of (all.result || [])) {
 							const m = row && row.value && row.value.stsTokenManager
-							if (m && m.accessToken) { resolve(m.accessToken); return }
+							if (m && m.accessToken && isFresh(m.accessToken)) {
+								resolve(m.accessToken); return
+							}
 						}
 						resolve(null)
 					}
@@ -65,8 +90,6 @@ export async function captureFirebaseTokenViaCdp(opts) {
     const loginUrl = opts.loginUrl || oldLoginUrl() || DEFAULT_LOGIN_URL;
     const timeoutMs = opts.timeoutMs ?? 180_000;
     const pollMs = opts.pollMs ?? 1000;
-    const onProgress = opts.onProgress ?? (async () => { });
-    const progressIntervalMs = 10_000;
     const cfg = new ConfigStore().read()?.browser_agent;
     const mode = cfg?.attachMode ?? 'dedicated';
     const port = cfg?.port ?? 9222;
@@ -91,9 +114,7 @@ export async function captureFirebaseTokenViaCdp(opts) {
     try {
         const session = await handles.attachToTab(targetId);
         const { Runtime } = session;
-        const startedAt = Date.now();
-        const deadline = startedAt + timeoutMs;
-        let lastProgressAt = startedAt;
+        const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             const r = await Runtime.evaluate({
                 expression: EXTRACT_TOKEN_JS,
@@ -104,13 +125,6 @@ export async function captureFirebaseTokenViaCdp(opts) {
             if (typeof value === 'string' && value.length > 0) {
                 return { token: value, closedBrowser: launchedByUs };
             }
-            const now = Date.now();
-            if (now - lastProgressAt >= progressIntervalMs) {
-                lastProgressAt = now;
-                const remainingSec = Math.round((deadline - now) / 1000);
-                await onProgress(`Still waiting for sign-in at ${loginUrl} ` +
-                    `(${remainingSec}s left before this call times out).`);
-            }
             await new Promise((resolve) => setTimeout(resolve, pollMs));
         }
         throw new Error('Timed out waiting for login. Finish signing in at the opened ' +

package/lib/old/sdk-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Default origin of the PUBLIC production read API that the Reclaim
+ * verification SDK/attestor itself calls at runtime to fetch a provider's
+ * recipe — a DIFFERENT service from the old-devtools dashboard backend
+ * (`ReclaimOldClient`, `devapi.reclaimprotocol.org`). Both endpoints below are
+ * unauthenticated reads (no `authenticateToken` middleware on this backend's
+ * routes), so this client needs no identity. Override with
+ * `RECLAIM_SDK_API_URL`.
+ */
+export declare const DEFAULT_SDK_API_URL = "https://api.reclaimprotocol.org";
+/**
+ * Minimal read-only client for the public provider-info endpoints on the SDK
+ * backend (`reclaim-sdk-backend`). Two distinct reads, on purpose:
+ *
+ *   - `getProvider` (`GET /providers/:id`) — the full provider row merged
+ *     with its version's WHOLE providerConfig, `customInjection` included.
+ *   - `getProviderConfigs` (`GET /providers/:id/configs`) — the trimmed
+ *     recipe the attestor actually consumes at verification time: a fixed
+ *     field projection that explicitly OMITS `customInjection` and adds a
+ *     computed `isScriptRequestingClaim` flag instead.
+ *
+ * Errors are thrown as `@hapi/boom` so `remapErrorAsResponse` renders them
+ * the same way as every other tool in this package.
+ */
+export declare class ReclaimSdkClient {
+    #private;
+    readonly baseUrl: string;
+    constructor(opts?: {
+        baseUrl?: string;
+        fetch?: typeof fetch;
+    });
+    /** Full provider + providerConfig (includes `customInjection`). Latest
+     *  version when `versionNumber` is omitted. */
+    getProvider(providerId: string, versionNumber?: string): Promise<unknown>;
+    /** Trimmed runtime recipe (no `customInjection`; adds
+     *  `isScriptRequestingClaim`). Latest version when `versionNumber` is
+     *  omitted. */
+    getProviderConfigs(providerId: string, versionNumber?: string): Promise<unknown>;
+}

package/lib/old/sdk-client.js

@@ -0,0 +1,85 @@
+import { Boom } from '@hapi/boom';
+import { NAME, VERSION } from "../pkg.js";
+/**
+ * Default origin of the PUBLIC production read API that the Reclaim
+ * verification SDK/attestor itself calls at runtime to fetch a provider's
+ * recipe — a DIFFERENT service from the old-devtools dashboard backend
+ * (`ReclaimOldClient`, `devapi.reclaimprotocol.org`). Both endpoints below are
+ * unauthenticated reads (no `authenticateToken` middleware on this backend's
+ * routes), so this client needs no identity. Override with
+ * `RECLAIM_SDK_API_URL`.
+ */
+export const DEFAULT_SDK_API_URL = 'https://api.reclaimprotocol.org';
+/**
+ * Minimal read-only client for the public provider-info endpoints on the SDK
+ * backend (`reclaim-sdk-backend`). Two distinct reads, on purpose:
+ *
+ *   - `getProvider` (`GET /providers/:id`) — the full provider row merged
+ *     with its version's WHOLE providerConfig, `customInjection` included.
+ *   - `getProviderConfigs` (`GET /providers/:id/configs`) — the trimmed
+ *     recipe the attestor actually consumes at verification time: a fixed
+ *     field projection that explicitly OMITS `customInjection` and adds a
+ *     computed `isScriptRequestingClaim` flag instead.
+ *
+ * Errors are thrown as `@hapi/boom` so `remapErrorAsResponse` renders them
+ * the same way as every other tool in this package.
+ */
+export class ReclaimSdkClient {
+    baseUrl;
+    #fetch;
+    constructor(opts = {}) {
+        this.baseUrl = (opts.baseUrl || DEFAULT_SDK_API_URL).replace(/\/+$/, '');
+        this.#fetch = opts.fetch ?? fetch;
+    }
+    /** Full provider + providerConfig (includes `customInjection`). Latest
+     *  version when `versionNumber` is omitted. */
+    getProvider(providerId, versionNumber) {
+        return this.#get(`/providers/${encodeURIComponent(providerId)}`, versionNumber);
+    }
+    /** Trimmed runtime recipe (no `customInjection`; adds
+     *  `isScriptRequestingClaim`). Latest version when `versionNumber` is
+     *  omitted. */
+    getProviderConfigs(providerId, versionNumber) {
+        return this.#get(`/providers/${encodeURIComponent(providerId)}/configs`, versionNumber);
+    }
+    async #get(path, versionNumber) {
+        let url = `${this.baseUrl}/api${path}`;
+        if (versionNumber) {
+            url += `?versionNumber=${encodeURIComponent(versionNumber)}`;
+        }
+        const res = await this.#fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                'User-Agent': `${NAME}/${VERSION}`,
+            },
+        });
+        let json;
+        try {
+            json = await res.json();
+        }
+        catch {
+            json = undefined;
+        }
+        const failed = !res.ok ||
+            (json !== undefined &&
+                typeof json === 'object' &&
+                json.isSuccess === false);
+        if (failed) {
+            const message = (json && typeof json === 'object' &&
+                typeof json.message === 'string'
+                ? json.message
+                : undefined) || res.statusText || 'SDK backend request failed';
+            throw new Boom(message, {
+                statusCode: res.ok ? 502 : res.status,
+                data: {
+                    status: res.status,
+                    title: message,
+                    detail: message,
+                    body: json,
+                },
+            });
+        }
+        return json;
+    }
+}

package/lib/old/to-register.d.ts

@@ -1,4 +1,5 @@
 import type { ReclaimProvider } from '../provider/schema.ts';
+import type { AllowedJsRequest } from '../provider/to-version.ts';
 import type { RegisterProviderBody, UpdateProviderConfigBody } from './client.ts';
 /**
  * Translate a drafted `ReclaimProvider` (from `propose_provider`) into the
@@ -22,7 +23,74 @@ export interface OldProviderOpts {
     /** Defaults to `true` when omitted. Register only (Provider-level flag). */
     useProxy?: boolean;
     providerType?: 'PRIVATE' | 'PUBLIC';
+    /** Page-injection script — old-devtools' name for the builder's
+     *  `webSettings.jsUserScripts`. Top-level on register, nested under
+     *  `providerConfig` on config (add-version). The backend rejects a few
+     *  deprecated injection APIs (e.g. `window.payloadData`) with a 400. */
+    customInjection?: string;
+    /** Accepted at register too (unlike the four fields below, which the
+     *  backend only accepts on config/add-version). */
+    userAgent?: {
+        ios?: string;
+        android?: string;
+    };
+    /** Accepted at register too. */
+    pageTitle?: string;
+    /** Config (add-version) ONLY — the register endpoint hardcodes this to
+     *  `[]` and ignores whatever is sent. Already old-backend-shaped: build
+     *  fresh entries with {@link injectedRequestDataFrom}; a carried-forward
+     *  value (read back from an existing version) passes through unchanged. */
+    allowedInjectedRequestData?: OldInjectedRequestData[];
+    /** Config (add-version) ONLY — the register endpoint never reads this
+     *  field from the request body. */
+    stepsToFollow?: string;
+    /** Config (add-version) ONLY — the register endpoint never reads this
+     *  field from the request body. */
+    useIncognitoWebview?: boolean;
+    /** Config (add-version) ONLY — the register endpoint never reads this
+     *  field from the request body. Free-form JSON. */
+    extensionConfig?: unknown;
 }
+interface OldResponseMatch {
+    value: string;
+    type: string;
+    isOptional: boolean;
+    order: number;
+}
+interface OldResponseRedaction {
+    xPath?: string;
+    jsonPath?: string;
+    regex?: string;
+    /** OPRF mode (`oprf` / `oprf-raw` / `oprf-mpc`) — the backend stores it as
+     *  a free-form string and the attestor interprets it at verification. */
+    hash?: string;
+    order: number;
+}
+interface OldRequestData {
+    url: string;
+    urlType: 'CONSTANT' | 'TEMPLATE';
+    method: 'GET' | 'POST';
+    responseMatches: OldResponseMatch[];
+    responseRedactions: OldResponseRedaction[];
+    credentials: 'include';
+    bodySniff?: {
+        enabled: boolean;
+        template: string;
+    };
+}
+/** One `allowedInjectedRequestData` entry — an `OldRequestData` plus the
+ *  pagination/optionality flags the old backend stores alongside it. */
+export interface OldInjectedRequestData extends OldRequestData {
+    required?: boolean;
+    multiple?: boolean;
+}
+/** Translate fresh `allowedInjectedRequestData` drafts (the author's input
+ *  shape, `AllowedJsRequest[]` — same shape the builder translator uses for
+ *  its own `allowedJsRequests`) into the old backend's shape. A
+ *  carried-forward value read back from an existing version is ALREADY in
+ *  this shape and should be passed straight through instead — don't run it
+ *  through this a second time. */
+export declare function injectedRequestDataFrom(requests: AllowedJsRequest[]): OldInjectedRequestData[];
 /** Body for `POST /api/providers/register` — new provider + v1.0.0. Every
  *  drafted request becomes a `requestData` entry; provider-level fields (name)
  *  come from the first draft. */
@@ -50,3 +118,4 @@ export declare function extractVersions(resp: unknown): SemverTriplet[];
  * rather than collide with the guaranteed 1.0.0).
  */
 export declare function bumpPatchString(versions: SemverTriplet[]): string;
+export {};

package/lib/old/to-register.js

@@ -4,7 +4,10 @@
  *  is a Provider-level flag (register only). */
 const DEFAULT_GEO_LOCATION = '{{DYNAMIC_GEO}}';
 const DEFAULT_USE_PROXY = true;
-/** Build the single `requestData` entry shared by register + update. */
+/** Build the single `requestData` entry shared by register + update. Takes
+ *  the loose `DraftRequest` shape (not the full `ReclaimProvider`) so it can
+ *  build BOTH the top-level `requestData` and `allowedInjectedRequestData`
+ *  entries — a `ReclaimProvider` satisfies it structurally either way. */
 function requestDataFromProvider(provider) {
     const method = String(provider.method).toUpperCase();
     if (method !== 'GET' && method !== 'POST') {
@@ -22,7 +25,8 @@ function requestDataFromProvider(provider) {
             'consumer-supplied params to the {{context_<name>}} form ' +
             'for this backend.');
     }
-    const responseMatches = provider.responseMatches.map((m, i) => ({
+    const responseMatches = (provider.responseMatches ?? [])
+        .map((m, i) => ({
         value: m.value,
         type: m.type ?? 'contains',
         isOptional: false,
@@ -78,6 +82,19 @@ function requestDataFromProvider(provider) {
 function requestDataFrom(providers) {
     return providers.map(requestDataFromProvider);
 }
+/** Translate fresh `allowedInjectedRequestData` drafts (the author's input
+ *  shape, `AllowedJsRequest[]` — same shape the builder translator uses for
+ *  its own `allowedJsRequests`) into the old backend's shape. A
+ *  carried-forward value read back from an existing version is ALREADY in
+ *  this shape and should be passed straight through instead — don't run it
+ *  through this a second time. */
+export function injectedRequestDataFrom(requests) {
+    return requests.map((req) => ({
+        ...requestDataFromProvider(req),
+        required: req.required ?? true,
+        multiple: req.multiple ?? true,
+    }));
+}
 /** Body for `POST /api/providers/register` — new provider + v1.0.0. Every
  *  drafted request becomes a `requestData` entry; provider-level fields (name)
  *  come from the first draft. */
@@ -94,6 +111,18 @@ export function providerToRegisterBody(providers, opts) {
     if (opts.description !== undefined) {
         body.description = opts.description;
     }
+    if (opts.customInjection !== undefined) {
+        body.customInjection = opts.customInjection;
+    }
+    // Register also accepts these two (unlike allowedInjectedRequestData /
+    // stepsToFollow / useIncognitoWebview / extensionConfig, which the
+    // register controller never reads from the body at all).
+    if (opts.userAgent !== undefined) {
+        body.userAgent = opts.userAgent;
+    }
+    if (opts.pageTitle !== undefined) {
+        body.pageTitle = opts.pageTitle;
+    }
     return body;
 }
 /** Body for `POST /api/providers/:providerId/config` — adds a new version to
@@ -108,6 +137,27 @@ export function providerToConfigBody(providers, opts, version, versionInfo) {
         geoLocation: opts.geoLocation ?? DEFAULT_GEO_LOCATION,
         requestData: requestDataFrom(providers),
     };
+    if (opts.customInjection !== undefined) {
+        providerConfig.customInjection = opts.customInjection;
+    }
+    if (opts.userAgent !== undefined) {
+        providerConfig.userAgent = opts.userAgent;
+    }
+    if (opts.pageTitle !== undefined) {
+        providerConfig.pageTitle = opts.pageTitle;
+    }
+    if (opts.allowedInjectedRequestData !== undefined) {
+        providerConfig.allowedInjectedRequestData = opts.allowedInjectedRequestData;
+    }
+    if (opts.stepsToFollow !== undefined) {
+        providerConfig.stepsToFollow = opts.stepsToFollow;
+    }
+    if (opts.useIncognitoWebview !== undefined) {
+        providerConfig.useIncognitoWebview = opts.useIncognitoWebview;
+    }
+    if (opts.extensionConfig !== undefined) {
+        providerConfig.extensionConfig = opts.extensionConfig;
+    }
     return { providerConfig, version, versionInfo };
 }
 /**

package/lib/old/tools/authenticate.js

@@ -1,5 +1,5 @@
 import { agentDisabled } from "../../consts.js";
-import { defineTool, } from "../../mcp/server.js";
+import { defineTool } from "../../mcp/server.js";
 import { persistIdentity, toEthUid } from "../identity.js";
 import { captureFirebaseTokenViaCdp } from "../login-cdp.js";
 /**
@@ -69,7 +69,7 @@ export function authenticateTool(client) {
                 },
             },
         },
-    }, async ({ token, ethAddress, loginUrl, timeoutMs, useBrowser }, ctx) => {
+    }, async ({ token, ethAddress, loginUrl, timeoutMs, useBrowser }) => {
         if (token && ethAddress) {
             throw new Error('Provide only ONE of `token` or `ethAddress`, not both.');
         }
@@ -113,11 +113,7 @@ export function authenticateTool(client) {
             throw new Error('Browser login is unavailable (RECLAIM_AGENT_DISABLED=1). Pass a ' +
                 '`token` (Firebase ID token) or `ethAddress` instead.');
         }
-        const result = await captureFirebaseTokenViaCdp({
-            loginUrl,
-            timeoutMs,
-            onProgress: ctx.reportProgress,
-        });
+        const result = await captureFirebaseTokenViaCdp({ loginUrl, timeoutMs });
         const identity = { kind: 'bearer', token: result.token };
         await validate(identity);
         persistIdentity(identity);

package/lib/old/tools/build.d.ts

@@ -1,9 +1,14 @@
 import type { RegisteredTool } from '../../mcp/server.ts';
 import type { ReclaimOldClient } from '../client.ts';
+import type { ReclaimSdkClient } from '../sdk-client.ts';
 /**
  * The backend-facing tools for OLD-devtools mode. Mirrors
  * `buildCredentialTools` / `buildAgentTools`: returns a flat `RegisteredTool`
  * list for `registerToolList`. These replace the builder credential + publish
  * tools and the (disabled) generated provider tools.
+ *
+ * `sdkClient` is a SEPARATE, unauthenticated client for the public
+ * production SDK backend (`api.reclaimprotocol.org`) — a different host from
+ * `client`'s old-devtools dashboard backend (`devapi.reclaimprotocol.org`).
  */
-export declare function buildOldBackendTools(client: ReclaimOldClient): RegisteredTool[];
+export declare function buildOldBackendTools(client: ReclaimOldClient, sdkClient: ReclaimSdkClient): RegisteredTool[];

package/lib/old/tools/build.js

@@ -1,18 +1,28 @@
 import { authenticateTool } from "./authenticate.js";
+import { getProviderInfoTool } from "./get-provider-info.js";
+import { getProviderVersionConfigTool } from "./get-version-config.js";
 import { getMeProvidersTool } from "./me-providers.js";
 import { createVersionFromCaptureTool } from "./publish.js";
 import { sessionAnalyticsLogsTool } from "./session-analytics-logs.js";
+import { updateProviderMetadataTool } from "./update-provider-metadata.js";
 /**
  * The backend-facing tools for OLD-devtools mode. Mirrors
  * `buildCredentialTools` / `buildAgentTools`: returns a flat `RegisteredTool`
  * list for `registerToolList`. These replace the builder credential + publish
  * tools and the (disabled) generated provider tools.
+ *
+ * `sdkClient` is a SEPARATE, unauthenticated client for the public
+ * production SDK backend (`api.reclaimprotocol.org`) — a different host from
+ * `client`'s old-devtools dashboard backend (`devapi.reclaimprotocol.org`).
  */
-export function buildOldBackendTools(client) {
+export function buildOldBackendTools(client, sdkClient) {
     return [
         authenticateTool(client),
         createVersionFromCaptureTool(client),
         getMeProvidersTool(client),
+        getProviderVersionConfigTool(client),
+        getProviderInfoTool(sdkClient),
+        updateProviderMetadataTool(client),
         sessionAnalyticsLogsTool(client),
     ];
 }

package/lib/old/tools/get-provider-info.d.ts

@@ -0,0 +1,16 @@
+import { type RegisteredTool } from '../../mcp/server.ts';
+import type { ReclaimSdkClient } from '../sdk-client.ts';
+/**
+ * Read provider info from the PUBLIC production SDK backend
+ * (`api.reclaimprotocol.org`) — the service the verification SDK/attestor
+ * itself calls at runtime, NOT the old-devtools dashboard backend
+ * (`get_provider_version_config`, `devapi.reclaimprotocol.org`, requires
+ * auth). Both underlying reads are unauthenticated.
+ *
+ * Fetches BOTH shapes in one call, since they're complementary:
+ *   - `provider`: full provider + providerConfig, `customInjection` included.
+ *   - `configs`: the trimmed runtime recipe the attestor actually consumes —
+ *     `customInjection` deliberately omitted, `isScriptRequestingClaim`
+ *     computed instead.
+ */
+export declare function getProviderInfoTool(client: ReclaimSdkClient): RegisteredTool;