@reclaimprotocol/agent 0.1.22 → 0.1.24

package/lib/provider/injection-doc.d.ts

@@ -1 +1,23 @@
-export declare const INJECTION_GUIDE: string;
+/**
+ * Short field hints for the user-script inputs on both publish tools
+ * (`webSettings.jsUserScripts` on the builder, `customInjection` on
+ * old-devtools).
+ *
+ * These used to inline the whole `skill/injection-api.md` guide (~22 KB) into
+ * the tool's input schema. That guide is needed by a small minority of
+ * providers, but an input-schema description is sent to the model on EVERY
+ * request — it was roughly half the old-devtools tool surface on its own. The
+ * prose now lives in `skill/user-script.md`, `skill/interception.md` and
+ * `skill/hash-validation.md`, served on demand as `how_it_works` topics; what
+ * stays here is the pointer plus the one warning that must be seen BEFORE the
+ * field is filled in, since acting on it wrongly is worse than not acting.
+ *
+ * Shared by both publish tools so the two can't drift apart.
+ */
+/** What the script is and where the real guidance lives. */
+export declare const USER_SCRIPT_HINT: string;
+/** Prefixes the `allowedJsRequests` / `allowedInjectedRequestData` field. The
+ *  trap it describes is silent and total — a mis-declared entry makes
+ *  `verifyProof({ providerId })` reject EVERY real proof — so the warning
+ *  itself stays in the schema even though its explanation moved to a topic. */
+export declare const ALLOWED_REQUESTS_HINT: string;

package/lib/provider/injection-doc.js

@@ -1,24 +1,37 @@
 /**
- * Guidance for authoring page-injection scripts (`webSettings.jsUserScripts` on
- * the builder, `customInjection` on old-devtools), surfaced to the authoring
- * model from the publish tool description. The prose lives in
- * `skill/injection-api.md` so it can be edited as markdown without touching
- * code — the same pattern as `mcp/instructions.ts`. The path resolves the same
- * from `src/provider` (dev) and `lib/provider` (published): both are two levels
- * below the package root.
+ * Short field hints for the user-script inputs on both publish tools
+ * (`webSettings.jsUserScripts` on the builder, `customInjection` on
+ * old-devtools).
  *
- * The guide leads with plain browser JavaScript (navigation/interaction via
- * standard APIs; the client already intercepts page requests) and treats
- * `window.Reclaim` as a rarely-needed edge-case bridge, pointing at the
- * authoritative `src/support/env.d.ts` rather than reproducing its surface.
- * 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. 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.
+ * These used to inline the whole `skill/injection-api.md` guide (~22 KB) into
+ * the tool's input schema. That guide is needed by a small minority of
+ * providers, but an input-schema description is sent to the model on EVERY
+ * request — it was roughly half the old-devtools tool surface on its own. The
+ * prose now lives in `skill/user-script.md`, `skill/interception.md` and
+ * `skill/hash-validation.md`, served on demand as `how_it_works` topics; what
+ * stays here is the pointer plus the one warning that must be seen BEFORE the
+ * field is filled in, since acting on it wrongly is worse than not acting.
+ *
+ * Shared by both publish tools so the two can't drift apart.
  */
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-export const INJECTION_GUIDE = readFileSync(fileURLToPath(new URL('../../skill/injection-api.md', import.meta.url)), 'utf8').trim();
+/** What the script is and where the real guidance lives. */
+export const USER_SCRIPT_HINT = 'Plain JavaScript injected into the provider page before every page load. '
+    + '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. Full guide: how_it_works({ topic: "user-script" }).';
+/** Prefixes the `allowedJsRequests` / `allowedInjectedRequestData` field. The
+ *  trap it describes is silent and total — a mis-declared entry makes
+ *  `verifyProof({ providerId })` reject EVERY real proof — so the warning
+ *  itself stays in the schema even though its explanation moved to a topic. */
+export const ALLOWED_REQUESTS_HINT = '⚠️ Only populate this if you intend to gate '
+    + '`verifyProof(proof, { providerId })`: each entry feeds a client-side '
+    + 'hash-equality check and its `url` is hashed VERBATIM (no regex/template '
+    + 'resolution, even with urlType REGEX/TEMPLATE). If the real captured URL '
+    + 'carries ANY per-session part (nonce, CSRF token, cache-busting '
+    + 'timestamp), no declared spec can ever hash-match a real proof — '
+    + 'populating it then makes verifyProof reject every real proof, which is '
+    + 'worse than leaving it empty. Diff the same endpoint\'s captured URL '
+    + 'across two sessions first. Mechanics, the body-templating rules and the '
+    + 'dangerouslyDisableContentValidation fallback: '
+    + 'how_it_works({ topic: "hash-validation" }).';

package/lib/provider/match-redaction-warning.d.ts

@@ -6,8 +6,8 @@
  * index and may not behave correctly when there are fewer matches than
  * redactions. This is NOT enforced — the author keeps full control over what
  * they publish in either old-devtools or builder mode. The tools surface these
- * strings so the dev can make an informed decision (e.g. add a functional match
- * per redaction) rather than being blocked.
+ * strings so the dev can make an informed decision (for example, add a
+ * functional match per redaction) rather than being blocked.
  */
 /** One request's match/redaction counts, with a human label for the message. */
 export interface RequestCounts {

package/lib/provider/match-redaction-warning.js

@@ -6,8 +6,8 @@
  * index and may not behave correctly when there are fewer matches than
  * redactions. This is NOT enforced — the author keeps full control over what
  * they publish in either old-devtools or builder mode. The tools surface these
- * strings so the dev can make an informed decision (e.g. add a functional match
- * per redaction) rather than being blocked.
+ * strings so the dev can make an informed decision (for example, add a
+ * functional match per redaction) rather than being blocked.
  */
 /** Build advisory warnings for any request with matchCount < redactionCount.
  *  Returns an empty array when everything is fine. */
@@ -17,7 +17,7 @@ export function matchRedactionWarnings(requests) {
         if (req.matchCount < req.redactionCount) {
             warnings.push(`${req.label}: ${req.matchCount} response match(es) but ` +
                 `${req.redactionCount} response redaction(s). Some verification ` +
-                'clients (e.g. the InApp SDK) may not work correctly when ' +
+                'clients (for example, the InApp SDK) may not work correctly when ' +
                 'responseMatches is shorter than responseRedactions — they pair the ' +
                 'two by index. This is allowed; add a functional match per redaction ' +
                 'if you hit verification issues.');

package/lib/provider/matcher.js

@@ -31,7 +31,7 @@ export function synthesizeMatcher(body, contentType, target, paramName, hash) {
         throw new Error('OPRF hashing requires a target with a known-safe character class '
             + '(digits, slug, or email). '
             + `Got "${target}" which is free-form. Use a tighter target `
-            + '(e.g. just the alphanumeric portion of the value) '
+            + '(for example, just the alphanumeric portion of the value) '
             + 'or call propose_provider without `hash`.');
     }
     const valueClass = inferValueClass(target) ?? '[^"<>\\n]+';
@@ -117,18 +117,34 @@ function jsonMatcher(body, target, paramName, valueClass, hash) {
     if (!jsonPath) {
         return undefined;
     }
-    const anchor = jsonKeyPrefix(body, target);
+    const anchor = jsonKeyPrefix(body, target, lastPathKey(jsonPath));
     if (!anchor) {
         return undefined;
     }
     return keyValueResult(anchor.prefix, anchor.close, target, paramName, valueClass, { jsonPath }, hash);
 }
+/** The trailing object-property name of a jsonPath (`$.total_records` →
+ *  `"total_records"`), or undefined for an array-index/bracket leaf, which
+ *  has no literal key to anchor a search on. */
+function lastPathKey(jsonPath) {
+    const m = jsonPath ? /\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonPath) : null;
+    return m?.[1];
+}
 /**
  * The literal `"key":"` (or `"key":` for a raw number/bool) immediately before
  * `target` in `text`, plus the closing quote (`"` for a string value, `''`
  * otherwise). Returns undefined when the value isn't preceded by a JSON key.
+ *
+ * When `key` is given, anchors the search on occurrences of the KEY (not the
+ * value) — so a short/common value elsewhere in the body (for example, the
+ * digit "5" inside `"investment_amount":354.85`) can't be mistaken for this
+ * field. Only falls back to a whole-body value search when there's no
+ * resolvable key (for example, `findJsonPath` returned an array-index leaf).
  */
-function jsonKeyPrefix(text, target) {
+function jsonKeyPrefix(text, target, key) {
+    if (key !== undefined) {
+        return jsonKeyPrefixByKey(text, target, key);
+    }
     const { idx } = firstIndex(text, target);
     if (idx < 0) {
         return undefined;
@@ -157,6 +173,61 @@ function jsonKeyPrefix(text, target) {
     }
     return { prefix: text.slice(keyStart, idx), close: quoted ? '"' : '' };
 }
+/** `jsonKeyPrefix`'s key-anchored path: scan occurrences of `"key"`, and for
+ *  each, check whether the value that follows its `:` matches `target` (or a
+ *  normalized candidate) before accepting it. */
+function jsonKeyPrefixByKey(text, target, key) {
+    const keyToken = `"${key}"`;
+    let from = 0;
+    for (;;) {
+        const keyIdx = text.indexOf(keyToken, from);
+        if (keyIdx < 0) {
+            return undefined;
+        }
+        from = keyIdx + keyToken.length;
+        let i = from;
+        while (i < text.length && /\s/.test(text[i] ?? '')) {
+            i++;
+        }
+        if (text[i] !== ':') {
+            continue;
+        }
+        i++;
+        while (i < text.length && /\s/.test(text[i] ?? '')) {
+            i++;
+        }
+        const matched = matchJsonValueAt(text, i, target);
+        if (matched) {
+            return {
+                prefix: text.slice(keyIdx, matched.valueStart),
+                close: matched.close,
+            };
+        }
+    }
+}
+/** Whether the JSON value starting at `pos` in `text` — quoted string or a
+ *  raw number/bool/null token — equals `target` (or a normalized candidate).
+ *  Returns the position right after any opening quote (matching `firstIndex`'s
+ *  convention) and the delimiter to close the match template with. */
+function matchJsonValueAt(text, pos, target) {
+    const candidates = [target, ...normalizeCandidates(target)];
+    if (text[pos] === '"') {
+        let j = pos + 1;
+        while (j < text.length && text[j] !== '"') {
+            j += text[j] === '\\' ? 2 : 1;
+        }
+        const raw = text.slice(pos + 1, j);
+        return candidates.includes(raw)
+            ? { valueStart: pos + 1, close: '"' }
+            : undefined;
+    }
+    let j = pos;
+    while (j < text.length && !/[,}\]\s]/.test(text[j] ?? '')) {
+        j++;
+    }
+    const raw = text.slice(pos, j);
+    return candidates.includes(raw) ? { valueStart: pos, close: '' } : undefined;
+}
 function findJsonPath(body, target) {
     let parsed;
     try {
@@ -226,7 +297,9 @@ function htmlMatcher(body, target, paramName, valueClass, hash) {
     const scriptJson = scriptJsonContent(revealSlice);
     if (scriptJson) {
         const jsonPath = findJsonPath(scriptJson, target);
-        const kp = jsonPath ? jsonKeyPrefix(scriptJson, target) : undefined;
+        const kp = jsonPath
+            ? jsonKeyPrefix(scriptJson, target, lastPathKey(jsonPath))
+            : undefined;
         if (jsonPath && kp) {
             return keyValueResult(kp.prefix, kp.close, target, paramName, valueClass, { xPath: anchor.xPath, jsonPath }, hash);
         }
@@ -284,9 +357,9 @@ function portableWindow(markup, valueIdx, valueLen) {
 /** Value is element text content. Left anchor: if only punctuation/whitespace
  *  sits between the opening tag and the value, fold the stable opening tag in;
  *  but if WORDS precede the value in the same text node they may be per-user
- *  (e.g. `<li>Full Name ( {{id}} )` — the name), so drop through the last
- *  alphanumeric and keep only the trailing punctuation as the anchor. Right:
- *  include a closing tag, but stop at a sibling. */
+ *  (for example, `<li>Full Name ( {{id}} )` — the name), so drop through the
+ *  last alphanumeric and keep only the trailing punctuation as the anchor.
+ *  Right: include a closing tag, but stop at a sibling. */
 function textWindow(markup, valueIdx, valueEnd, openTagGt) {
     const openTagStart = markup.lastIndexOf('<', openTagGt);
     const openTag = openTagStart >= 0
@@ -396,7 +469,7 @@ function contentMatcher(body, target, paramName, valueClass, hash) {
         return {
             match: {
                 type: 'contains',
-                value: buildContextualTemplate(body, target, paramName),
+                value: buildContextualTemplate(body, target, paramName, valueClass),
             },
             redaction,
             paramValues: { [paramName]: target },
@@ -421,12 +494,47 @@ function contentMatcher(body, target, paramName, valueClass, hash) {
  * must CONTAIN the match template (buildContextualTemplate), so the trailing
  * delimiter is kept unless it's whitespace (which the template also drops).
  */
+/** Indices where `cand` occurs in `body` as a WHOLE match of `valueClass` —
+ * that is, not a substring inside a longer run of the same class (the digit "5"
+ * inside "354.85" is never a whole `\d+` match; "354" and "85" are). Only
+ * meaningful for a structural (non-free-form) class. */
+function wholeTokenIndices(body, cand, valueClass) {
+    const indices = [];
+    let re;
+    try {
+        re = new RegExp(valueClass, 'g');
+    }
+    catch {
+        return indices;
+    }
+    let m;
+    while ((m = re.exec(body))) {
+        if (m[0] === cand) {
+            indices.push(m.index);
+        }
+        if (re.lastIndex === m.index) {
+            re.lastIndex++;
+        }
+    }
+    return indices;
+}
 function buildContentRegex(body, target, paramName, valueClass) {
+    const structural = inferValueClass(target) !== undefined;
     for (const cand of normalizeCandidates(target)) {
-        const idx = body.indexOf(cand);
+        const occurrences = structural
+            ? wholeTokenIndices(body, cand, valueClass)
+            : undefined;
+        const idx = occurrences ? occurrences[0] ?? -1 : body.indexOf(cand);
         if (idx < 0) {
             continue;
         }
+        if (occurrences && occurrences.length > 1
+            && cand.replace(/[^A-Za-z0-9]/g, '').length < 4) {
+            throw new Error(`target value "${target}" occurs ${occurrences.length} times as a `
+                + 'standalone token with no JSON key or HTML anchor to '
+                + "disambiguate — capture a request where it's unique, or use a "
+                + 'longer/more specific target.');
+        }
         const endIdx = idx + cand.length;
         const rawRight = findRightContext(body, endIdx);
         const right = /^\s/.test(rawRight) ? '' : escapeRegexFlexWs(rawRight);
@@ -456,8 +564,9 @@ function buildContentRegex(body, target, paramName, valueClass) {
  * literal contains can't flex whitespace); stable context (a JSON key, an HTML
  * opening tag) is kept so the match anchors on it.
  */
-function buildContextualTemplate(body, target, paramName) {
-    const idx = body.indexOf(target);
+function buildContextualTemplate(body, target, paramName, valueClass) {
+    const idx = wholeTokenIndices(body, target, valueClass)[0]
+        ?? body.indexOf(target);
     if (idx < 0) {
         return `{{${paramName}}}`;
     }
@@ -536,7 +645,8 @@ function inferValueClass(target) {
     if (/^[0-9]+$/.test(target)) {
         return '\\d+';
     }
-    // Numbers with thousands separators / decimals, e.g. "1,908" or "12,345.6".
+    // Numbers with thousands separators / decimals, for example, "1,908" or
+    // "12,345.6".
     if (/^[0-9][0-9,.]*[0-9]$/.test(target)) {
         return '[0-9,.]+';
     }

package/lib/provider/secrets.d.ts

@@ -18,9 +18,9 @@ export declare function splitSecrets(headers: Record<string, string>): {
  *  still visible to the attestor regardless of secret-marking. */
 export declare function secretUrlCharBudget(writeRedactionMode: ReclaimProvider['writeRedactionMode']): number;
 /** A `paramValues`/context key is secret iff its name contains `SECRET`
- *  (case-insensitive) — e.g. `SECRET_apiKey`, `context.SECRET_apiKey`. Same
- *  naming-convention classifier reclaim-inapp-sdk and reclaim-portal use for
- *  their `witnessParams`/`paramValues` maps (no separate boolean flag). */
+ *  (case-insensitive) — for example, `SECRET_apiKey`, `context.SECRET_apiKey`.
+ *  Same naming-convention classifier reclaim-inapp-sdk and reclaim-portal use
+ *  for their `witnessParams`/`paramValues` maps (no separate boolean flag). */
 export declare function classifyParamName(name: string): boolean;
 /** Split a `paramValues` map (bare `{{name}}` / `{{context.<name>}}` entries)
  *  into public (→ `params.paramValues`, revealed to the attestor) and secret

package/lib/provider/secrets.js

@@ -108,9 +108,9 @@ export function secretUrlCharBudget(writeRedactionMode) {
     return writeRedactionMode === 'zk' ? 12 : 2;
 }
 /** A `paramValues`/context key is secret iff its name contains `SECRET`
- *  (case-insensitive) — e.g. `SECRET_apiKey`, `context.SECRET_apiKey`. Same
- *  naming-convention classifier reclaim-inapp-sdk and reclaim-portal use for
- *  their `witnessParams`/`paramValues` maps (no separate boolean flag). */
+ *  (case-insensitive) — for example, `SECRET_apiKey`, `context.SECRET_apiKey`.
+ *  Same naming-convention classifier reclaim-inapp-sdk and reclaim-portal use
+ *  for their `witnessParams`/`paramValues` maps (no separate boolean flag). */
 export function classifyParamName(name) {
     return name.toUpperCase().includes('SECRET');
 }

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

@@ -27,14 +27,14 @@ export interface DraftRequest {
  *  pagination/optionality flags of `RequestSelectionTemplate`. Reuses the
  *  shared `DraftRequest` shape — no provider `name`/`paramValues` required. */
 export interface AllowedJsRequest extends DraftRequest {
-    /** Allow the template to match many requests (e.g. pagination). Default
-     *  true. */
+    /** Allow the template to match many requests (for example, pagination).
+     *  Default true. */
     multiple?: boolean;
     /** Fail validation if no request matches this template. Default true. */
     required?: boolean;
     /** Names of `${var}` placeholders in this template's `responseMatches`/
      *  `responseRedactions` that get substituted at verify time from the
-     *  submitted proof's own witness params (e.g. an index list a
+     *  submitted proof's own witness params (for example, an index list a
      *  `Reclaim.requestClaim` call attached alongside its `{{var}}`
      *  extractions). Omit (or leave empty) when the template has no such
      *  placeholders — verification then matches it literally as-is. */
@@ -54,15 +54,18 @@ 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). */
+    /** In-app interception options, mapped to
+     *  `webSettings.clientOptions.inapp.interceptorOptions` — ONLY when this
+     *  is explicitly passed (builder's schema has no `NONE` interceptorType;
+     *  omitting `inapp` entirely IS the "no interception" signal, so omitting
+     *  this must omit `inapp`, not default it to HAWKEYE). When it IS passed,
+     *  `isDocumentRequestReplayEnabled` defaults to `false` (disabled) unless
+     *  explicitly overridden here — see `providerToCreateVersionRequest`. Only
+     *  meaningful for `HAWKEYE`/`MSWJS`; inert for `CDP`. */
     interceptorOptions?: {
         interceptorType: 'HAWKEYE' | 'MSWJS' | 'CDP';
-        isDocumentRequestReplayEnabled?: boolean;
         interceptorSettings?: string;
+        isDocumentRequestReplayEnabled?: boolean;
     };
 }
 /**

package/lib/provider/to-version.js

@@ -130,14 +130,26 @@ export function providerToCreateVersionRequest(providers, initialUrl, opts = {})
             geoLocation: pickGeoLocation(providers),
             clientOptions: {
                 portal: { useProxy: true },
+                // Builder's schema has NO "NONE" interceptorType — the real
+                // no-interception signal is OMITTING `inapp` entirely (it's not
+                // `required` on `InAppClientOptions`). So `inapp` is only built at
+                // ALL when the author explicitly opts into a real interceptorType;
+                // omitting `interceptorOptions` must omit `inapp` too, or every
+                // standard (non-interception) provider would incorrectly publish
+                // as HAWKEYE. Within that block, `isDocumentRequestReplayEnabled`
+                // defaults to disabled but is author-overridable — see
+                // `CreateVersionOptions.interceptorOptions`'s doc comment.
                 ...(interceptorOptions
                     ? {
                         inapp: {
                             interceptorOptions: {
-                                // openapi `default: false` — the generated type
-                                // requires the key even when the author omits it.
-                                isDocumentRequestReplayEnabled: false,
-                                ...interceptorOptions,
+                                interceptorType: interceptorOptions.interceptorType,
+                                isDocumentRequestReplayEnabled: interceptorOptions.isDocumentRequestReplayEnabled ?? false,
+                                ...(interceptorOptions.interceptorSettings
+                                    ? {
+                                        interceptorSettings: interceptorOptions.interceptorSettings,
+                                    }
+                                    : {}),
                             },
                         },
                     }

package/lib/tools/registry.d.ts

@@ -30,11 +30,11 @@ 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
- * handler. A host maps whichever shared tools it needs through this (e.g. the
- * MCP adds its `captureId` session handle + the credential-aware `run_proof`
- * contract). Args parse loosely, so the extra fields flow through to the
- * handler (its backend resolver reads them); the base tool stays untouched for
- * hosts that don't need them.
+ * handler. A host maps whichever shared tools it needs through this (for
+ * example, the MCP adds its `captureId` session handle + the credential-aware
+ * `run_proof` contract). Args parse loosely, so the extra fields flow through
+ * to the handler (its backend resolver reads them); the base tool stays
+ * untouched for hosts that don't need them.
  */
 export declare function extendTool(tool: RegisteredTool, extra: {
     description?: string;

package/lib/tools/registry.js

@@ -44,11 +44,11 @@ export function errorAsToolText(err) {
 /**
  * Adapt a tool to a host by WIDENING its input schema — add properties, mark
  * some required, optionally override the description — without touching the
- * handler. A host maps whichever shared tools it needs through this (e.g. the
- * MCP adds its `captureId` session handle + the credential-aware `run_proof`
- * contract). Args parse loosely, so the extra fields flow through to the
- * handler (its backend resolver reads them); the base tool stays untouched for
- * hosts that don't need them.
+ * handler. A host maps whichever shared tools it needs through this (for
+ * example, the MCP adds its `captureId` session handle + the credential-aware
+ * `run_proof` contract). Args parse loosely, so the extra fields flow through
+ * to the handler (its backend resolver reads them); the base tool stays
+ * untouched for hosts that don't need them.
  */
 export function extendTool(tool, extra) {
     const base = tool.definition;

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@reclaimprotocol/agent",
 	"title": "Reclaim Agent",
-	"version": "0.1.22",
-	"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.",
+	"version": "0.1.24",
+	"description": "Reclaim Protocol tools for AI coding agents. Reclaim lets your app verify data points about its users, such as a follower count, an account balance, or an order history. This package is the Reclaim MCP server: it gives your agent the tools to find, build, test, and fix data verification providers by capturing and replaying browser requests, drafting provider recipes, running zkTLS proofs, and publishing provider versions.",
 	"type": "module",
 	"main": "./lib/index.js",
 	"types": "./lib/index.d.ts",
@@ -83,10 +83,11 @@
 		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@noble/hashes": "^2.2.0",
 		"@reclaimprotocol/attestor-core": "^5.0.8",
-		"@reclaimprotocol/client": "0.1.22",
+		"@reclaimprotocol/client": "0.1.24",
 		"@reclaimprotocol/tls": "^0.1.3",
 		"chrome-remote-interface": "^0.33.0",
 		"domhandler": "^6.0.0",
+		"openid-client": "^6.8.5",
 		"parse5": "^8.0.0",
 		"parse5-htmlparser2-tree-adapter": "^8.0.0",
 		"pino": "^9.14.0",

package/samples/demo-server/README.md

@@ -6,13 +6,14 @@
    existing app.
 3. Set `PUBLIC_URL` in `.env` to a URL Reclaim's servers can reach — pick
    whichever fits:
-   - **ngrok**: in a separate terminal, run `ngrok http 3000` (install from
-     https://ngrok.com if needed) and copy the
+   - **ngrok**: in a separate terminal, run `ngrok http 3000` (install it
+     from the [ngrok site](https://ngrok.com) if needed) and copy the
      `https://<id>.ngrok-free.app` URL it prints.
-   - **A dev/staging server you can deploy to quickly**: if you already have
-     one reachable from the internet, deploy this there and use its URL
-     instead — no local tunnel needed.
-   This step is REQUIRED — `localhost` is never reachable from Reclaim's
+   - **A development or staging server you can deploy to quickly**: if you
+     already have one reachable from the internet, deploy this there and use
+     its URL instead — no local tunnel needed.
+
+   This step is REQUIRED: `localhost` is never reachable from Reclaim's
    servers.
 4. `npm start`, then open http://localhost:3000/verify (or your deployed
    URL's `/verify`) and click "Start verification".