@reclaimprotocol/agent 0.1.9 → 0.1.11

package/src/authoring/tools.ts

@@ -205,6 +205,82 @@ export function authoringTools(
 				}))
 			},
 		),
+		defineTool<Record<string, unknown>>(
+			{
+				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) || 180_000)
+				const cookies = async() => {
+					const res = (await backend.sendCdp('Network.getCookies')) as {
+						cookies?: { name: string, httpOnly?: boolean }[]
+					}
+					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<Record<string, unknown>>(
 			{
 				name: 'list_requests',

package/src/mcp/tools/agent/find.ts

@@ -21,7 +21,12 @@ export function findTool(resolveBackend: ResolveBackend): RegisteredTool {
 				'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'],
@@ -29,37 +34,60 @@ export function findTool(resolveBackend: ResolveBackend): RegisteredTool {
 		},
 		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: string, idx: number, len: number) => {
+				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: { snippet: string, variant: string } | undefined
 				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)

package/src/mcp/tools/agent/propose.ts

@@ -83,12 +83,12 @@ export function proposeTool(resolveBackend: ResolveBackend): RegisteredTool {
 			}
 
 			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`.',
 					)
 				}
 			}

package/src/old/client.ts

@@ -147,24 +147,6 @@ export class ReclaimOldClient {
 		)
 	}
 
-	/** 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> {
-		return this.#request(
-			'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/src/old/to-register.ts

@@ -93,6 +93,8 @@ interface OldRequestData {
 export interface OldInjectedRequestData extends OldRequestData {
 	required?: boolean
 	multiple?: boolean
+	templateParams?: string[]
+	templateParamsMode?: 'separate' | 'merge'
 }
 
 /** Build the single `requestData` entry shared by register + update. Takes
@@ -200,11 +202,15 @@ function requestDataFrom(providers: ReclaimProvider[]): OldRequestData[] {
 export function injectedRequestDataFrom(
 	requests: AllowedJsRequest[],
 ): OldInjectedRequestData[] {
-	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

package/src/old/tools/build.ts

@@ -3,7 +3,6 @@ import type { ReclaimOldClient } from '../client.ts'
 import type { ReclaimSdkClient } from '../sdk-client.ts'
 import { authenticateTool } from './authenticate.ts'
 import { getProviderInfoTool } from './get-provider-info.ts'
-import { getProviderVersionConfigTool } from './get-version-config.ts'
 import { getMeProvidersTool } from './me-providers.ts'
 import { createVersionFromCaptureTool } from './publish.ts'
 import { sessionAnalyticsLogsTool } from './session-analytics-logs.ts'
@@ -27,7 +26,6 @@ export function buildOldBackendTools(
 		authenticateTool(client),
 		createVersionFromCaptureTool(client),
 		getMeProvidersTool(client),
-		getProviderVersionConfigTool(client),
 		getProviderInfoTool(sdkClient),
 		updateProviderMetadataTool(client),
 		sessionAnalyticsLogsTool(client),

package/src/old/tools/get-provider-info.ts

@@ -18,14 +18,17 @@ async function attempt(
 }
 
 /**
- * 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.
@@ -38,15 +41,18 @@ export function getProviderInfoTool(client: ReclaimSdkClient): RegisteredTool {
 				'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/src/old/tools/publish.ts

@@ -12,7 +12,6 @@ import {
 	bumpPatchString,
 	extractVersions,
 	injectedRequestDataFrom,
-	type OldInjectedRequestData,
 	type OldProviderOpts,
 	providerToConfigBody,
 	providerToRegisterBody,
@@ -20,66 +19,6 @@ import {
 
 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',
-] as const
-
-/** Pull `providerConfig` out of a `get_provider_version_config` /
- *  `getProviderConfig` response, tolerant of a missing/malformed shape. */
-function extractProviderConfig(
-	resp: unknown,
-): Record<string, unknown> | undefined {
-	if(resp && typeof resp === 'object') {
-		const cfg = (resp as { providerConfig?: unknown }).providerConfig
-		if(cfg && typeof cfg === 'object') {
-			return cfg as Record<string, unknown>
-		}
-	}
-
-	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<T>(
-	explicit: T | undefined,
-	current: unknown,
-	fieldName: string,
-	carried: string[],
-): T | undefined {
-	if(explicit !== undefined) {
-		return explicit
-	}
-
-	if(current !== undefined && current !== null) {
-		carried.push(fieldName)
-		return current as T
-	}
-
-	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
@@ -166,23 +105,19 @@ export function createVersionFromCaptureTool(
 				'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' +
@@ -316,6 +251,28 @@ export function createVersionFromCaptureTool(
 									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'],
 						},
@@ -356,25 +313,23 @@ export function createVersionFromCaptureTool(
 
 			const providers = hasMany ? args.providers! : [args.provider!]
 
-			const opts: OldProviderOpts = { 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: OldProviderOpts = {
+				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
@@ -414,27 +369,15 @@ export function createVersionFromCaptureTool(
 					.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 ` +
+						`${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))
 			}
@@ -445,48 +388,12 @@ export function createVersionFromCaptureTool(
 			// 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: string[] = []
-				for(const key of PRESERVABLE_KEYS) {
-					const resolved = resolveField(args[key], current?.[key], key, carried)
-					if(resolved !== undefined) {
-						(opts as unknown as Record<string, unknown>)[key] = resolved
-					}
-				}
-
-				const freshInjected = args.allowedInjectedRequestData !== undefined
-					? injectedRequestDataFrom(args.allowedInjectedRequestData)
-					: undefined
-				const resolvedInjected = resolveField<OldInjectedRequestData[]>(
-					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 ' +
@@ -495,6 +402,15 @@ export function createVersionFromCaptureTool(
 					)
 				}
 
+				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 =