@reclaimprotocol/agent 0.1.10 → 0.1.12

package/lib/authoring/tools.js

@@ -135,6 +135,73 @@ export function authoringTools(resolveBackend) {
                 ...(c.httpOnly ? { httpOnly: true } : {}),
             }));
         }),
+        defineTool({
+            name: 'wait_for_login',
+            description: 'Wait for the user to finish logging in. Polls the browser\'s '
+                + 'REAL cookies over CDP (httpOnly INCLUDED) until a NEW session '
+                + 'cookie appears, ignoring analytics/bot cookies. The ONLY '
+                + 'correct login wait — NEVER use wait_for_page for it: page JS '
+                + 'can\'t see the httpOnly session cookie (hangs the whole '
+                + 'timeout), yet DOES see pre-login tracking cookies (a '
+                + 'length/substring check fires instantly, before the user '
+                + 'types). Snapshots the baseline itself — call right after '
+                + 'navigating to the login page. Does NOT navigate (never yanks '
+                + 'the user off login/2FA). Returns { loggedIn, newCookies }.',
+            inputSchema: objectSchema({ timeoutMs: { type: 'number' } }),
+        }, async (args) => {
+            const backend = resolveBackend(args);
+            const deadline = Date.now() + (Number(args.timeoutMs) || 180000);
+            const cookies = async () => {
+                const res = (await backend.sendCdp('Network.getCookies'));
+                return res.cookies ?? [];
+            };
+            // Analytics / bot-protection / pre-auth infra cookies appear (and
+            // rotate) without any login — never the signal, even when new.
+            const JUNK = new RegExp('^(' + [
+                '_ga', '_gid', '_gat', '_ym', '__ddg', '__gads', '__gpi', '__eoi',
+                '__utm', '_fbp', 'fbp', 'fr', 'FCCDCF', 'pinLogger',
+                'userFirstVisit', 'cf_', '_dd_', 'bcookie', 'bscookie', 'lidc',
+            ].join('|') + ')', 'i');
+            // A real session/auth cookie name. Deliberately NOT bare `token` — a
+            // challenge/CSRF token (e.g. LinkedIn `chp_token`) contains it and is
+            // set BEFORE auth completes. Any new httpOnly cookie is also a
+            // candidate (server-set session cookies are usually httpOnly).
+            const SESSION = /sess|sid|jwt|_session|auth|logged.?in|remember|li_at/i;
+            // Auth/challenge URL paths — while the page is still on one, login is
+            // NOT done (a mid-flow cookie must not count). Cross-site-stable, far
+            // more so than cookie names.
+            const AUTH_URL = new RegExp([
+                'login', 'signin', 'sign-in', 'challenge', 'checkpoint', '\\buas\\b',
+                'authorize', '\\bsso\\b', 'mfa', '2fa', 'two-factor', 'otp', 'verify',
+                'password',
+            ].join('|'), 'i');
+            const offAuthUrl = async () => {
+                const { value } = await evalInPage(backend, 'location.href');
+                const href = typeof value === 'string' ? value : '';
+                try {
+                    const u = new URL(href);
+                    return !AUTH_URL.test(u.pathname + u.search);
+                }
+                catch {
+                    return false;
+                }
+            };
+            const initial = await cookies();
+            const baseline = new Set(initial.map((c) => c.name));
+            while (Date.now() < deadline) {
+                const current = await cookies();
+                const fresh = current
+                    .filter((c) => !baseline.has(c.name) && !JUNK.test(c.name));
+                const hit = fresh.filter((c) => c.httpOnly || SESSION.test(c.name));
+                // BOTH required: a new session cookie AND the page has left the auth
+                // flow. Either alone false-positives (mid-flow token; stray nav).
+                if (hit.length && await offAuthUrl()) {
+                    return { loggedIn: true, newCookies: hit.map((c) => c.name) };
+                }
+                await sleep(1000);
+            }
+            return { loggedIn: false, newCookies: [] };
+        }),
         defineTool({
             name: 'list_requests',
             description: 'List captured network requests (method/url/status/size), newest '

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

@@ -14,38 +14,63 @@ export function findTool(resolveBackend) {
         description: 'Search captured responses for any encoding of `value` (raw, '
             + 'URL/JSON/HTML-escaped, …). Returns a ranked candidate list with '
             + 'the matched variant, score, and a short snippet — used to locate '
-            + 'the request that returns a target. Server-side; bodies stay here.',
+            + 'the request that returns a target. Also finds SPLIT matches: when '
+            + '`value` is multi-word (e.g. a full name), a response that carries '
+            + 'every word SEPARATELY (a JSON profile API with first/last name in '
+            + 'distinct fields) is returned with `splitMatch:true` — prove those '
+            + 'per-field (a redaction per part) rather than as one string. '
+            + 'Server-side; bodies stay here.',
         inputSchema: objectSchema({ value: { type: 'string' }, limit: { type: 'number' } }, ['value']),
     }, async (args) => {
         const backend = resolveBackend(args);
-        const variants = normalizeCandidates(String(args.value));
+        const value = String(args.value);
+        const variants = normalizeCandidates(value);
+        // Name-part tokens (≥3 chars) for split-field detection — a JSON API
+        // often carries a full name as separate first/last fields, so the whole
+        // string never matches even though the value IS there.
+        const tokens = value.split(/\s+/).filter((t) => t.length >= 3);
+        const snip = (body, idx, len) => {
+            const s = Math.max(0, idx - 40);
+            return body.slice(s, Math.min(body.length, idx + len + 40));
+        };
         const ranked = [];
         for (const r of backend.capture.requests.values()) {
             if (!r.responseBody) {
                 continue;
             }
+            const body = r.responseBody;
+            // Prefer JSON responses + smaller bodies (likely API endpoints).
+            const base = (r.contentType.includes('json') ? 10 : 0)
+                + Math.max(0, 5 - Math.log10(Math.max(r.size, 1)));
             let hit;
             for (const v of variants) {
-                const idx = r.responseBody.indexOf(v);
+                const idx = body.indexOf(v);
                 if (idx >= 0) {
-                    const start = Math.max(0, idx - 40);
-                    const end = Math.min(r.responseBody.length, idx + v.length + 40);
-                    hit = { snippet: r.responseBody.slice(start, end), variant: v };
+                    hit = { snippet: snip(body, idx, v.length), variant: v };
                     break;
                 }
             }
-            if (!hit) {
+            if (hit) {
+                // Whole-value match — ranked above split matches (+5).
+                ranked.push({
+                    ...publicRequest(r),
+                    matchedVariant: hit.variant,
+                    snippet: hit.snippet,
+                    score: base + 5,
+                });
                 continue;
             }
-            // Prefer JSON responses + smaller bodies (likely API endpoints).
-            const score = (r.contentType.includes('json') ? 10 : 0)
-                + Math.max(0, 5 - Math.log10(Math.max(r.size, 1)));
-            ranked.push({
-                ...publicRequest(r),
-                matchedVariant: hit.variant,
-                snippet: hit.snippet,
-                score,
-            });
+            // Split match: every word present separately (e.g. first/last name
+            // in distinct JSON fields). Requires ≥2 tokens so it's specific.
+            if (tokens.length >= 2 && tokens.every((t) => body.includes(t))) {
+                ranked.push({
+                    ...publicRequest(r),
+                    matchedVariant: `split:${tokens.join('+')}`,
+                    splitMatch: true,
+                    snippet: snip(body, body.indexOf(tokens[0]), tokens[0].length),
+                    score: base,
+                });
+            }
         }
         ranked.sort((a, b) => b.score - a.score);
         const limit = Number(args.limit) || 10;

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

@@ -71,11 +71,11 @@ export function proposeTool(resolveBackend) {
                 + '`targets` array');
         }
         for (const t of targets) {
-            if ((t.hash ?? defaultHash) !== undefined
-                && t.value.length > OPRF_MAX_BYTES) {
+            const bytes = Buffer.byteLength(t.value, 'utf8');
+            if ((t.hash ?? defaultHash) !== undefined && bytes > OPRF_MAX_BYTES) {
                 throw new Error(`OPRF caps hashed values at ${OPRF_MAX_BYTES} bytes; got `
-                    + `${t.value.length}-byte "${t.value}". Use a tighter `
-                    + 'target or drop `hash`.');
+                    + `${bytes}-byte "${t.value}". Use a tighter target or drop `
+                    + '`hash`.');
             }
         }
         const captured = backend.capture.requests.get(requestId);

package/lib/old/client.d.ts

@@ -71,6 +71,20 @@ export interface MyProvidersQuery {
     pageSize?: number;
     searchQuery?: string;
 }
+/** `POST /api/applications/issue-credentials` response — a brand-new,
+ *  unassociated (sandboxed) app. `appSecret` is the raw eth private key;
+ *  it's returned once and never stored server-side in recoverable form. */
+export interface IssuedAppCredentials {
+    appId: string;
+    appSecret: string;
+}
+/** `GET /api/applications/link/nonce` response — a one-time, 5-minute-TTL
+ *  challenge the caller signs with the app's private key to prove ownership
+ *  in `linkAppToAccount`. */
+export interface LinkNonce {
+    nonce: string;
+    expiresInSeconds: number;
+}
 /**
  * Minimal REST client for the OLD devtools Express backend (base `/api`).
  * Deliberately NOT a clone of `@reclaimprotocol/client`'s operationId
@@ -99,11 +113,6 @@ 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
@@ -115,5 +124,22 @@ export declare class ReclaimOldClient {
      *  `#request`). Attaches the caller identity when one is set; queried
      *  anonymously otherwise. */
     getSessionAnalyticsLogs(sessionId: string): Promise<unknown>;
+    /** Mint a brand-new, unassociated (sandboxed) app — no auth required. Link
+     *  it to an account afterwards with `getLinkNonce` + `linkAppToAccount`, or
+     *  use it as-is within the sandbox session limit. */
+    issueCredentials(): Promise<IssuedAppCredentials>;
+    /** One-time, 5-minute challenge for `linkAppToAccount`. Requires auth —
+     *  the nonce is scoped to the authenticated user's uid. */
+    getLinkNonce(): Promise<LinkNonce>;
+    /** Link an unassociated (`issueCredentials`-minted) app to the
+     *  authenticated account. `signature` must be an EIP-191 signature, made
+     *  with the app's private key, over the exact string
+     *  `` `Link ${appId} to account ${userId} | nonce: ${nonce}` `` — see
+     *  `buildLinkMessage` in the backend's `application.controller.ts`. Fails
+     *  with `APP_ALREADY_LINKED` (400) if the app already belongs to someone. */
+    linkAppToAccount(appId: string, signature: string, nonce: string): Promise<unknown>;
+    /** Public, unauthenticated app status — `isLinked`, sandbox/quota info.
+     *  Works for any appId, owned or not. */
+    getApplicationStatus(appId: string): Promise<unknown>;
     getMyProviders(query?: MyProvidersQuery): Promise<unknown>;
 }

package/lib/old/client.js

@@ -60,16 +60,6 @@ export class ReclaimOldClient {
     listVersions(providerId) {
         return __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, '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 __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, '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
@@ -99,6 +89,39 @@ export class ReclaimOldClient {
         }
         return json;
     }
+    /** Mint a brand-new, unassociated (sandboxed) app — no auth required. Link
+     *  it to an account afterwards with `getLinkNonce` + `linkAppToAccount`, or
+     *  use it as-is within the sandbox session limit. */
+    async issueCredentials() {
+        const res = await __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, 'POST', '/applications/issue-credentials');
+        return res.data;
+    }
+    /** One-time, 5-minute challenge for `linkAppToAccount`. Requires auth —
+     *  the nonce is scoped to the authenticated user's uid. */
+    async getLinkNonce() {
+        const res = await __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, 'GET', '/applications/link/nonce', {
+            auth: true,
+        });
+        return res.data;
+    }
+    /** Link an unassociated (`issueCredentials`-minted) app to the
+     *  authenticated account. `signature` must be an EIP-191 signature, made
+     *  with the app's private key, over the exact string
+     *  `` `Link ${appId} to account ${userId} | nonce: ${nonce}` `` — see
+     *  `buildLinkMessage` in the backend's `application.controller.ts`. Fails
+     *  with `APP_ALREADY_LINKED` (400) if the app already belongs to someone. */
+    linkAppToAccount(appId, signature, nonce) {
+        return __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, 'POST', '/applications/link', {
+            body: { appId, signature, nonce },
+            auth: true,
+        });
+    }
+    /** Public, unauthenticated app status — `isLinked`, sandbox/quota info.
+     *  Works for any appId, owned or not. */
+    async getApplicationStatus(appId) {
+        const res = await __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, 'GET', `/applications/status/${encodeURIComponent(appId)}`);
+        return res.data;
+    }
     getMyProviders(query = {}) {
         // Every one of these query params is REQUIRED by the backend
         // validator (missing/invalid → 400), so default them all here.

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

@@ -83,6 +83,8 @@ interface OldRequestData {
 export interface OldInjectedRequestData extends OldRequestData {
     required?: boolean;
     multiple?: boolean;
+    templateParams?: string[];
+    templateParamsMode?: 'separate' | 'merge';
 }
 /** Translate fresh `allowedInjectedRequestData` drafts (the author's input
  *  shape, `AllowedJsRequest[]` — same shape the builder translator uses for

package/lib/old/to-register.js

@@ -89,11 +89,15 @@ function requestDataFrom(providers) {
  *  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,
-    }));
+    return requests.map((req) => {
+        return {
+            ...requestDataFromProvider(req),
+            required: req.required ?? true,
+            multiple: req.multiple ?? true,
+            templateParams: req.templateParams,
+            templateParamsMode: req.templateParamsMode,
+        };
+    });
 }
 /** Body for `POST /api/providers/register` — new provider + v1.0.0. Every
  *  drafted request becomes a `requestData` entry; provider-level fields (name)

package/lib/old/tools/build.js

@@ -1,10 +1,15 @@
 import { authenticateTool } from "./authenticate.js";
+import { checkAppStatusTool } from "./check-app-status.js";
 import { getProviderInfoTool } from "./get-provider-info.js";
-import { getProviderVersionConfigTool } from "./get-version-config.js";
+import { issueAppCredentialsTool } from "./issue-app-credentials.js";
+import { getJsSdkIntegrationGuideTool } from "./js-sdk-integration-guide.js";
+import { linkAppTool } from "./link-app.js";
 import { getMeProvidersTool } from "./me-providers.js";
 import { createVersionFromCaptureTool } from "./publish.js";
+import { scaffoldDemoServerTool } from "./scaffold-demo-server.js";
 import { sessionAnalyticsLogsTool } from "./session-analytics-logs.js";
 import { updateProviderMetadataTool } from "./update-provider-metadata.js";
+import { verifySdkSetupTool } from "./verify-sdk-setup.js";
 /**
  * The backend-facing tools for OLD-devtools mode. Mirrors
  * `buildCredentialTools` / `buildAgentTools`: returns a flat `RegisteredTool`
@@ -20,9 +25,14 @@ export function buildOldBackendTools(client, sdkClient) {
         authenticateTool(client),
         createVersionFromCaptureTool(client),
         getMeProvidersTool(client),
-        getProviderVersionConfigTool(client),
         getProviderInfoTool(sdkClient),
         updateProviderMetadataTool(client),
         sessionAnalyticsLogsTool(client),
+        issueAppCredentialsTool(client),
+        linkAppTool(client),
+        checkAppStatusTool(client),
+        getJsSdkIntegrationGuideTool(),
+        scaffoldDemoServerTool(),
+        verifySdkSetupTool(client),
     ];
 }

package/lib/old/tools/check-app-status.d.ts

@@ -0,0 +1,8 @@
+import { type RegisteredTool } from '../../mcp/server.ts';
+import type { ReclaimOldClient } from '../client.ts';
+/**
+ * Public, unauthenticated app status lookup — works for any `appId`, owned
+ * or not, linked or sandboxed. Mirrors the backend's
+ * `GET /api/applications/status/:appId`.
+ */
+export declare function checkAppStatusTool(client: ReclaimOldClient): RegisteredTool;

package/lib/old/tools/check-app-status.js

@@ -0,0 +1,27 @@
+import { defineTool } from "../../mcp/server.js";
+/**
+ * Public, unauthenticated app status lookup — works for any `appId`, owned
+ * or not, linked or sandboxed. Mirrors the backend's
+ * `GET /api/applications/status/:appId`.
+ */
+export function checkAppStatusTool(client) {
+    return defineTool({
+        name: 'check_app_status',
+        description: 'Check a Reclaim app\'s link/sandbox status by appId — no ' +
+            'authentication required. Returns whether the app is linked to a ' +
+            'dashboard account (`isLinked`), and for linked apps, remaining ' +
+            'session quota. A 404 means the appId has never been used yet — ' +
+            'it is created lazily on the first ReclaimProofRequest.init() call ' +
+            'or via issue_app_credentials.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The eth-address appId to check.',
+                },
+            },
+            required: ['appId'],
+        },
+    }, async ({ appId }) => client.getApplicationStatus(appId));
+}

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

@@ -1,14 +1,17 @@
 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.
+ * The single provider-read tool for old-devtools mode. Reads from the PUBLIC
+ * production SDK backend (`api.reclaimprotocol.org`) — the service the
+ * verification SDK/attestor itself calls at runtime. No auth required, works
+ * for ANY provider.
  *
- * Fetches BOTH shapes in one call, since they're complementary:
- *   - `provider`: full provider + providerConfig, `customInjection` included.
+ * Fetches BOTH shapes in one call, since they're complementary and together
+ * cover everything a caller needs before re-publishing a new version:
+ *   - `provider`: the full provider + providerConfig — `customInjection`,
+ *     `userAgent`, `allowedInjectedRequestData`, `requestData`, everything.
+ *     This is what you read before create_provider_version_from_capture so
+ *     you can pass the whole config back (that tool carries nothing forward).
  *   - `configs`: the trimmed runtime recipe the attestor actually consumes —
  *     `customInjection` deliberately omitted, `isScriptRequestingClaim`
  *     computed instead.

package/lib/old/tools/get-provider-info.js

@@ -13,14 +13,17 @@ async function attempt(label, call) {
     }
 }
 /**
- * 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.
+ * The single provider-read tool for old-devtools mode. Reads from the PUBLIC
+ * production SDK backend (`api.reclaimprotocol.org`) — the service the
+ * verification SDK/attestor itself calls at runtime. No auth required, works
+ * for ANY provider.
  *
- * Fetches BOTH shapes in one call, since they're complementary:
- *   - `provider`: full provider + providerConfig, `customInjection` included.
+ * Fetches BOTH shapes in one call, since they're complementary and together
+ * cover everything a caller needs before re-publishing a new version:
+ *   - `provider`: the full provider + providerConfig — `customInjection`,
+ *     `userAgent`, `allowedInjectedRequestData`, `requestData`, everything.
+ *     This is what you read before create_provider_version_from_capture so
+ *     you can pass the whole config back (that tool carries nothing forward).
  *   - `configs`: the trimmed runtime recipe the attestor actually consumes —
  *     `customInjection` deliberately omitted, `isScriptRequestingClaim`
  *     computed instead.
@@ -31,15 +34,18 @@ export function getProviderInfoTool(client) {
         description: 'Read a PUBLISHED provider from the public production SDK backend ' +
             '(api.reclaimprotocol.org — what the verification SDK/attestor ' +
             'itself fetches at runtime), for ANY provider, no auth required. ' +
-            'Different from get_provider_version_config, which reads the old ' +
-            'devtools DASHBOARD backend and requires auth. \n\n' +
+            'This is the provider-read tool for old-devtools mode. \n\n' +
             'Returns two complementary reads for the given version (latest ' +
-            'when `versionNumber` is omitted): `provider` (the full provider ' +
-            '+ providerConfig, including `customInjection`) and `configs` (the ' +
-            'trimmed recipe the attestor actually consumes — `customInjection` ' +
-            'is deliberately OMITTED there, replaced by a computed ' +
-            '`isScriptRequestingClaim` flag). One endpoint failing (e.g. an ' +
-            'invalid `versionNumber`) is reported under `errors` without ' +
+            'when `versionNumber` is omitted): `provider` (the FULL provider ' +
+            '+ providerConfig — `customInjection`, `userAgent`, ' +
+            '`allowedInjectedRequestData`, `requestData`, everything) and ' +
+            '`configs` (the trimmed recipe the attestor actually consumes — ' +
+            '`customInjection` is deliberately OMITTED there, replaced by a ' +
+            'computed `isScriptRequestingClaim` flag). Read `provider` here ' +
+            'BEFORE create_provider_version_from_capture so you can pass the ' +
+            'whole existing config back — that tool always creates a new ' +
+            'version and carries nothing forward. One endpoint failing (e.g. ' +
+            'an invalid `versionNumber`) is reported under `errors` without ' +
             'hiding a result the other endpoint did return.',
         inputSchema: {
             type: 'object',

package/lib/old/tools/issue-app-credentials.d.ts

@@ -0,0 +1,11 @@
+import { type RegisteredTool } from '../../mcp/server.ts';
+import type { ReclaimOldClient } from '../client.ts';
+/**
+ * Mint a brand-new eth-keypair APP (as opposed to authenticating as a
+ * dashboard user). `appId` is the eth address, `appSecret` the raw private
+ * key — this is the pair `@reclaimprotocol/js-sdk`'s `ReclaimProofRequest.init`
+ * expects. No auth required: the app starts unassociated (`creatorUid: null`)
+ * and sandboxed (`sandboxLimit: 100` sessions). Use `link_app_to_account` to
+ * attach it to your dashboard account, or `check_app_status` to inspect it.
+ */
+export declare function issueAppCredentialsTool(client: ReclaimOldClient): RegisteredTool;

package/lib/old/tools/issue-app-credentials.js

@@ -0,0 +1,35 @@
+import { defineTool } from "../../mcp/server.js";
+/**
+ * Mint a brand-new eth-keypair APP (as opposed to authenticating as a
+ * dashboard user). `appId` is the eth address, `appSecret` the raw private
+ * key — this is the pair `@reclaimprotocol/js-sdk`'s `ReclaimProofRequest.init`
+ * expects. No auth required: the app starts unassociated (`creatorUid: null`)
+ * and sandboxed (`sandboxLimit: 100` sessions). Use `link_app_to_account` to
+ * attach it to your dashboard account, or `check_app_status` to inspect it.
+ */
+export function issueAppCredentialsTool(client) {
+    return defineTool({
+        name: 'issue_app_credentials',
+        description: 'Mint a new Reclaim APP (eth keypair) on the old devtools backend — ' +
+            'no authentication required. Returns `{ appId, appSecret }`: ' +
+            '`appId` is the eth address, `appSecret` the raw private key. This ' +
+            'is the appId/appSecret pair for @reclaimprotocol/js-sdk ' +
+            '(`ReclaimProofRequest.init(appId, appSecret, providerId)`). The app ' +
+            'starts UNLINKED and sandboxed (100 sessions) — call ' +
+            'link_app_to_account to attach it to your dashboard account and ' +
+            'check_app_status to check its state. Store `appSecret` like a ' +
+            'password (e.g. in a gitignored .env as RECLAIM_APP_SECRET) — it ' +
+            'is returned once and cannot be recovered from the server.',
+        inputSchema: { type: 'object', properties: {} },
+    }, async () => {
+        const { appId, appSecret } = await client.issueCredentials();
+        return {
+            appId,
+            appSecret,
+            note: 'Unlinked, sandboxed app (100 session limit). Set RECLAIM_APP_ID ' +
+                'and RECLAIM_APP_SECRET in your .env (gitignored). Run ' +
+                'link_app_to_account to attach it to your dashboard account and ' +
+                'lift the sandbox limit.',
+        };
+    });
+}

package/lib/old/tools/js-sdk-integration-guide.d.ts

@@ -0,0 +1,2 @@
+import { type RegisteredTool } from '../../mcp/server.ts';
+export declare function getJsSdkIntegrationGuideTool(): RegisteredTool;