@reclaimprotocol/agent 0.1.14 → 0.1.17

package/src/old/tools/publish.ts

@@ -240,15 +240,89 @@ export function createVersionFromCaptureTool(
 							'Extra requests the customInjection script is allowed to ' +
 							'fire (e.g. pagination) — add-version ONLY, the register ' +
 							'endpoint ignores this. Each item has the same shape as ' +
-							'`provider`, plus `multiple`/`required` (default true).',
+							'`provider`, plus `multiple`/`required` (default true). ' +
+							'IMPORTANT whenever a claim\'s request HAS a body: set `body` ' +
+							'here (see its own description below) — if only a small part ' +
+							'of the real body varies per user/run (e.g. one id field, not ' +
+							'the whole payload), template just that part with ' +
+							'`{{paramName}}` and keep the rest as fixed literal text; see ' +
+							'the "bodySniff" section of the customInjection field\'s guide ' +
+							'for the exact mechanics and a worked example.',
 						items: {
 							type: 'object',
 							properties: {
 								url: { type: 'string' },
 								method: { type: 'string' },
-								body: { type: 'string' },
-								responseMatches: { type: 'array' },
-								responseRedactions: { type: 'array' },
+								body: {
+									type: 'string',
+									description:
+										'Becomes `bodySniff: { enabled: true, template: <this ' +
+										'string> }` — set this whenever the request has a ' +
+										'body at all (skip only for a genuinely bodyless ' +
+										'request, typically GET). If the real body is FIXED ' +
+										'(identical for every user/run), put that literal body ' +
+										'text here verbatim. If only PART of it varies (e.g. ' +
+										'`{"request":1,"type":"user_info","id":"12345"}` where ' +
+										'only `id` differs per user), template ONLY that part: ' +
+										'`{"request":1,"type":"user_info",' +
+										'"id":"{{REQ_BODY_USER_ID}}"}` — keep everything else ' +
+										'as fixed literal text rather than templating the whole ' +
+										'body. Confirmed directly against attestor-core\'s ' +
+										'`hashProviderParams`: the hash embeds this string ' +
+										'LITERALLY, unresolved braces and all, never the real ' +
+										'substituted body, so a claim built with the SAME ' +
+										'literal template (plus a witness/extracted param per ' +
+										'placeholder, supplying the real value for ' +
+										'verification) hashes identically regardless of what ' +
+										'those real values are. This is the OPPOSITE of ' +
+										'`templateParams`\' `${var}` syntax below, which ' +
+										'genuinely IS substituted before hashing — do not ' +
+										'confuse `{{param}}` (body, never resolved) with ' +
+										'`${var}` (responseMatches/responseRedactions, resolved ' +
+										'at verify time). Before publishing, hand-verify that ' +
+										'substituting real sample values into this template ' +
+										'reproduces the real captured request body ' +
+										'byte-for-byte. Fallback if per-field templating keeps ' +
+										'mismatching (more fields vary than expected, unstable ' +
+										'key order, etc.) and you can\'t pin down every ' +
+										'variable field: template the WHOLE body as one ' +
+										'placeholder instead, `{{REQ_BODY_GRD}}` — the `GRD` ' +
+										'suffix makes it a greedy match (captures everything) ' +
+										'rather than the default non-greedy match, which is ' +
+										'needed when nothing fixed follows the placeholder. ' +
+										'This pins down nothing about body structure, so prefer ' +
+										'minimal per-field placeholders whenever you can ' +
+										'actually identify which fields vary.',
+								},
+								responseMatches: {
+									type: 'array',
+									description:
+										'Each item: `{ value: string, type?: "contains" | ' +
+										'"regex", invert?: boolean, isOptional?: boolean }`. ' +
+										'`value` must literally appear (or match, if `regex`) ' +
+										'somewhere in the response body for the claim to be ' +
+										'accepted; it commonly embeds one or more ' +
+										'`{{paramName}}` extraction placeholders (e.g. ' +
+										'`"name":"{{name_0}}"`) whose real value is redacted ' +
+										'out and supplied separately as a witness/extracted ' +
+										'param. Use `${var}` (not `{{var}}`) inside this string ' +
+										'only if you also declare that name in this entry\'s ' +
+										'own `templateParams` below — that\'s a DIFFERENT, ' +
+										'verify-time-substituted placeholder, resolved from the ' +
+										'submitted proof before hashing (unlike a body ' +
+										'`{{param}}`, which never resolves — see `body` above).',
+								},
+								responseRedactions: {
+									type: 'array',
+									description:
+										'Each item: `{ jsonPath?: string, xPath?: string, ' +
+										'regex?: string, hash?: string }`. Identifies WHICH ' +
+										'part of the response the matching `{{paramName}}` in ' +
+										'`responseMatches` actually redacts/extracts — e.g. ' +
+										'`jsonPath: "$.data.items[0].name"` for a JSON response. ' +
+										'Order/count should line up with `responseMatches`\' ' +
+										'placeholders one-to-one for a typical claim.',
+								},
 								multiple: {
 									type: 'boolean',
 									description: 'Allow matching many requests. Default true.',

package/src/proof/debug-response-dump.ts

@@ -26,7 +26,7 @@ let installed = false
 /** Wrap attestor-core's http `getResponseRedactions` to dump the response it
  *  runs against. Idempotent; no-op unless RECLAIM_AGENT_DUMP_RESPONSE is
  *  set. */
-export function installResponseDump(): void {
+export function installResponseDump() {
 	if(installed || !process.env['RECLAIM_AGENT_DUMP_RESPONSE']) {
 		return
 	}

package/src/proof/proof-core.ts

@@ -20,7 +20,7 @@ let cryptoInitialized = false
  *  caller; without this the first proof dies inside the TLS client with
  *  `crypto.randomBytes is not a function`. Shared by every attestor caller —
  *  the agent MCP `run_proof` tool and the app's verification runner. */
-export function ensureAttestorCrypto(): void {
+export function ensureAttestorCrypto() {
 	if(cryptoInitialized) {
 		return
 	}

package/src/proof/zk-files.ts

@@ -27,7 +27,7 @@ let inFlight: Promise<void> | undefined
  * All output goes to stderr (fd 2): the MCP server speaks JSON-RPC over stdout,
  * so a stray write to fd 1 mid-session would corrupt the protocol.
  */
-export function ensureZkFiles(): Promise<void> {
+export function ensureZkFiles() {
 	inFlight ??= download().catch((err) => {
 		inFlight = undefined
 		throw err
@@ -35,7 +35,7 @@ export function ensureZkFiles(): Promise<void> {
 	return inFlight
 }
 
-async function download(): Promise<void> {
+async function download() {
 	let mainPath: string
 	try {
 		mainPath = require.resolve('@reclaimprotocol/zk-symmetric-crypto')

package/src/provider/dom-xpath.ts

@@ -190,7 +190,7 @@ function findElement(root: Node, targets: string[]): Element | undefined {
 	const complete: Element[] = []
 	const embedded: Element[] = []
 
-	const walk = (node: Node): void => {
+	const walk = (node: Node) => {
 		if(isTag(node)) {
 			const el = node
 			const texts = el.children.filter(isText).map((c) => c.data)

package/src/provider/draft.ts

@@ -160,7 +160,7 @@ export function assertPortableMatches(
 	matches: ResponseMatch[],
 	redactions: ResponseRedaction[],
 	targets: DraftTarget[],
-): void {
+) {
 	// A baked email LOCAL-PART ("jane.doe@…") pins the provider to one user
 	// even when only the domain is captured as a param — the classic result of
 	// proving an email's domain substring. Reject it regardless of the declared
@@ -172,7 +172,7 @@ export function assertPortableMatches(
 		.replace(/\{\{[^}]*\}\}/g, '')
 		.replace(/\(\?<[^>]*>[^)]*\)/g, '')
 		.replace(/\\(.)/g, '$1')
-	const scanEmail = (text: string, where: string): void => {
+	const scanEmail = (text: string, where: string) => {
 		if(EMAIL_LOCAL_BAKED.test(deregex(text))) {
 			throw new Error(
 				`drafted ${where} bakes a per-user email local-part as a literal — `
@@ -203,7 +203,7 @@ export function assertPortableMatches(
 	}
 
 	const stripParams = (s: string): string => s.replace(/\{\{[^}]*\}\}/g, '')
-	const scan = (text: string, where: string, own: string | null): void => {
+	const scan = (text: string, where: string, own: string | null) => {
 		const bare = stripParams(text)
 		for(const v of guarded) {
 			if(bare.includes(v)) {

package/src/provider/to-version.ts

@@ -189,6 +189,10 @@ export function providerToCreateVersionRequest(
 		...providerToRequestSelection(req),
 		multiple: req.multiple ?? true,
 		required: req.required ?? true,
+		templateParamsMode: req.templateParamsMode ?? 'separate',
+		...(req.templateParams?.length
+			? { templateParams: req.templateParams }
+			: {}),
 	}))
 	const script = jsUserScripts?.trim()
 

package/src/tools/registry.ts

@@ -11,6 +11,8 @@
  * glue (`registerToolList` onto an `McpServer`) stays in `mcp/server.ts`, which
  * re-exports this primitive for the MCP-side tool files.
  */
+import { type Boom, isBoom } from '@hapi/boom'
+import type { ProblemDetails } from '@reclaimprotocol/client'
 import type { JSONSchema } from 'zod/v4/core'
 import { toZod } from '../mcp/api/to-zod.ts'
 
@@ -51,6 +53,20 @@ export function defineTool<TArgs>(
 	}
 }
 
+/**
+ * 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: unknown): string {
+	if(isBoom(err) && err.output?.statusCode) {
+		const detail = (err as Boom<ProblemDetails>).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
@@ -73,6 +89,9 @@ export function extendTool(
 		...(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/src/cli/args.ts

@@ -1,20 +0,0 @@
-import { parseArgs as nodeParseArgs } from 'node:util'
-
-// Placeholder. Final shape decided once the backend openapi stabilises and
-// the CLI surface is fleshed out (see AGENTS.md → "CLI").
-export function parseCliArgs(argv: string[]) {
-	return nodeParseArgs({
-		args: argv,
-		options: {
-			'base-url': { type: 'string' },
-			token: { type: 'string' },
-			param: { type: 'string', multiple: true },
-			query: { type: 'string', multiple: true },
-			body: { type: 'string' },
-			help: { type: 'boolean', short: 'h' },
-			version: { type: 'boolean', short: 'v' },
-		},
-		allowPositionals: true,
-		strict: false,
-	})
-}

package/src/cli/commands.ts

@@ -1,27 +0,0 @@
-import { notImplemented } from '@hapi/boom'
-import { DESCRIPTION, NAME, VERSION } from '../pkg.ts'
-import { parseCliArgs } from './args.ts'
-
-// Entry point for the `reclaim` bin. Placeholder until backend openapi
-// finalises — `--version` and `--help` work; everything else throws.
-export async function run(argv: string[]) {
-	const parsed = parseCliArgs(argv)
-
-	if(parsed.values['version']) {
-		process.stdout.write(`${NAME} ${VERSION}\n`)
-		return
-	}
-
-	if(parsed.values['help']) {
-		process.stdout.write(
-			`${NAME} ${VERSION}\n${DESCRIPTION}\n\n` +
-			'Usage: reclaim call <OperationId> ' +
-			'[--param k=v] [--query k=v] [--body <json>]\n',
-		)
-		return
-	}
-
-	throw notImplemented(
-		'reclaim CLI: pending @reclaimprotocol/app spec finalisation',
-	)
-}

package/src/cli.ts

@@ -1,7 +0,0 @@
-import { run } from './cli/commands.ts'
-import { LOGGER } from './logger.ts'
-
-run(process.argv.slice(2)).catch((err) => {
-	LOGGER.error({ err }, 'cli failed')
-	process.exitCode = 1
-})