@reclaimprotocol/agent 0.1.1 → 0.1.2

package/lib/mcp/server.d.ts

@@ -30,9 +30,3 @@ export declare function defineTool<TArgs>(definition: ToolDefinition, handler: (
  * stringification and error catching for tool execution.
  */
 export declare function registerToolList(server: McpServer, tools: RegisteredTool[]): void;
-export declare class ReclaimMcpServer {
-    #private;
-    constructor();
-    register(tool: RegisteredTool): void;
-    listen(): Promise<void>;
-}

package/lib/mcp/server.js

@@ -1,6 +1,3 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { toZod } from "./api/to-zod.js";
 import { remapErrorAsResponse } from "./remap_errors.js";
 /**
@@ -47,30 +44,3 @@ export function registerToolList(server, tools) {
         });
     }
 }
-export class ReclaimMcpServer {
-    #tools = new Map();
-    #server;
-    constructor() {
-        this.#server = new Server({ name: 'reclaim-agent', version: '0.1.0' }, { capabilities: { tools: {} } });
-        this.#server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            // Double-cast: our `ToolDefinition` carries the same fields as the
-            // SDK's `Tool` but the SDK's type is strict-narrowed and won't
-            // accept ours without going through `unknown`.
-            tools: [...this.#tools.values()].map((t) => t.definition),
-        }));
-        this.#server.setRequestHandler(CallToolRequestSchema, async (req) => {
-            const tool = this.#tools.get(req.params.name);
-            if (!tool) {
-                throw new Error(`unknown tool: ${req.params.name}`);
-            }
-            const result = await tool.handler(req.params.arguments ?? {});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-    }
-    register(tool) {
-        this.#tools.set(tool.definition.name, tool);
-    }
-    async listen() {
-        await this.#server.connect(new StdioServerTransport());
-    }
-}

package/lib/mcp/start.js

@@ -1,8 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { DEFAULT_BASE_URL, ReclaimClient } from '@reclaimprotocol/client';
-import { DEFAULT_OLD_API_URL, ReclaimOldClient } from "../old/client.js";
-import { useOldDevtools } from "../old/flag.js";
+import { ReclaimClient } from '@reclaimprotocol/client';
+import { agentDisabled, apiToken, apiUrl, oldApiUrl, useOldDevtools, } from "../consts.js";
+import { ReclaimOldClient } from "../old/client.js";
 import { resolveInitialIdentity } from "../old/identity.js";
 import { OLD_MODE_INSTRUCTIONS } from "../old/instructions.js";
 import { buildOldBackendTools } from "../old/tools/build.js";
@@ -22,14 +22,14 @@ export async function startMcpServer() {
     // backend-independent and registered in both modes. Skipped in hosted
     // deployments — set RECLAIM_AGENT_DISABLED=1 to register only the API
     // surface.
-    const agentToolsEnabled = process.env.RECLAIM_AGENT_DISABLED !== '1';
+    const agentToolsEnabled = !agentDisabled();
     if (oldMode) {
         // OLD-devtools mode (the default): the legacy backend is still in
         // production while builder is built. All auto-generated builder tools
         // are disabled; a small ReclaimOldClient serves authenticate / publish /
         // get_me_providers instead.
         const oldClient = new ReclaimOldClient({
-            baseUrl: process.env.RECLAIM_OLD_API_URL || DEFAULT_OLD_API_URL,
+            baseUrl: oldApiUrl(),
             identity: resolveInitialIdentity(),
         });
         registerToolList(server, buildLocalCredentialTools());
@@ -42,9 +42,9 @@ export async function startMcpServer() {
     }
     else {
         const client = new ReclaimClient({
-            baseUrl: process.env.RECLAIM_API_URL || DEFAULT_BASE_URL,
+            baseUrl: apiUrl(),
             // Priority: explicit env var → cached session token → unauthenticated
-            token: process.env.RECLAIM_API_TOKEN || readSession()?.token,
+            token: apiToken() || readSession()?.token,
             headers: { 'User-Agent': `${NAME}/${VERSION}` },
         });
         // Tool names must stay disjoint across these three groups: hand-written

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

@@ -1,12 +1,8 @@
 /**
  * Factory entry-point for embedding the reclaim-agent's MCP tools into
- * a host MCP server. Two consumers:
- *
- *   - The agent's own standalone `src/index.ts` (uses `ReclaimMcpServer`,
- *     the low-level wrapper around `@modelcontextprotocol/sdk`'s Server).
- *   - `@reclaimprotocol/client`'s MCP server (uses `McpServer`, the
- *     high-level SDK wrapper). Calls `registerAgentTools` to fold the
- *     agent's 16 tools alongside its auto-generated API tools.
+ * a host MCP server via `registerToolList` (server.ts) on the high-level
+ * `@modelcontextprotocol/sdk` `McpServer`. Folds the agent's tools
+ * alongside the auto-generated API tools.
  *
  * Shared state — Chrome attach state, capture store, secret store — is
  * built once per server and threaded through every tool factory.
@@ -25,8 +21,8 @@ export interface AgentState {
     captures: CaptureStore;
     secrets: SecretStore;
 }
-/** Build the flat list of `RegisteredTool` entries. Useful when the host
- *  uses our internal `ReclaimMcpServer` interface (`.register(tool)`).
+/** Build the flat list of `RegisteredTool` entries, ready for
+ *  `registerToolList`.
  *  Pass `client` to include the builder `create_provider_version_from_capture`;
  *  omit it (e.g. OLD-devtools mode) to register only the backend-independent
  *  capture/proof tools — old mode supplies its own publish tool. */

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

@@ -1,12 +1,8 @@
 /**
  * Factory entry-point for embedding the reclaim-agent's MCP tools into
- * a host MCP server. Two consumers:
- *
- *   - The agent's own standalone `src/index.ts` (uses `ReclaimMcpServer`,
- *     the low-level wrapper around `@modelcontextprotocol/sdk`'s Server).
- *   - `@reclaimprotocol/client`'s MCP server (uses `McpServer`, the
- *     high-level SDK wrapper). Calls `registerAgentTools` to fold the
- *     agent's 16 tools alongside its auto-generated API tools.
+ * a host MCP server via `registerToolList` (server.ts) on the high-level
+ * `@modelcontextprotocol/sdk` `McpServer`. Folds the agent's tools
+ * alongside the auto-generated API tools.
  *
  * Shared state — Chrome attach state, capture store, secret store — is
  * built once per server and threaded through every tool factory.
@@ -30,8 +26,8 @@ function buildAgentState() {
         secrets: makeSecretStore(),
     };
 }
-/** Build the flat list of `RegisteredTool` entries. Useful when the host
- *  uses our internal `ReclaimMcpServer` interface (`.register(tool)`).
+/** Build the flat list of `RegisteredTool` entries, ready for
+ *  `registerToolList`.
  *  Pass `client` to include the builder `create_provider_version_from_capture`;
  *  omit it (e.g. OLD-devtools mode) to register only the backend-independent
  *  capture/proof tools — old mode supplies its own publish tool. */

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

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { agentTraceEnabled } from "../../../consts.js";
 import { reclaimHomeDirPath } from "../../../paths.js";
 import { runAttestorProof, tailLogs, warnsAndErrors, } from "../../../proof/attestor.js";
 import { defineTool } from "../../server.js";
@@ -182,7 +183,7 @@ export function proofTool(secrets) {
         // when investigating proof failures and the file at runLogPath
         // will carry the input provider, sentParams, full attestor log
         // stream, and result.
-        if (process.env['RECLAIM_AGENT_TRACE'] === '1') {
+        if (agentTraceEnabled()) {
             const runLogPath = writeProofRunDump({
                 provider,
                 hasSecretParamsRef: secretParamsRef !== undefined,

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

@@ -1,23 +1,118 @@
+import { INJECTION_GUIDE } from "../../../provider/injection-doc.js";
+import { countsFor, matchRedactionWarnings, } from "../../../provider/match-redaction-warning.js";
 import { nextVersion, providerToCreateVersionRequest, } from "../../../provider/to-version.js";
 import { defineTool } from "../../server.js";
+/** Schemas shared by the top-level `provider`/`providers` and the lighter
+ *  `allowedJsRequests` drafts — keeps the request shape from drifting between
+ *  them. */
+const RESPONSE_MATCHES_SCHEMA = {
+    type: 'array',
+    description: 'What the attestor checks on the revealed response slice.',
+    items: {
+        type: 'object',
+        properties: {
+            type: { type: 'string', enum: ['regex', 'contains'] },
+            value: { type: 'string' },
+        },
+        required: ['type', 'value'],
+    },
+};
+const RESPONSE_REDACTIONS_SCHEMA = {
+    type: 'array',
+    description: 'Which portions of the response the prover reveals ' +
+        '(xPath / jsonPath / regex; hash to OPRF the value). Paired with ' +
+        'responseMatches by index — keep them aligned 1-to-1. If you list more ' +
+        'redactions than matches, the tool pads matches with no-op optional ' +
+        'entries so older index-paired claim creators stay happy.',
+    items: {
+        type: 'object',
+        properties: {
+            xPath: { type: 'string' },
+            jsonPath: { type: 'string' },
+            regex: { type: 'string' },
+            hash: { type: 'string', enum: ['oprf', 'oprf-mpc', 'oprf-raw'] },
+        },
+    },
+};
+/** Properties every drafted request shares (top-level providers and the
+ *  injected `allowedJsRequests`). */
+const REQUEST_DRAFT_PROPERTIES = {
+    url: {
+        type: 'string',
+        description: 'Exact API URL the attestor replays, with {{param}} placeholders ' +
+            'for any templated values.',
+    },
+    method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH'] },
+    body: { type: 'string', description: 'Request body template, if any.' },
+    responseMatches: RESPONSE_MATCHES_SCHEMA,
+    responseRedactions: RESPONSE_REDACTIONS_SCHEMA,
+};
+/** A full provider draft (from propose_provider), passed through verbatim. */
+const PROVIDER_SCHEMA = {
+    type: 'object',
+    description: 'A `provider` object from propose_provider, passed through verbatim — ' +
+        'the tool builds the version body (the requests[] entry etc.) for you.',
+    properties: {
+        name: { type: 'string', description: 'Verification name.' },
+        ...REQUEST_DRAFT_PROPERTIES,
+        headers: {
+            type: 'object',
+            description: 'Request headers from the capture. Secret headers are stripped ' +
+                'before persistence; the client re-supplies them at runtime.',
+        },
+        paramValues: {
+            type: 'object',
+            description: 'Real values for the {{param}} placeholders, e.g. ' +
+                '{ "username": "Syed" }.',
+        },
+    },
+    required: ['name', 'url', 'method', 'responseMatches'],
+};
+/** One `allowedJsRequests` template: a request the injection script may fire,
+ *  plus pagination/optionality flags. */
+const ALLOWED_JS_REQUEST_SCHEMA = {
+    type: 'object',
+    properties: {
+        ...REQUEST_DRAFT_PROPERTIES,
+        multiple: {
+            type: 'boolean',
+            description: 'Allow the template to match many requests (e.g. pagination). ' +
+                'Default true.',
+        },
+        required: {
+            type: 'boolean',
+            description: 'Fail validation if no request matches this template. Default true.',
+        },
+    },
+    required: ['url', 'method'],
+};
 export function createVersionFromCaptureTool(client) {
     return defineTool({
         name: 'create_provider_version_from_capture',
-        description: 'Persist a drafted ReclaimProvider as a verification version. ' +
-            'Call this after run_proof succeeds, passing the `provider` object ' +
-            'from propose_provider VERBATIM. This tool builds the full version ' +
+        description: 'Persist drafted ReclaimProvider(s) as a verification version. ' +
+            'Call this after run_proof succeeds, passing the `provider` ' +
+            'object(s) from propose_provider VERBATIM. This tool builds the ' +
             'body (the requests[] array, webSettings, etc.) for you — do NOT ' +
             'hand-construct that shape or call create_provider_version directly. ' +
+            'For a MULTI-REQUEST provider, pass `providers: [...]` (each entry a ' +
+            'proven draft) — every entry becomes one request in the version, and ' +
+            'all are required at verification time. Pass a single `provider` ' +
+            'for the one-request case (exactly one of `provider`/`providers`). ' +
+            'For data gated behind login/navigation, supply `jsUserScripts` (a ' +
+            'page-injection script that drives the page to where the request ' +
+            'fires) and/or `allowedJsRequests` (extra requests the script may ' +
+            'fire, e.g. pagination). ' +
             'Omit `version` to have the tool auto-select the next available ' +
             'version (it lists existing versions and bumps past the highest). ' +
             'The version lands on the draft branch — to go live, call ' +
             '`publish_provider_version` (PRIVATE) or ' +
             '`submit_provider_version_for_review` (PUBLIC) afterwards. ' +
             '`requiredContext` is derived from any {{context.<name>}} ' +
-            'placeholders and returned on the created version — when ' +
-            'present, tell the dev verbatim which context fields consumers ' +
-            'MUST send when creating sessions (verification matches those ' +
-            'values exactly; a missing field is a 400 at session create). ' +
+            'placeholders across ALL requests (plus injected requests / script) ' +
+            'and returned on the created version — when present, tell the dev ' +
+            'verbatim which context fields consumers MUST send when creating ' +
+            'sessions (verification matches those values exactly; a missing ' +
+            'field is a 400 at session create). ' +
             'Refine types/descriptions via `update_provider_version` while ' +
             'still on draft.',
         inputSchema: {
@@ -27,71 +122,14 @@ export function createVersionFromCaptureTool(client) {
                     type: 'string',
                     description: 'UUID of the verification to publish the version on.',
                 },
-                provider: {
-                    type: 'object',
-                    description: 'The `provider` object from propose_provider, passed ' +
-                        'through verbatim — the tool builds the version body ' +
-                        '(the requests[] array etc.) for you.',
-                    properties: {
-                        name: { type: 'string', description: 'Verification name.' },
-                        url: {
-                            type: 'string',
-                            description: 'Exact API URL the attestor replays, with {{param}} ' +
-                                'placeholders for any templated values.',
-                        },
-                        method: {
-                            type: 'string',
-                            enum: ['GET', 'POST', 'PUT', 'PATCH'],
-                        },
-                        headers: {
-                            type: 'object',
-                            description: 'Request headers from the capture. Secret headers are ' +
-                                'stripped before persistence; the client re-supplies them ' +
-                                'at runtime.',
-                        },
-                        body: {
-                            type: 'string',
-                            description: 'Request body template, if any.',
-                        },
-                        responseMatches: {
-                            type: 'array',
-                            description: 'What the attestor checks on the revealed response slice.',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    type: { type: 'string', enum: ['regex', 'contains'] },
-                                    value: { type: 'string' },
-                                },
-                                required: ['type', 'value'],
-                            },
-                        },
-                        responseRedactions: {
-                            type: 'array',
-                            description: 'Which portions of the response the prover reveals ' +
-                                '(xPath / jsonPath / regex; hash to OPRF the value). ' +
-                                'Paired with responseMatches by index — the tool folds ' +
-                                'each one into the matching entry\'s `extract` in the ' +
-                                'persisted version, so keep them aligned 1-to-1.',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    xPath: { type: 'string' },
-                                    jsonPath: { type: 'string' },
-                                    regex: { type: 'string' },
-                                    hash: {
-                                        type: 'string',
-                                        enum: ['oprf', 'oprf-mpc', 'oprf-raw'],
-                                    },
-                                },
-                            },
-                        },
-                        paramValues: {
-                            type: 'object',
-                            description: 'Real values for the {{param}} placeholders, ' +
-                                'e.g. { "username": "Syed" }.',
-                        },
-                    },
-                    required: ['name', 'url', 'method', 'responseMatches'],
+                provider: PROVIDER_SCHEMA,
+                providers: {
+                    type: 'array',
+                    description: 'Multiple proven drafts → one multi-request version. Each ' +
+                        'entry has the same shape as `provider`. Pass this OR ' +
+                        '`provider`, not both.',
+                    items: PROVIDER_SCHEMA,
+                    minItems: 1,
                 },
                 initialUrl: {
                     type: 'string',
@@ -114,17 +152,68 @@ export function createVersionFromCaptureTool(client) {
                     },
                     required: ['major', 'minor', 'patch'],
                 },
+                jsUserScripts: {
+                    type: 'string',
+                    description: 'Plain JavaScript injected into the provider page before every ' +
+                        'page load (stored as webSettings.jsUserScripts). Use standard ' +
+                        'browser APIs (window.location, element.click(), forms) to ' +
+                        'drive login/navigation so the target request fires — the ' +
+                        'client already intercepts page requests, and window.Reclaim ' +
+                        'is only for rare edge cases, not navigation. The Builder ' +
+                        'verification client installs this to run before every page ' +
+                        'load (before navigating to initialUrl), matching old-devtool ' +
+                        'customInjection; window.Reclaim itself is not yet exposed ' +
+                        'there, so prefer plain browser JS. Guide:\n\n' +
+                        INJECTION_GUIDE,
+                },
+                allowedJsRequests: {
+                    type: 'array',
+                    description: 'Extra requests the injection script is allowed to fire ' +
+                        '(e.g. paginated API calls), as RequestSelectionTemplates. ' +
+                        '`multiple`/`required` default to true.',
+                    items: ALLOWED_JS_REQUEST_SCHEMA,
+                },
             },
-            required: ['providerId', 'provider', 'initialUrl'],
+            required: ['providerId', 'initialUrl'],
         },
     }, async (args) => {
+        // Exactly one of `provider` / `providers` — normalize to an array.
+        const hasMany = Array.isArray(args.providers) && args.providers.length > 0;
+        const hasOne = !!args.provider;
+        if (hasMany === hasOne) {
+            throw new Error('Pass exactly one of `provider` (a single draft) or ' +
+                '`providers` (an array of 1+ drafts).');
+        }
+        const providers = hasMany ? args.providers : [args.provider];
         // Auto-pick the next version if not explicit
         const ver = args.version ?? (await nextVersion(client, args.providerId));
-        const body = providerToCreateVersionRequest(args.provider, args.initialUrl, args.notes, ver);
-        const result = (await client.call('CreateProviderVersion', {
+        const body = providerToCreateVersionRequest(providers, args.initialUrl, {
+            notes: args.notes,
+            version: ver,
+            jsUserScripts: args.jsUserScripts,
+            allowedJsRequests: args.allowedJsRequests,
+        });
+        const result = await client.call('CreateProviderVersion', {
             params: { providerId: args.providerId },
             body,
-        }));
-        return result.data;
+        });
+        const created = result.data;
+        // Aggregate non-blocking advisories for the dev — nothing here blocks
+        // or alters what was published; the author keeps full control.
+        const notes = [];
+        // Match/redaction advisory across every request (+ injected requests).
+        const requestCounts = [
+            ...providers.map((p, i) => countsFor(`Request ${i + 1}`, p)),
+            ...(args.allowedJsRequests ?? []).map((r, i) => countsFor(`Injected request ${i + 1}`, r)),
+        ];
+        notes.push(...matchRedactionWarnings(requestCounts));
+        // Let the dev know how/when the script runs (and the window.Reclaim gap).
+        if (args.jsUserScripts?.trim()) {
+            notes.push('jsUserScripts will run in the Builder verification client before ' +
+                'every page load (before navigating to initialUrl), matching ' +
+                'old-devtool customInjection. window.Reclaim is not yet exposed ' +
+                'there, so prefer plain browser JS for navigation/interaction.');
+        }
+        return notes.length ? { ...created, _notes: notes } : created;
     });
 }

package/lib/mcp/tools/authenticate/decrypt-key.d.ts

@@ -1,32 +1,19 @@
 /**
- * Optional X25519 decryption key — only needed when testing ENCRYPTED callback
- * payloads in the consumer role. Resolution is file-only (no env var, no path
- * override, no `~/.reclaim` caching):
+ * Optional eth decryption key — only needed when testing ENCRYPTED callback
+ * payloads in the consumer role. The org's results are ECIES-encrypted to its
+ * eth public key; this is the matching eth PRIVATE key (`0x`-hex). Resolution:
  *
- *   1. An X25519 PKCS#8 PEM file named `reclaim-decrypt.pem` in the project
- *      root. Mint it with openssl:
- *
- *        openssl genpkey -algorithm X25519 -out reclaim-decrypt.pem
- *
- *   2. Absent — plaintext-only testing (no decryption key; encrypted
+ *   1. The `RECLAIM_DECRYPT_KEY` env var (a `0x`-prefixed 32-byte hex key), or
+ *   2. A file named `reclaim-decrypt.key` in the project root holding that hex.
+ *   3. Absent — plaintext-only testing (no decryption key; encrypted
  *      deliveries surface a clear error).
  *
- * The PEM *content* is loaded via the client's `loadDecryptionKey` (jose
- * `ECDH-ES`) and passed straight through as `ReclaimConfig.credential` / to
- * `decryptCallback`.
+ * The hex is loaded via the client's `loadDecryptionKey` and passed straight
+ * through as `ReclaimConfig.credential` / to `decryptCallback`.
  */
 import { type DecryptionKey } from '@reclaimprotocol/client';
-/** Default X25519 PEM filename the agent looks for in the project root. */
-export declare const DEFAULT_DECRYPT_PEM = "reclaim-decrypt.pem";
-/** Resolve the decrypt-PEM path (the default file in the project root). */
-export declare function decryptPemPath(projectDir?: string): string;
-/**
- * Read the raw decryption-key PEM string from the default file, without loading
- * it. Returns `undefined` when the file is absent (plaintext-only).
- */
-export declare function resolveDecryptKeyInput(projectDir?: string): string | undefined;
 /**
- * Load the optional decryption key. Returns `undefined` when the PEM file is
- * absent (the consumer then handles only plaintext deliveries).
+ * Load the optional decryption key. Returns `undefined` when no key is
+ * configured (the consumer then handles only plaintext deliveries).
  */
 export declare function resolveDecryptionKey(projectDir?: string): Promise<DecryptionKey | undefined>;

package/lib/mcp/tools/authenticate/decrypt-key.js

@@ -1,44 +1,41 @@
 /**
- * Optional X25519 decryption key — only needed when testing ENCRYPTED callback
- * payloads in the consumer role. Resolution is file-only (no env var, no path
- * override, no `~/.reclaim` caching):
+ * Optional eth decryption key — only needed when testing ENCRYPTED callback
+ * payloads in the consumer role. The org's results are ECIES-encrypted to its
+ * eth public key; this is the matching eth PRIVATE key (`0x`-hex). Resolution:
  *
- *   1. An X25519 PKCS#8 PEM file named `reclaim-decrypt.pem` in the project
- *      root. Mint it with openssl:
- *
- *        openssl genpkey -algorithm X25519 -out reclaim-decrypt.pem
- *
- *   2. Absent — plaintext-only testing (no decryption key; encrypted
+ *   1. The `RECLAIM_DECRYPT_KEY` env var (a `0x`-prefixed 32-byte hex key), or
+ *   2. A file named `reclaim-decrypt.key` in the project root holding that hex.
+ *   3. Absent — plaintext-only testing (no decryption key; encrypted
  *      deliveries surface a clear error).
  *
- * The PEM *content* is loaded via the client's `loadDecryptionKey` (jose
- * `ECDH-ES`) and passed straight through as `ReclaimConfig.credential` / to
- * `decryptCallback`.
+ * The hex is loaded via the client's `loadDecryptionKey` and passed straight
+ * through as `ReclaimConfig.credential` / to `decryptCallback`.
  */
 import { loadDecryptionKey, } from '@reclaimprotocol/client';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { findProjectRoot } from "../../../paths.js";
-/** Default X25519 PEM filename the agent looks for in the project root. */
-export const DEFAULT_DECRYPT_PEM = 'reclaim-decrypt.pem';
-/** Resolve the decrypt-PEM path (the default file in the project root). */
-export function decryptPemPath(projectDir = findProjectRoot(process.cwd())) {
-    return join(projectDir, DEFAULT_DECRYPT_PEM);
-}
+/** Default eth decrypt-key filename the agent looks for in the project root. */
+const DEFAULT_DECRYPT_KEY_FILE = 'reclaim-decrypt.key';
 /**
- * Read the raw decryption-key PEM string from the default file, without loading
- * it. Returns `undefined` when the file is absent (plaintext-only).
+ * Read the raw eth decryption-key hex — from `RECLAIM_DECRYPT_KEY` or the
+ * default file — without loading it. Returns `undefined` when neither is
+ * present (plaintext-only).
  */
-export function resolveDecryptKeyInput(projectDir = findProjectRoot(process.cwd())) {
-    const pemPath = decryptPemPath(projectDir);
-    if (existsSync(pemPath)) {
-        return readFileSync(pemPath, 'utf8');
+function resolveDecryptKeyInput(projectDir = findProjectRoot(process.cwd())) {
+    const fromEnv = process.env.RECLAIM_DECRYPT_KEY?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const keyPath = join(projectDir, DEFAULT_DECRYPT_KEY_FILE);
+    if (existsSync(keyPath)) {
+        return readFileSync(keyPath, 'utf8').trim();
     }
     return undefined;
 }
 /**
- * Load the optional decryption key. Returns `undefined` when the PEM file is
- * absent (the consumer then handles only plaintext deliveries).
+ * Load the optional decryption key. Returns `undefined` when no key is
+ * configured (the consumer then handles only plaintext deliveries).
  */
 export async function resolveDecryptionKey(projectDir = findProjectRoot(process.cwd())) {
     const input = resolveDecryptKeyInput(projectDir);

package/lib/mcp/tools/authenticate/eth-key.d.ts

@@ -13,19 +13,12 @@ export type ResolvedEthKey = {
 };
 /** Validate + normalize a raw Ethereum private key to lowercase 0x-hex. */
 export declare function normalizeEthHex(value: string): string;
-/** The explicit raw-hex key-file path, if `RECLAIM_PRIVATE_KEY_FILE` is set. */
-export declare function ethKeyFilePath(projectDir?: string): string | undefined;
 /**
  * Resolve the eth proof-owner key without prompting. Returns `undefined` when
  * no key is configured anywhere — the caller decides whether to generate or
  * ask for one (see `resolve_owner_key`).
  */
 export declare function resolveEthKey(projectDir?: string): ResolvedEthKey | undefined;
-/**
- * Resolve the eth proof-owner private key (0x-hex) or throw a clear, actionable
- * error. Used by the proof flow that can't proceed without a signing key.
- */
-export declare function requireEthPrivateKey(projectDir?: string): string;
 /**
  * Persist a raw eth private key to the project `.env` as
  * `RECLAIM_PRIVATE_KEY=0x…` (upsert; mode 0600; `.env` added to `.gitignore`).

package/lib/mcp/tools/authenticate/eth-key.js

@@ -12,11 +12,12 @@
  * Generated/imported keys are written to the project `.env` (mode 0600, and the
  * file is added to `.gitignore`). NO `~/.reclaim` caching. This is a LOCAL
  * signing key only — unrelated to org auth (the org secret) or encryption
- * (the X25519 decrypt key).
+ * (the eth decrypt key).
  */
 import { deriveFromPrivateKey } from '@reclaimprotocol/client';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
+import { privateKey, privateKeyFile } from "../../../consts.js";
 import { findProjectRoot } from "../../../paths.js";
 const ENV_VAR = 'RECLAIM_PRIVATE_KEY';
 /** The dotenv file the agent reads from / writes the key to. */
@@ -43,8 +44,8 @@ function readDotenvKey(path) {
     return undefined;
 }
 /** The explicit raw-hex key-file path, if `RECLAIM_PRIVATE_KEY_FILE` is set. */
-export function ethKeyFilePath(projectDir = findProjectRoot(process.cwd())) {
-    const p = process.env.RECLAIM_PRIVATE_KEY_FILE;
+function ethKeyFilePath(projectDir = findProjectRoot(process.cwd())) {
+    const p = privateKeyFile();
     if (!p) {
         return undefined;
     }
@@ -64,7 +65,7 @@ function resolved(privateKey, source, path) {
  * ask for one (see `resolve_owner_key`).
  */
 export function resolveEthKey(projectDir = findProjectRoot(process.cwd())) {
-    const env = process.env.RECLAIM_PRIVATE_KEY;
+    const env = privateKey();
     if (env?.trim()) {
         return resolved(normalizeEthHex(env), 'env');
     }
@@ -79,21 +80,6 @@ export function resolveEthKey(projectDir = findProjectRoot(process.cwd())) {
     }
     return undefined;
 }
-/**
- * Resolve the eth proof-owner private key (0x-hex) or throw a clear, actionable
- * error. Used by the proof flow that can't proceed without a signing key.
- */
-export function requireEthPrivateKey(projectDir = findProjectRoot(process.cwd())) {
-    const r = resolveEthKey(projectDir);
-    if (!r) {
-        throw new Error('No eth proof-owner key found. Set RECLAIM_PRIVATE_KEY (0x-hex), add a '
-            + `RECLAIM_PRIVATE_KEY=0x… line to ${join(projectDir, ENV_FILE)}, or `
-            + 'point RECLAIM_PRIVATE_KEY_FILE at a file holding the raw hex. Run '
-            + 'issue_credentials to generate one, or import_credentials to use a '
-            + 'key you already hold.');
-    }
-    return r.privateKey;
-}
 /** Append `entry` to the project `.gitignore` if not already present. */
 function ensureGitignored(projectDir, entry) {
     const path = join(projectDir, '.gitignore');

package/lib/mcp/tools/authenticate/issue.js

@@ -10,7 +10,7 @@ export function issueTool() {
             '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 X25519 decrypt key). ALWAYS confirm with ' +
+            '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.',