@reclaimprotocol/agent 0.1.10 → 0.1.11

package/lib/authoring/tools.js

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

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

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

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

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

package/lib/old/client.d.ts

@@ -99,11 +99,6 @@ export declare class ReclaimOldClient {
     registerProvider(body: RegisterProviderBody): Promise<unknown>;
     updateProviderConfig(providerId: string, body: UpdateProviderConfigBody): Promise<unknown>;
     listVersions(providerId: string): Promise<unknown>;
-    /** Full `providerConfig` (loginUrl, customInjection, requestData, ...) for
-     *  one version — the latest when `version` is omitted. Readable for ANY
-     *  non-archived provider (not owner-restricted), same as the dashboard's
-     *  edit-form prefill fetch. */
-    getProviderConfig(providerId: string, version?: string): Promise<unknown>;
     /** Partial update on the PROVIDER document itself — name/description/
      *  providerType/tags/isActive, after creation. The backend 403s if you
      *  don't own the provider (and aren't admin); other providerConfig-style

package/lib/old/client.js

@@ -60,16 +60,6 @@ export class ReclaimOldClient {
     listVersions(providerId) {
         return __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, 'GET', `/providers/${encodeURIComponent(providerId)}/versions`, { auth: true });
     }
-    /** Full `providerConfig` (loginUrl, customInjection, requestData, ...) for
-     *  one version — the latest when `version` is omitted. Readable for ANY
-     *  non-archived provider (not owner-restricted), same as the dashboard's
-     *  edit-form prefill fetch. */
-    getProviderConfig(providerId, version) {
-        return __classPrivateFieldGet(this, _ReclaimOldClient_instances, "m", _ReclaimOldClient_request).call(this, 'GET', `/providers/${encodeURIComponent(providerId)}/config`, {
-            auth: true,
-            query: version ? { versionNumber: version } : undefined,
-        });
-    }
     /** Partial update on the PROVIDER document itself — name/description/
      *  providerType/tags/isActive, after creation. The backend 403s if you
      *  don't own the provider (and aren't admin); other providerConfig-style

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

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

package/lib/old/to-register.js

@@ -89,11 +89,15 @@ function requestDataFrom(providers) {
  *  this shape and should be passed straight through instead — don't run it
  *  through this a second time. */
 export function injectedRequestDataFrom(requests) {
-    return requests.map((req) => ({
-        ...requestDataFromProvider(req),
-        required: req.required ?? true,
-        multiple: req.multiple ?? true,
-    }));
+    return requests.map((req) => {
+        return {
+            ...requestDataFromProvider(req),
+            required: req.required ?? true,
+            multiple: req.multiple ?? true,
+            templateParams: req.templateParams,
+            templateParamsMode: req.templateParamsMode,
+        };
+    });
 }
 /** Body for `POST /api/providers/register` — new provider + v1.0.0. Every
  *  drafted request becomes a `requestData` entry; provider-level fields (name)

package/lib/old/tools/build.js

@@ -1,6 +1,5 @@
 import { authenticateTool } from "./authenticate.js";
 import { getProviderInfoTool } from "./get-provider-info.js";
-import { getProviderVersionConfigTool } from "./get-version-config.js";
 import { getMeProvidersTool } from "./me-providers.js";
 import { createVersionFromCaptureTool } from "./publish.js";
 import { sessionAnalyticsLogsTool } from "./session-analytics-logs.js";
@@ -20,7 +19,6 @@ export function buildOldBackendTools(client, sdkClient) {
         authenticateTool(client),
         createVersionFromCaptureTool(client),
         getMeProvidersTool(client),
-        getProviderVersionConfigTool(client),
         getProviderInfoTool(sdkClient),
         updateProviderMetadataTool(client),
         sessionAnalyticsLogsTool(client),

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

@@ -1,14 +1,17 @@
 import { type RegisteredTool } from '../../mcp/server.ts';
 import type { ReclaimSdkClient } from '../sdk-client.ts';
 /**
- * Read provider info from the PUBLIC production SDK backend
- * (`api.reclaimprotocol.org`) — the service the verification SDK/attestor
- * itself calls at runtime, NOT the old-devtools dashboard backend
- * (`get_provider_version_config`, `devapi.reclaimprotocol.org`, requires
- * auth). Both underlying reads are unauthenticated.
+ * The single provider-read tool for old-devtools mode. Reads from the PUBLIC
+ * production SDK backend (`api.reclaimprotocol.org`) — the service the
+ * verification SDK/attestor itself calls at runtime. No auth required, works
+ * for ANY provider.
  *
- * Fetches BOTH shapes in one call, since they're complementary:
- *   - `provider`: full provider + providerConfig, `customInjection` included.
+ * Fetches BOTH shapes in one call, since they're complementary and together
+ * cover everything a caller needs before re-publishing a new version:
+ *   - `provider`: the full provider + providerConfig — `customInjection`,
+ *     `userAgent`, `allowedInjectedRequestData`, `requestData`, everything.
+ *     This is what you read before create_provider_version_from_capture so
+ *     you can pass the whole config back (that tool carries nothing forward).
  *   - `configs`: the trimmed runtime recipe the attestor actually consumes —
  *     `customInjection` deliberately omitted, `isScriptRequestingClaim`
  *     computed instead.

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

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

package/lib/old/tools/publish.js

@@ -4,53 +4,6 @@ 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';
-/** Fields with no partial-patch equivalent on this backend: a version always
- *  replaces the WHOLE `providerConfig`, so omitting one of these on
- *  add-version must carry forward the current value rather than publish it
- *  blank. `allowedInjectedRequestData` is handled alongside these (further
- *  down, inline) since it needs translation when freshly authored, unlike
- *  these — which pass through unchanged either way. */
-const PRESERVABLE_KEYS = [
-    'customInjection',
-    'userAgent',
-    'pageTitle',
-    'stepsToFollow',
-    'useIncognitoWebview',
-    'extensionConfig',
-];
-/** Pull `providerConfig` out of a `get_provider_version_config` /
- *  `getProviderConfig` response, tolerant of a missing/malformed shape. */
-function extractProviderConfig(resp) {
-    if (resp && typeof resp === 'object') {
-        const cfg = resp.providerConfig;
-        if (cfg && typeof cfg === 'object') {
-            return cfg;
-        }
-    }
-    return undefined;
-}
-/** Prefer the caller's explicit value; otherwise fall back to `current`'s
- *  value (if any) and record `fieldName` as carried forward.
- *
- *  `current === null` is treated the SAME as `undefined` (nothing to carry),
- *  not as a real value to preserve. These are all optional fields with no
- *  Prisma default — a version where one was never set reads back as
- *  `null`, not a missing key, because Prisma normalizes an absent optional
- *  field to `null` on read. Carrying that `null` "forward" would falsely
- *  claim the field was preserved when really nothing was ever there — it
- *  most likely means an EARLIER version already lost it (e.g. published
- *  before this field had carry-forward support at all), not that this call
- *  is doing anything wrong. */
-function resolveField(explicit, current, fieldName, carried) {
-    if (explicit !== undefined) {
-        return explicit;
-    }
-    if (current !== undefined && current !== null) {
-        carried.push(fieldName);
-        return current;
-    }
-    return undefined;
-}
 /**
  * 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
@@ -111,23 +64,19 @@ export function createVersionFromCaptureTool(client) {
             'For data gated behind login/navigation, pass `customInjection` — a ' +
             'page-injection script (old-devtools\' name for the builder\'s ' +
             'jsUserScripts) that drives the page to where the request fires. \n\n' +
-            'This backend has NO partial-patch endpoint — adding a version ' +
-            'always replaces the WHOLE providerConfig. When `providerId` is ' +
-            'set, any of `customInjection`, `userAgent`, `pageTitle`, ' +
-            '`allowedInjectedRequestData`, `stepsToFollow`, ' +
-            '`useIncognitoWebview`, `extensionConfig` that you OMIT is carried ' +
-            'forward unchanged from the currently-published version (so ' +
-            're-publishing requestData never wipes a working login script or ' +
-            'other config someone set via the dashboard). This can only carry ' +
-            'forward what the CURRENT version actually has — if an earlier ' +
-            'version already lost a field (e.g. published before this tool ' +
-            'carried it forward at all), there is nothing left to preserve and ' +
-            'the result legitimately comes back empty/null for that field; ' +
-            'that is not this call failing to carry it forward. Pass an ' +
-            'explicit value (`""`, `[]`, `false`, ...) to intentionally clear ' +
-            'one of them instead, or call get_provider_version_config FIRST ' +
-            'to see exactly what is live today, rather than assuming this ' +
-            'call recovered something that may already be gone. ' +
+            'BY DESIGN, this backend only ever CREATES A NEW VERSION (POST) — ' +
+            'there is no partial-patch/edit endpoint, and this tool does NOT ' +
+            'read or carry anything forward from the previous version. Every ' +
+            'new version replaces the WHOLE providerConfig with exactly what ' +
+            'you pass in THIS call. Therefore any field you want present in the ' +
+            'new version MUST be supplied here — `customInjection`, `userAgent`, ' +
+            '`pageTitle`, `allowedInjectedRequestData`, `stepsToFollow`, ' +
+            '`useIncognitoWebview`, `extensionConfig`, and `requestData` (via ' +
+            '`provider`/`providers`). Anything you OMIT is published blank/' +
+            'default in the new version, NOT preserved. To change one field ' +
+            'while keeping the rest, first read the current version with ' +
+            'get_provider_info, then pass the full desired config (the existing ' +
+            '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' +
@@ -250,6 +199,26 @@ export function createVersionFromCaptureTool(client) {
                                 type: 'boolean',
                                 description: 'Fail validation if none match. Default true.',
                             },
+                            templateParams: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Names of `${var}` placeholders used in this ' +
+                                    'template\'s `responseMatches`/`responseRedactions` ' +
+                                    'that should be substituted at verify time from the ' +
+                                    'submitted proof\'s own witness params. Omit (or ' +
+                                    'leave empty) if the template has no such ' +
+                                    'placeholders.',
+                            },
+                            templateParamsMode: {
+                                type: 'string',
+                                enum: ['separate', 'merge'],
+                                description: 'How multiple values for `templateParams` expand ' +
+                                    'into request specs. `separate` (default): one ' +
+                                    'independent spec per value, each matching its own ' +
+                                    'proof. `merge`: fold all values into ONE spec with ' +
+                                    'one match/redaction entry per value, matching a ' +
+                                    'single proof that bundles them all into one claim.',
+                            },
                         },
                         required: ['url', 'method'],
                     },
@@ -281,22 +250,22 @@ export function createVersionFromCaptureTool(client) {
                 '(an array of 1+ drafts).', { statusCode: 400 });
         }
         const providers = hasMany ? args.providers : [args.provider];
-        const opts = { initialUrl: args.initialUrl };
-        if (args.description !== undefined) {
-            opts.description = args.description;
-        }
-        if (args.geoLocation !== undefined) {
-            opts.geoLocation = args.geoLocation;
-        }
-        if (args.useProxy !== undefined) {
-            opts.useProxy = args.useProxy;
-        }
-        if (args.providerType !== undefined) {
-            opts.providerType = args.providerType;
-        }
-        if (args.customInjection !== undefined) {
-            opts.customInjection = args.customInjection;
-        }
+        const opts = {
+            initialUrl: args.initialUrl,
+            description: args.description,
+            geoLocation: args.geoLocation,
+            useProxy: args.useProxy,
+            providerType: args.providerType,
+            customInjection: args.customInjection,
+            userAgent: args.userAgent,
+            pageTitle: args.pageTitle,
+            stepsToFollow: args.stepsToFollow,
+            useIncognitoWebview: args.useIncognitoWebview,
+            extensionConfig: args.extensionConfig,
+            allowedInjectedRequestData: args.allowedInjectedRequestData
+                ? injectedRequestDataFrom(args.allowedInjectedRequestData)
+                : undefined
+        };
         // Non-blocking advisory per request — never alters or blocks the
         // publish; the author keeps full control. Attaches under `_notes`.
         const notes = matchRedactionWarnings(providers.map((p, i) => countsFor(`Request ${i + 1}`, p)));
@@ -325,20 +294,13 @@ export function createVersionFromCaptureTool(client) {
             const ignoredOnRegister = REGISTER_IGNORED_KEYS
                 .filter((k) => args[k] !== undefined);
             if (ignoredOnRegister.length) {
-                notes.push(`${ignoredOnRegister.join(', ')} ${ignoredOnRegister.length > 1 ? 'are' : 'is'} ignored on register (no providerId) — the old backend only ` +
+                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.');
             }
-            if (args.userAgent !== undefined) {
-                opts.userAgent = args.userAgent;
-            }
-            if (args.pageTitle !== undefined) {
-                opts.pageTitle = args.pageTitle;
-            }
-            if (args.stepsToFollow !== undefined) {
-                opts.stepsToFollow = args.stepsToFollow;
-            }
             const body = providerToRegisterBody(providers, opts);
             return withNotes(await client.registerProvider(body));
         }
@@ -348,42 +310,23 @@ export function createVersionFromCaptureTool(client) {
         // workaround instead of a bare permission error.
         const providerId = args.providerId;
         try {
-            // This backend has no partial-patch endpoint — a version always
-            // replaces the WHOLE providerConfig. Anything the caller didn't
-            // pass at all is carried forward from the currently-published
-            // version instead of going out blank. Pass an explicit empty
-            // value ("", [], false) to intentionally clear one.
-            const needsCurrent = PRESERVABLE_KEYS.some((k) => args[k] === undefined)
-                || args.allowedInjectedRequestData === undefined;
-            const current = needsCurrent
-                ? extractProviderConfig(await client.getProviderConfig(providerId))
-                : undefined;
-            const carried = [];
-            for (const key of PRESERVABLE_KEYS) {
-                const resolved = resolveField(args[key], current?.[key], key, carried);
-                if (resolved !== undefined) {
-                    opts[key] = resolved;
-                }
-            }
-            const freshInjected = args.allowedInjectedRequestData !== undefined
-                ? injectedRequestDataFrom(args.allowedInjectedRequestData)
-                : undefined;
-            const resolvedInjected = resolveField(freshInjected, current?.allowedInjectedRequestData, 'allowedInjectedRequestData', carried);
-            if (resolvedInjected !== undefined) {
-                opts.allowedInjectedRequestData = resolvedInjected;
-            }
-            if (carried.length) {
-                notes.push('Not passed, carried forward unchanged from the current ' +
-                    `published version: ${carried.join(', ')}. Pass an explicit ` +
-                    'value ("", [], false, ...) to override any of them, or ' +
-                    'call get_provider_version_config first to see what is ' +
-                    'live today.');
-            }
+            // By design this always POSTs a brand-new version and publishes
+            // EXACTLY the config assembled above — nothing is read back or
+            // carried forward. Any field the caller omitted is already absent
+            // from `opts` and will be blank/default in the new version. To
+            // preserve existing fields, the caller must have read them via
+            // get_provider_info and passed them back in.
             if (args.customInjection !== undefined && opts.customInjection?.trim()) {
                 notes.push('customInjection will run in the verification client before ' +
                     'every page load (before navigating to initialUrl), matching ' +
                     'the builder\'s jsUserScripts.');
             }
+            notes.push('A NEW version was created with only the fields passed in this ' +
+                'call — nothing was carried forward from the previous version. ' +
+                'If you intended to keep other fields (customInjection, ' +
+                'userAgent, allowedInjectedRequestData, ...), read the prior ' +
+                'version with get_provider_info and re-publish with them ' +
+                'included.');
             const versionsResp = await client.listVersions(providerId);
             const version = bumpPatchString(extractVersions(versionsResp));
             const versionInfo = args.notes && args.notes.trim().length >= 10