@reclaimprotocol/agent 0.1.15 → 0.1.18

package/lib/old/to-register.js

@@ -1,5 +1,6 @@
+import assert from 'node:assert';
 /** Default web settings, mirroring the builder openapi defaults
- *  (`ProviderWebSettings.geoLocation`, `PortalClientOptions.useProxy`). The old
+ *  (`ProviderWebSettings.geoLocation`, `PortalClientOptions.useProxy`). The
  *  backend accepts both: `geoLocation` lives on the providerConfig, `useProxy`
  *  is a Provider-level flag (register only). */
 const DEFAULT_GEO_LOCATION = '{{DYNAMIC_GEO}}';
@@ -10,29 +11,29 @@ const DEFAULT_USE_PROXY = true;
  *  entries — a `ReclaimProvider` satisfies it structurally either way. */
 function requestDataFromProvider(provider) {
     const method = String(provider.method).toUpperCase();
-    if (method !== 'GET' && method !== 'POST') {
-        throw new Error('Old devtools supports only GET/POST requests; got ' +
-            `"${provider.method}". Re-capture against a GET/POST endpoint.`);
-    }
-    // The old backend has no dotted interpolation: consumer-supplied params
+    assert(method === 'GET' || method === 'POST', new Error('Devtools supports only GET/POST requests; got ' +
+        `"${provider.method}". Re-capture against a GET/POST endpoint.`));
+    // The devtools backend has no dotted interpolation: consumer-supplied params
     // must use the `{{context_<name>}}` form here, not the builder's
     // `{{context.<name>}}`. Catch the mix-up at publish with a clear error
     // instead of a template that silently never resolves.
     const dotted = `${provider.url}\n${provider.body ?? ''}`
         .match(/\{\{context\.[A-Za-z_][A-Za-z0-9_]*\}\}/);
-    if (dotted) {
-        throw new Error(`Old devtools does not support ${dotted[0]} — rename ` +
-            'consumer-supplied params to the {{context_<name>}} form ' +
-            'for this backend.');
-    }
+    assert(!dotted, new Error(`Devtools does not support ${dotted?.[0]} — rename ` +
+        'consumer-supplied params to the {{context_<name>}} form ' +
+        'for this backend.'));
     const responseMatches = (provider.responseMatches ?? [])
         .map((m, i) => ({
         value: m.value,
         type: m.type ?? 'contains',
-        isOptional: false,
+        // The backend honors isOptional on BOTH register and add-version
+        // (responseMatches pass through verbatim) — forward the author's
+        // flag, default false. (`invert` has no old-backend equivalent and
+        // stays dropped.)
+        isOptional: m.isOptional ?? false,
         order: i,
     }));
-    // Old devtools wants `responseMatches` and `responseRedactions` as PARALLEL
+    // Devtools wants `responseMatches` and `responseRedactions` as PARALLEL
     // arrays — same shape the builder uses, so pass them through directly. We do
     // NOT enforce any match/redaction count relationship here (and never pad —
     // empty placeholder matches break proof generation): the author keeps full
@@ -58,33 +59,35 @@ function requestDataFromProvider(provider) {
     });
     const requestData = {
         url: provider.url,
-        // `{{param}}` placeholders → TEMPLATE so the backend templates them;
-        // otherwise a fixed CONSTANT url. (REGEX is never drafted.)
-        urlType: provider.url.includes('{{') ? 'TEMPLATE' : 'CONSTANT',
+        // Explicit override wins; otherwise `{{param}}` placeholders → TEMPLATE
+        // so the backend templates them, else a fixed CONSTANT url.
+        urlType: provider.urlType
+            ?? (provider.url.includes('{{') ? 'TEMPLATE' : 'CONSTANT'),
         method: method,
         responseMatches,
         responseRedactions,
         // The verification client re-supplies cookies/auth at runtime; secrets
         // are never persisted (propose_provider already stripped them).
-        credentials: 'include',
+        credentials: provider.credentials ?? 'include',
     };
     if (provider.body !== undefined) {
         requestData.bodySniff = { enabled: true, template: provider.body };
     }
-    // NOTE: `responseVariables` is intentionally omitted — the old backend
+    // NOTE: `responseVariables` is intentionally omitted — the devtools backend
     // auto-extracts it from `{{var}}` placeholders in responseMatches. Sending
     // it ourselves would risk drifting from the server's own extraction.
     return requestData;
 }
 /** One `requestData` entry per drafted provider. A multi-request provider
- *  becomes parallel entries that the old backend runs together at verification
- *  (the same way the builder version carries multiple `requests`). */
+ *  becomes parallel entries that the devtools backend runs together at
+ *  verification (the same way the builder version carries multiple
+ *  `requests`). */
 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
+ *  its own `allowedJsRequests`) into the devtools 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. */
@@ -165,6 +168,11 @@ export function providerToConfigBody(providers, opts, version, versionInfo) {
     if (opts.extensionConfig !== undefined) {
         providerConfig.extensionConfig = opts.extensionConfig;
     }
+    // The config (add-version) controller persists providerConfig verbatim,
+    // so this lands as-is; the register controller ignores it entirely.
+    if (opts.disableRequestReplay !== undefined) {
+        providerConfig.disableRequestReplay = opts.disableRequestReplay;
+    }
     return { providerConfig, version, versionInfo };
 }
 /**

package/lib/old/tools/publish.js

@@ -4,6 +4,12 @@ import { INJECTION_GUIDE } from "../../provider/injection-doc.js";
 import { countsFor, matchRedactionWarnings, } from "../../provider/match-redaction-warning.js";
 import { bumpPatchString, extractVersions, injectedRequestDataFrom, providerToConfigBody, providerToRegisterBody, } from "../to-register.js";
 const DEFAULT_VERSION_INFO = 'Updated from MCP browser capture';
+/** Pull the new provider's id out of a register response, tolerant of the
+ *  envelope (`{providerId}`, `{provider:{providerId}}`, `{id}`). */
+function extractProviderId(resp) {
+    const obj = resp;
+    return obj?.providerId ?? obj?.provider?.providerId ?? obj?.id;
+}
 /**
  * The old backend lets you add a version only to a provider YOU own. A
  * `providerId` for a public provider (or anyone else's) comes back as
@@ -44,7 +50,7 @@ function rethrowOwnershipError(err, providerId) {
 export function createVersionFromCaptureTool(client) {
     return defineTool({
         name: 'create_provider_version_from_capture',
-        description: 'Publish drafted ReclaimProvider(s) to the OLD devtools backend. ' +
+        description: 'Publish drafted ReclaimProvider(s) to the devtools backend. ' +
             'Pass the `provider` object from propose_provider VERBATIM and the ' +
             '`initialUrl` the user landed on (the login/landing page, NOT the ' +
             'API url). \n\n' +
@@ -62,7 +68,7 @@ export function createVersionFromCaptureTool(client) {
             "PUBLIC provider you don't own, omit `providerId` to register your " +
             'own copy (you cannot edit someone else\'s provider here). \n\n' +
             'For data gated behind login/navigation, pass `customInjection` — a ' +
-            'page-injection script (old-devtools\' name for the builder\'s ' +
+            'page-injection script (the devtools name for the builder\'s ' +
             'jsUserScripts) that drives the page to where the request fires. \n\n' +
             'BY DESIGN, this backend only ever CREATES A NEW VERSION (POST) — ' +
             'there is no partial-patch/edit endpoint, and this tool does NOT ' +
@@ -79,7 +85,14 @@ export function createVersionFromCaptureTool(client) {
             'values plus your change) back into this call. ' +
             '`allowedInjectedRequestData`/`useIncognitoWebview`/' +
             '`extensionConfig` only take effect on add-version — the register ' +
-            'endpoint (no `providerId`) ignores them. \n\n' +
+            'endpoint (no `providerId`) ignores them. `disableRequestReplay` ' +
+            'is also add-version-only, but when it is true the tool follows ' +
+            'a register up with an add-version call automatically so it takes ' +
+            'effect on new providers too. Per-request fields you may set on ' +
+            '`provider`/`providers`: `credentials` (omit/same-origin/include, ' +
+            'default include), `urlType` (REGEX/CONSTANT/TEMPLATE, default ' +
+            'derived from {{placeholders}}), and `isOptional` on each ' +
+            'responseMatch (default false). \n\n' +
             'Captured requests must be GET/POST. OPRF redactions are supported.',
         inputSchema: {
             type: 'object',
@@ -94,6 +107,19 @@ export function createVersionFromCaptureTool(client) {
                         method: { type: 'string' },
                         headers: { type: 'object' },
                         body: { type: 'string' },
+                        credentials: {
+                            type: 'string',
+                            enum: ['omit', 'same-origin', 'include'],
+                            description: 'How the verification client supplies cookies/auth ' +
+                                'when replaying this request. Default `include`.',
+                        },
+                        urlType: {
+                            type: 'string',
+                            enum: ['REGEX', 'CONSTANT', 'TEMPLATE'],
+                            description: 'How the backend treats the URL. Default derived: ' +
+                                'TEMPLATE when the URL has {{placeholders}}, else ' +
+                                'CONSTANT.',
+                        },
                         responseMatches: { type: 'array' },
                         responseRedactions: { type: 'array' },
                         paramValues: { type: 'object' },
@@ -122,6 +148,14 @@ export function createVersionFromCaptureTool(client) {
                             method: { type: 'string' },
                             headers: { type: 'object' },
                             body: { type: 'string' },
+                            credentials: {
+                                type: 'string',
+                                enum: ['omit', 'same-origin', 'include'],
+                            },
+                            urlType: {
+                                type: 'string',
+                                enum: ['REGEX', 'CONSTANT', 'TEMPLATE'],
+                            },
                             responseMatches: { type: 'array' },
                             responseRedactions: { type: 'array' },
                             paramValues: { type: 'object' },
@@ -202,6 +236,13 @@ export function createVersionFromCaptureTool(client) {
                         properties: {
                             url: { type: 'string' },
                             method: { type: 'string' },
+                            urlType: {
+                                type: 'string',
+                                enum: ['REGEX', 'CONSTANT', 'TEMPLATE'],
+                                description: 'How the backend treats this URL. Default derived ' +
+                                    'from {{placeholders}} (TEMPLATE) like a normal ' +
+                                    'request entry.',
+                            },
                             body: {
                                 type: 'string',
                                 description: 'Becomes `bodySniff: { enabled: true, template: <this ' +
@@ -315,6 +356,14 @@ export function createVersionFromCaptureTool(client) {
                     description: 'Free-form JSON passed through to the client. Add-version ' +
                         'ONLY.',
                 },
+                disableRequestReplay: {
+                    type: 'boolean',
+                    description: 'Skip replaying the main document request (HAWKEYE ' +
+                        'provider-level flag). Honored on add-version; for a ' +
+                        'provider (no `providerId`) the register endpoint ignores ' +
+                        'it, so when true the tool automatically follows the ' +
+                        'register up with an add-version call that applies it.',
+                },
             },
             required: ['initialUrl'],
         },
@@ -348,6 +397,7 @@ export function createVersionFromCaptureTool(client) {
             stepsToFollow: args.stepsToFollow,
             useIncognitoWebview: args.useIncognitoWebview,
             extensionConfig: args.extensionConfig,
+            disableRequestReplay: args.disableRequestReplay,
             allowedInjectedRequestData: args.allowedInjectedRequestData
                 ? injectedRequestDataFrom(args.allowedInjectedRequestData)
                 : undefined
@@ -372,6 +422,11 @@ export function createVersionFromCaptureTool(client) {
                     'every page load (before navigating to initialUrl), matching ' +
                     'the builder\'s jsUserScripts.');
             }
+            // disableRequestReplay is honored ONLY on add-version, so a
+            // register can't set it — when true we immediately follow the
+            // register with an add-version call (which also lands any other
+            // register-ignored fields).
+            const followUp = args.disableRequestReplay === true;
             const REGISTER_IGNORED_KEYS = [
                 'allowedInjectedRequestData',
                 'useIncognitoWebview',
@@ -382,13 +437,36 @@ export function createVersionFromCaptureTool(client) {
             if (ignoredOnRegister.length) {
                 notes.push(`${ignoredOnRegister.join(', ')} ` +
                     `${ignoredOnRegister.length > 1 ? 'are' : 'is'} ` +
-                    'ignored on register (no providerId) — the old backend only ' +
-                    'reads them when adding a version. Publish once to create ' +
-                    'the provider, then call this again WITH the returned ' +
-                    'providerId to set them.');
+                    'ignored on register (no providerId) — the devtools backend only ' +
+                    'reads them when adding a version. ' +
+                    (followUp
+                        ? 'They were applied by the follow-up version the tool ' +
+                            'created to set disableRequestReplay.'
+                        : 'Publish once to create the provider, then call this ' +
+                            'again WITH the returned providerId to set them.'));
             }
             const body = providerToRegisterBody(providers, opts);
-            return withNotes(await client.registerProvider(body));
+            const registered = await client.registerProvider(body);
+            if (followUp) {
+                const newProviderId = extractProviderId(registered);
+                if (newProviderId) {
+                    const versionsResp = await client.listVersions(newProviderId);
+                    const followVersion = bumpPatchString(extractVersions(versionsResp));
+                    const configBody = providerToConfigBody(providers, { ...opts, disableRequestReplay: true }, followVersion, DEFAULT_VERSION_INFO);
+                    await client.updateProviderConfig(newProviderId, configBody);
+                    notes.push('disableRequestReplay is ignored by the register endpoint — ' +
+                        `applied it via a follow-up version (${followVersion}) on ` +
+                        'the new provider, which also lands any register-ignored ' +
+                        'fields you passed.');
+                }
+                else {
+                    notes.push('Could not apply disableRequestReplay: the register ' +
+                        'response did not include the new providerId. Call this ' +
+                        'tool again WITH `providerId` and `disableRequestReplay: ' +
+                        'true` to set it.');
+                }
+            }
+            return withNotes(registered);
         }
         // New version of an existing provider — pick the next patch above
         // the highest existing version. A provider you don't own (e.g. a

package/lib/provider/injection-doc.js

@@ -14,9 +14,10 @@
  * It also covers the HAWKEYE-style live-interception path (`injectionType` /
  * `interceptorType`, `disableRequestReplay` / `isDocumentRequestReplayEnabled`)
  * and `bodySniff`, reverse-engineered from the old-devtools Prisma schema,
- * controller code, and dashboard field hints — neither publish tool exposes
- * these as inputs (both only build the standard replay flow), so this is
- * read-the-field-and-recognize-it documentation, not authoring guidance.
+ * controller code, and dashboard field hints. The replay flag IS settable via
+ * the publish tools (`disableRequestReplay` on old-devtools — add-version or
+ * the register follow-up; `interceptorOptions` on the builder), so this is
+ * recognition + authoring guidance for the remaining internals.
  */
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';

package/lib/provider/schema.d.ts

@@ -11,6 +11,24 @@ export type HttpMethod = HttpParams['method'];
  * jsonPath/xPath belong on the redaction, not here.
  */
 export type ResponseMatch = HttpParams['responseMatches'][number];
+/**
+ * A response match as drafted for PUBLISH: the attestor's match plus
+ * `isOptional` — a backend-side matcher flag (both the old devtools backend
+ * and the builder store it; the attestor's own params have no such field, so
+ * `propose_provider` drafts never set it — only an explicit publish input
+ * does). Default false on both backends.
+ */
+export type DraftResponseMatch = ResponseMatch & {
+    isOptional?: boolean;
+};
+/** How the verification client supplies cookies/auth when replaying a
+ *  request. Both backends accept the same enum (old devtools on
+ *  `requestData`, builder on `RequestSelection`); default `include`. */
+export type WebCredentials = 'omit' | 'same-origin' | 'include';
+/** Old-devtools `urlType` for a requestData entry. The builder backend has
+ *  no such field (templating is implicit in the URL's `{{param}}`
+ *  placeholders), so the builder translator ignores it. */
+export type OldUrlType = 'REGEX' | 'CONSTANT' | 'TEMPLATE';
 /**
  * Selector telling the prover which portion of the response to reveal:
  * `xPath`/`jsonPath` narrows the slice, `regex` (with named groups) matches
@@ -59,8 +77,15 @@ export interface ReclaimProvider {
     method: HttpMethod;
     headers?: Record<string, string>;
     body?: string;
-    responseMatches: ResponseMatch[];
+    responseMatches: DraftResponseMatch[];
     responseRedactions?: ResponseRedaction[];
+    /** How the verification client supplies cookies/auth on replay. Both
+     *  backends default to `include` when unset. */
+    credentials?: WebCredentials;
+    /** Old-devtools-only url type override (`REGEX`/`CONSTANT`/`TEMPLATE`).
+     *  Auto-derived from `{{param}}` placeholders when unset; ignored by the
+     *  builder backend. */
+    urlType?: OldUrlType;
     /** Public param refs (templated into URL/body), populated by draft layer. */
     paramValues?: Record<string, string>;
     /** Redaction mode for the transcript (attestor default: 'key-update'). */

package/lib/provider/to-version.d.ts

@@ -1,6 +1,6 @@
 import type { ReclaimClient } from '@reclaimprotocol/client';
 import type { CreateProviderVersionRequest, ProviderVersionRef } from '@reclaimprotocol/client/openapi';
-import type { HttpMethod, ReclaimProvider, ResponseMatch, ResponseRedaction } from './schema.ts';
+import type { DraftResponseMatch, HttpMethod, OldUrlType, ReclaimProvider, ResponseRedaction, WebCredentials } from './schema.ts';
 /** One entry of the version's `requests[]` (a `RequestSelection`), derived
  *  from the openapi type so it can't drift from what the server accepts. */
 type RequestSelection = CreateProviderVersionRequest['requests'][number];
@@ -13,8 +13,15 @@ export interface DraftRequest {
     body?: string;
     writeRedactionMode?: ReclaimProvider['writeRedactionMode'];
     additionalClientOptions?: ReclaimProvider['additionalClientOptions'];
-    responseMatches?: ResponseMatch[];
+    responseMatches?: DraftResponseMatch[];
     responseRedactions?: ResponseRedaction[];
+    /** How the verification client supplies cookies/auth on replay. Default
+     *  `include` (both backends). */
+    credentials?: WebCredentials;
+    /** Old-devtools `urlType` override. Ignored by THIS translator (the
+     *  builder backend has no urlType) — read only by the old-devtools
+     *  translator (`old/to-register.ts`). */
+    urlType?: OldUrlType;
 }
 /** A request the page's injection script is allowed to fire, plus the
  *  pagination/optionality flags of `RequestSelectionTemplate`. Reuses the
@@ -47,6 +54,16 @@ export interface CreateVersionOptions {
     jsUserScripts?: string;
     /** Requests the injection script may fire, as `RequestSelectionTemplate`s. */
     allowedJsRequests?: AllowedJsRequest[];
+    /** In-app interception options, mapped verbatim to
+     *  `webSettings.clientOptions.inapp.interceptorOptions`. `interceptorType`
+     *  is required by the backend whenever the object is present.
+     *  `isDocumentRequestReplayEnabled` is the INVERSE of old-devtools'
+     *  `disableRequestReplay` (default false). */
+    interceptorOptions?: {
+        interceptorType: 'HAWKEYE' | 'MSWJS' | 'CDP';
+        isDocumentRequestReplayEnabled?: boolean;
+        interceptorSettings?: string;
+    };
 }
 /**
  * Derive the version's `requiredContext` JSON Schema from the

package/lib/provider/to-version.js

@@ -61,13 +61,13 @@ export function providerToRequestSelection(provider) {
     const responseMatches = (provider.responseMatches ?? []).map((match) => ({
         type: match.type,
         value: match.value,
-        isOptional: false,
+        isOptional: match.isOptional ?? false,
     }));
     const responseRedactions = provider.responseRedactions ?? [];
     return {
         url: provider.url,
         method: provider.method,
-        credentials: 'include',
+        credentials: provider.credentials ?? 'include',
         ...(provider.body ? { requestBodyTemplate: provider.body } : {}),
         ...(provider.writeRedactionMode
             ? { writeRedactionMode: provider.writeRedactionMode }
@@ -91,7 +91,7 @@ function pickGeoLocation(providers) {
     return DYNAMIC_GEO;
 }
 export function providerToCreateVersionRequest(providers, initialUrl, opts = {}) {
-    const { notes, version, jsUserScripts, allowedJsRequests } = opts;
+    const { notes, version, jsUserScripts, allowedJsRequests, interceptorOptions, } = opts;
     const requiredContext = deriveRequiredContext(providers, {
         allowedJsRequests,
         jsUserScripts,
@@ -102,6 +102,10 @@ export function providerToCreateVersionRequest(providers, initialUrl, opts = {})
         ...providerToRequestSelection(req),
         multiple: req.multiple ?? true,
         required: req.required ?? true,
+        templateParamsMode: req.templateParamsMode ?? 'separate',
+        ...(req.templateParams?.length
+            ? { templateParams: req.templateParams }
+            : {}),
     }));
     const script = jsUserScripts?.trim();
     return {
@@ -114,7 +118,21 @@ export function providerToCreateVersionRequest(providers, initialUrl, opts = {})
         // apply schema defaults to request bodies.
         webSettings: {
             geoLocation: pickGeoLocation(providers),
-            clientOptions: { portal: { useProxy: true } },
+            clientOptions: {
+                portal: { useProxy: true },
+                ...(interceptorOptions
+                    ? {
+                        inapp: {
+                            interceptorOptions: {
+                                // openapi `default: false` — the generated type
+                                // requires the key even when the author omits it.
+                                isDocumentRequestReplayEnabled: false,
+                                ...interceptorOptions,
+                            },
+                        },
+                    }
+                    : {}),
+            },
             // Only set when non-empty; an empty string would store a no-op script.
             ...(script ? { jsUserScripts: script } : {}),
         },

package/lib/tools/registry.d.ts

@@ -1,16 +1,3 @@
-/**
- * The ONE tool primitive for the agent. A tool is authored once with
- * {@link defineTool} — `{ definition, handler }`, where the handler receives
- * args already parsed + validated against the definition's JSON Schema (via
- * zod), so the schema shown to the model and the validation applied to inbound
- * args cannot drift.
- *
- * This lives outside `mcp/` on purpose: it depends only on zod (NOT the MCP
- * SDK), so non-MCP consumers — the cloud authoring loop — can author and run
- * these tools without pulling in `@modelcontextprotocol/sdk`. The MCP-specific
- * glue (`registerToolList` onto an `McpServer`) stays in `mcp/server.ts`, which
- * re-exports this primitive for the MCP-side tool files.
- */
 import type { JSONSchema } from 'zod/v4/core';
 export interface ToolDefinition {
     name: string;
@@ -34,6 +21,12 @@ export interface RegisteredTool {
  * and the validation applied to inbound args cannot drift.
  */
 export declare function defineTool<TArgs>(definition: ToolDefinition, handler: (args: TArgs) => Promise<unknown>): RegisteredTool;
+/**
+ * Render a tool-handler error as the text every host shows the LLM.
+ * Boom errors carrying an RFC 9457 problem include its `detail`; anything
+ * else falls back to the plain message.
+ */
+export declare function errorAsToolText(err: unknown): string;
 /**
  * Adapt a tool to a host by WIDENING its input schema — add properties, mark
  * some required, optionally override the description — without touching the

package/lib/tools/registry.js

@@ -1,3 +1,17 @@
+/**
+ * The ONE tool primitive for the agent. A tool is authored once with
+ * {@link defineTool} — `{ definition, handler }`, where the handler receives
+ * args already parsed + validated against the definition's JSON Schema (via
+ * zod), so the schema shown to the model and the validation applied to inbound
+ * args cannot drift.
+ *
+ * This lives outside `mcp/` on purpose: it depends only on zod (NOT the MCP
+ * SDK), so non-MCP consumers — the cloud authoring loop — can author and run
+ * these tools without pulling in `@modelcontextprotocol/sdk`. The MCP-specific
+ * glue (`registerToolList` onto an `McpServer`) stays in `mcp/server.ts`, which
+ * re-exports this primitive for the MCP-side tool files.
+ */
+import { isBoom } from '@hapi/boom';
 import { toZod } from "../mcp/api/to-zod.js";
 /**
  * Define a tool with a single inputSchema (JSON Schema) as the source of truth.
@@ -15,6 +29,18 @@ export function defineTool(definition, handler) {
         },
     };
 }
+/**
+ * Render a tool-handler error as the text every host shows the LLM.
+ * Boom errors carrying an RFC 9457 problem include its `detail`; anything
+ * else falls back to the plain message.
+ */
+export function errorAsToolText(err) {
+    if (isBoom(err) && err.output?.statusCode) {
+        const detail = err.data?.detail;
+        return detail ? `${err.message}: ${detail}` : err.message;
+    }
+    return err instanceof Error ? err.message : String(err);
+}
 /**
  * Adapt a tool to a host by WIDENING its input schema — add properties, mark
  * some required, optionally override the description — without touching the
@@ -30,6 +56,9 @@ export function extendTool(tool, extra) {
         ...(base.inputSchema.required ?? []),
         ...(extra.required ?? []),
     ];
+    // The merged `properties` spread carries the base's untyped property values,
+    // which don't structurally match ObjectSchema's strict per-property schema
+    // type — assert the merged shape.
     const inputSchema = {
         ...base.inputSchema,
         properties: {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@reclaimprotocol/agent",
 	"title": "Reclaim Agent",
-	"version": "0.1.15",
+	"version": "0.1.18",
 	"description": "Reclaim Protocol's tools for agents — Reclaim Protocol lets your app verify **data points** about its users — a follower count, an account balance, an order history. This package gives your AI coding agent the tools to **find, build, test and fix the _data verification providers_** (the recipes that verify a data point) by inspecting and replaying captured requests, checking sessions, evaluate proofs, publishing updates, and much more.",
 	"type": "module",
 	"main": "./lib/index.js",
@@ -33,7 +33,6 @@
 		}
 	},
 	"bin": {
-		"reclaim": "./lib/cli.js",
 		"reclaim-mcp-server": "./lib/mcp-bin.js"
 	},
 	"files": [
@@ -45,7 +44,7 @@
 		"README.md"
 	],
 	"engines": {
-		"node": ">=20"
+		"node": ">=22.0.0"
 	},
 	"repository": {
 		"url": "https://github.com/reclaimprotocol/builder",
@@ -53,12 +52,11 @@
 	},
 	"websiteUrl": "https://docs.reclaimprotocol.org",
 	"scripts": {
-		"build": "tsc && node scripts/prepend-shebang.js && chmod 755 lib/cli.js lib/mcp-bin.js",
+		"build": "tsc && node scripts/prepend-shebang.js && chmod 755 lib/mcp-bin.js",
 		"prepublishOnly": "npm run build",
 		"dev": "tsc --watch",
-		"test": "node --env-file=.test.env --test tests/*.test.ts",
+		"test": "node --env-file=.test.env --test-timeout=120000 --test tests/*.test.ts",
 		"check": "tsc -p tsconfig.test.json",
-		"start:cli": "node lib/cli.js",
 		"start:mcp": "node lib/mcp-bin.js",
 		"inspect": "npx @modelcontextprotocol/inspector node lib/mcp-bin.js",
 		"download:zk-files": "node scripts/download-zk-files.js"
@@ -67,7 +65,6 @@
 		"mcp",
 		"model-context-protocol",
 		"sdk",
-		"cli",
 		"ai",
 		"agent",
 		"chrome-devtools-protocol",
@@ -86,7 +83,7 @@
 		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@noble/hashes": "^2.2.0",
 		"@reclaimprotocol/attestor-core": "^5.0.8",
-		"@reclaimprotocol/client": "0.1.15",
+		"@reclaimprotocol/client": "0.1.18",
 		"@reclaimprotocol/tls": "^0.1.3",
 		"chrome-remote-interface": "^0.33.0",
 		"domhandler": "^6.0.0",

package/scripts/prepend-shebang.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url'
 
 const SHEBANG = '#!/usr/bin/env node\n'
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
-const BIN_FILES = ['cli.js', 'mcp-bin.js']
+const BIN_FILES = ['mcp-bin.js']
 
 for(const file of BIN_FILES) {
 	const path = join(ROOT, 'lib', file)

package/skill/builder-mode.md

@@ -13,3 +13,5 @@ This server targets the Reclaim BUILDER backend. It exposes three tool layers: g
 **Discover & resolve (find providers for the user's app):** when a dev wants to add verification but doesn't know which providers to use, run the same flow the Discover UI does. Ask which website their users prove data from, then `discover_data_points({ domain })` to list what's verifiable there. Confirm the data points with the dev, then `discover_resolve({ domain, dataPoints })` → the smallest provider set (`providers`, greedy combine), the `requiredContext` inputs to collect from the dev, and any `uncovered` points (author those with the provider-authoring flow above, then re-resolve). Create the session with `create_verification_session({ providers: [{ providerId }, …], context, verificationClientUrl })`, passing EVERY resolved provider id and the collected context. `merge.mergeable` only signals the set could collapse into one provider — you still pass them all; the Builder runs them in one session.
 
 **Verification sessions:** consumers authenticate with a per-org token (`rorg_…`, issued in the dashboard via `POST /orgs/{orgId}/token`) and create sessions via `POST /verifications/sessions`. Results are ECIES-encrypted (secp256k1 + AES-256-GCM) to the org's eth public key when its `canEncryptResult` is enabled — set via `PUT /orgs/{orgId}/keypair` with an eth public key — and delivered to the org's callback subscriptions (plaintext otherwise). Use the org/session tools (`get_verification_session`, `list_verification_events`, `list_org_verification_sessions`) to troubleshoot.
+
+**Backend mode:** this server can alternatively run against the devtools backend with a reduced tool set (no generated API tools, no orgs/review flows). `get_devtools_mode` reports the active mode and why it's in effect; `set_devtools_mode` persists a switch to `~/.reclaim/config.json` — it takes effect on the NEXT server start (restart/reconnect), and an explicit `USE_OLD_DEVTOOLS` env var overrides the persisted choice.

package/skill/old-mode.md

@@ -1,4 +1,4 @@
-This server is running against the LEGACY Reclaim devtools backend (temporary, while the new builder backend is in development), so its capabilities are intentionally limited.
+This server is running against the devtools backend, so its capabilities are intentionally limited.
 
 **Provider-authoring flow:**
 
@@ -15,3 +15,5 @@ Only GET/POST endpoints can be captured into providers here. There is no organiz
 **Diagnosing a session:** `session_analytics_logs` fetches the analytics logs for a verification session by id (from the logs service) — use it to see what happened in a session (matches, claims, failures).
 
 **Templating:** bare `{{name}}` placeholders are provider params (values extracted from the response). Values the CONSUMER must supply at verification time (e.g. a username in the URL path) use the `{{context_<name>}}` form — this backend does not support the dotted `{{context.<name>}}` interpolation the new builder uses.
+
+**Backend mode:** this is the reduced devtools surface — the BUILDER backend (generated API tools, orgs, verification sessions, public review) is one switch away. `get_devtools_mode` reports the active mode and why it's in effect; `set_devtools_mode` persists a switch to `~/.reclaim/config.json` — it takes effect on the NEXT server start (restart/reconnect), and an explicit `USE_OLD_DEVTOOLS` env var overrides the persisted choice.

package/src/authoring/index.ts

@@ -14,6 +14,7 @@ export { authoringTools } from './tools.ts'
 // subsystem.
 export {
 	defineTool,
+	errorAsToolText,
 	extendTool,
 	type RegisteredTool,
 	type ToolDefinition,

package/src/authoring/util.ts

@@ -21,6 +21,9 @@ export function objectSchema(
 	properties: Record<string, unknown>,
 	required?: string[],
 ): JSONSchema.ObjectSchema {
+	// `properties` is an untyped Record here (this is a literal shortener, not a
+	// schema validator), so it doesn't structurally match ObjectSchema's strict
+	// per-property schema type — assert the shape.
 	return {
 		type: 'object',
 		properties,

package/src/cdp/launcher.ts

@@ -113,7 +113,7 @@ export function launchChrome(opts: LaunchOptions): ChildProcess {
 export async function waitForCdpReady(
 	port: number,
 	timeoutMs = 10_000,
-): Promise<void> {
+) {
 	const deadline = Date.now() + timeoutMs
 	while(Date.now() < deadline) {
 		try {