@reclaimprotocol/agent 0.1.18 → 0.1.21

package/lib/mcp/tools/propose.js

@@ -1,75 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { draftProvider } from "../../provider/draft.js";
-import { OPRF_MAX_BYTES } from "../../provider/matcher.js";
-import { defineTool } from "../server.js";
-export function makeSecretStore() {
-    const map = new Map();
-    return {
-        put: (values) => {
-            const id = `sref_${randomUUID()}`;
-            map.set(id, values);
-            return id;
-        },
-        resolve: (ref) => map.get(ref),
-        clear: () => map.clear(),
-    };
-}
-export function proposeTool(captures, secrets) {
-    return defineTool({
-        name: 'propose_provider',
-        description: 'Draft a Reclaim provider JSON from a captured request + ' +
-            'a target value. ' +
-            'Secret header values are stored server-side and replaced with an ' +
-            'opaque secretParamsRef ' +
-            'in the response — raw secret values never appear in tool output. ' +
-            "`hash` is opt-in: when set, the captured value is OPRF'd so " +
-            'the attestor never sees ' +
-            'cleartext. Skill should ask the dev first. `oprf-raw` ' +
-            'is the only variant that runs ' +
-            'without external deps; `oprf` needs gnark (Linux/macOS), ' +
-            '`oprf-mpc` needs a TEE attestor.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                captureId: { type: 'string' },
-                requestId: { type: 'string' },
-                target: { type: 'string' },
-                name: { type: 'string' },
-                hash: { type: 'string', enum: ['oprf-raw', 'oprf', 'oprf-mpc'] },
-            },
-            required: ['captureId', 'requestId', 'target', 'name'],
-        },
-    }, async ({ captureId, requestId, target, name, hash }) => {
-        if (hash !== undefined && target.length > OPRF_MAX_BYTES) {
-            throw new Error(`OPRF caps hashed values at ${OPRF_MAX_BYTES} bytes; ` +
-                `got ${target.length}-byte target ` +
-                `"${target}". Try a tighter target ` +
-                '(e.g. just the relevant substring) or call ' +
-                'propose_provider without `hash`.');
-        }
-        const session = captures.sessions.get(captureId);
-        if (!session) {
-            throw new Error(`no capture ${captureId}`);
-        }
-        const r = session.requests.get(requestId);
-        if (!r) {
-            throw new Error(`no request ${requestId}`);
-        }
-        const body = session.bodies.get(requestId);
-        if (!body.available) {
-            throw new Error(`request body unavailable: ${body.reason}`);
-        }
-        const reqWithBody = { ...r, responseBody: body.body };
-        const { provider, secretRefs } = draftProvider(reqWithBody, target, name, hash);
-        // Stash real secret values for later replay/proof.
-        const realSecrets = {};
-        for (const ref of secretRefs) {
-            const real = r.requestHeaders[ref.name];
-            if (real !== undefined) {
-                realSecrets[ref.name] = real;
-            }
-        }
-        const secretParamsRef = secrets.put(realSecrets);
-        return { provider, secretRefs, secretParamsRef };
-    });
-}

package/lib/mcp/tools/publish.d.ts

@@ -1,3 +0,0 @@
-import type { ReclaimClient } from '@reclaimprotocol/client';
-import { type RegisteredTool } from '../server.ts';
-export declare function createVersionFromCaptureTool(client: ReclaimClient): RegisteredTool;

package/lib/mcp/tools/publish.js

@@ -1,59 +0,0 @@
-import { nextVersion, providerToCreateVersionRequest, } from "../../provider/to-version.js";
-import { defineTool } from "../server.js";
-export function createVersionFromCaptureTool(client) {
-    return defineTool({
-        name: 'create_provider_version_from_capture',
-        description: 'Translate a drafted ReclaimProvider (from propose_provider) into a ' +
-            'verification version and persist it via create_provider_version. ' +
-            'Call this after run_proof succeeds. ' +
-            'Omit `version` to have the tool auto-select the next available ' +
-            'version (it lists existing versions and bumps past the highest). ' +
-            'For PRIVATE verifications the version goes live immediately; ' +
-            'for PUBLIC ones call submit_provider_version_for_review afterwards.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                providerId: {
-                    type: 'string',
-                    description: 'UUID of the verification to publish the version on.',
-                },
-                provider: {
-                    type: 'object',
-                    description: 'The ReclaimProvider JSON from propose_provider ' +
-                        '(with URL parameterisation applied).',
-                },
-                initialUrl: {
-                    type: 'string',
-                    description: 'The website URL the user landed on to trigger the request ' +
-                        '(e.g. https://github.com/Syed). The URL the verification ' +
-                        'flow opens for end-users — NOT the API URL inside the provider.',
-                },
-                notes: {
-                    type: 'string',
-                    description: 'Short change note (e.g. "Initial draft from browser capture").',
-                },
-                version: {
-                    type: 'object',
-                    description: 'Semver to publish as. Omit to auto-pick the next ' +
-                        'version above the highest existing one.',
-                    properties: {
-                        major: { type: 'number', minimum: 0 },
-                        minor: { type: 'number', minimum: 0 },
-                        patch: { type: 'number', minimum: 0 },
-                    },
-                    required: ['major', 'minor', 'patch'],
-                },
-            },
-            required: ['providerId', 'provider', 'initialUrl'],
-        },
-    }, async (args) => {
-        // Auto-pick the next version if not explicit
-        const ver = args.version ?? (await nextVersion(client, args.providerId));
-        const body = providerToCreateVersionRequest(args.provider, args.initialUrl, args.notes, ver);
-        const result = (await client.call('CreateProviderVersion', {
-            params: { providerId: args.providerId },
-            body,
-        }));
-        return result.data;
-    });
-}

package/lib/mcp/tools/replay.d.ts

@@ -1,3 +0,0 @@
-import { type RegisteredTool } from '../server.ts';
-import type { SecretStore } from './propose.ts';
-export declare function replayTool(secrets: SecretStore): RegisteredTool;

package/lib/mcp/tools/replay.js

@@ -1,46 +0,0 @@
-import { replayProvider } from "../../proof/replay.js";
-import { defineTool } from "../server.js";
-export function replayTool(secrets) {
-    return defineTool({
-        name: 'replay_request',
-        description: 'Replay a drafted provider against the live endpoint ' +
-            'using Node fetch (no attestor). ' +
-            'Pre-flight gate before run_proof — ' +
-            'diagnoses CSRF / token-rotation / matcher-too-tight ' +
-            'issues with richer hints than the attestor would produce.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                // `type: 'object'` is required so MCP clients (the LLM)
-                // serialize the value as an object, not a JSON-stringified
-                // string. `properties: {}` is required so zod-from-json-schema
-                // compiles to a passthrough instead of strict-strip — leaving
-                // it off makes the server receive `{}`.
-                provider: { type: 'object', properties: {} },
-                secretParamsRef: { type: 'string' },
-            },
-            required: ['provider'],
-        },
-    }, async ({ provider, secretParamsRef }) => {
-        let resolved = {};
-        if (secretParamsRef !== undefined) {
-            const r = secrets.resolve(secretParamsRef);
-            if (!r) {
-                throw new Error(`unknown secretParamsRef "${secretParamsRef}" — ` +
-                    'the MCP server has restarted or reset_session was called. ' +
-                    'Re-run propose_provider to mint a fresh ref.');
-            }
-            resolved = r;
-        }
-        const result = await replayProvider(provider, resolved);
-        const out = {
-            status: result.status,
-            matchesOriginal: result.matchesOriginal,
-            bodySnippet: result.body.slice(0, 256),
-        };
-        if (result.hints !== undefined) {
-            out.hints = result.hints;
-        }
-        return out;
-    });
-}

package/lib/mcp/tools/session.d.ts

@@ -1,10 +0,0 @@
-import type { ConfigStore } from '../../config/store.ts';
-import { type RegisteredTool } from '../server.ts';
-import type { AttachState } from './attach.ts';
-import type { CaptureStore } from './capture.ts';
-export declare function sessionTools(attachRef: {
-    current?: AttachState;
-    config: ConfigStore;
-}, captures: CaptureStore, secrets: {
-    clear: () => void;
-}): RegisteredTool[];

package/lib/mcp/tools/session.js

@@ -1,29 +0,0 @@
-import { defineTool } from "../server.js";
-export function sessionTools(attachRef, captures, secrets) {
-    return [
-        defineTool({
-            name: 'get_session',
-            description: 'Return current attach state, active captures, and persisted config.',
-            inputSchema: { type: 'object', properties: {} },
-        }, async () => ({
-            config: attachRef.config.read(),
-            attached: Boolean(attachRef.current),
-            port: attachRef.current?.port,
-            captures: [...captures.sessions.keys()],
-            activeTab: captures.activeTab,
-        })),
-        defineTool({
-            name: 'reset_session',
-            description: 'Stop all captures, drop in-memory secrets, and clear capture state.',
-            inputSchema: { type: 'object', properties: {} },
-        }, async () => {
-            for (const s of captures.sessions.values()) {
-                await s.stop().catch(() => { });
-            }
-            captures.sessions.clear();
-            delete captures.activeTab;
-            secrets.clear();
-            return { reset: true };
-        }),
-    ];
-}

package/lib/mcp/tools/verification/diagnose.d.ts

@@ -1,11 +0,0 @@
-import { type ReclaimClient } from '@reclaimprotocol/client';
-import { type RegisteredTool } from '../../server.ts';
-/**
- * `diagnose_verification_session` — one call that answers "what's wrong
- * with this session?". Pulls the session, its full event log, and its
- * callback-delivery diagnostics, then derives findings (where the flow
- * stalled or failed) and concrete suggestions (what to check or do next).
- * Read-only; authenticates with the active eth credential like
- * `get_verification_result`.
- */
-export declare function verificationDiagnoseTool(client: ReclaimClient): RegisteredTool;

package/lib/mcp/tools/verification/diagnose.js

@@ -1,132 +0,0 @@
-import { buildAuthHeaders } from '@reclaimprotocol/client';
-import { defineTool } from "../../server.js";
-import { resolveActivePrivateKey } from "./result.js";
-const TERMINAL = new Set(['success', 'rejected', 'error']);
-/**
- * `diagnose_verification_session` — one call that answers "what's wrong
- * with this session?". Pulls the session, its full event log, and its
- * callback-delivery diagnostics, then derives findings (where the flow
- * stalled or failed) and concrete suggestions (what to check or do next).
- * Read-only; authenticates with the active eth credential like
- * `get_verification_result`.
- */
-export function verificationDiagnoseTool(client) {
-    return defineTool({
-        name: 'diagnose_verification_session',
-        description: 'Diagnose a verification session: fetches its status, event ' +
-            'timeline, and callback-delivery state, then reports findings ' +
-            '(where the flow stalled or failed — link never opened, proof ' +
-            'failed, callback endpoint erroring, dead-lettered delivery, ' +
-            'expiry) and suggested next steps. Read-only. Use ' +
-            'get_verification_result to fetch and decrypt the actual result.',
-        inputSchema: {
-            type: 'object',
-            required: ['sessionId'],
-            properties: {
-                sessionId: {
-                    type: 'string',
-                    description: 'The verification session id to diagnose.',
-                },
-            },
-        },
-    }, async (args) => {
-        const privateKey = resolveActivePrivateKey();
-        const auth = () => buildAuthHeaders(privateKey, 'VerificationAuth');
-        const params = { sessionId: args.sessionId };
-        const [session, events, deliveries] = await Promise.all([
-            client.call('GetVerificationSession', { params, headers: auth() })
-                .then((r) => r.data),
-            client.call('ListVerificationEvents', { params, headers: auth() })
-                .then((r) => r.data.items),
-            client.call('ListVerificationDeliveries', { params, headers: auth() })
-                .then((r) => r.data.items),
-        ]);
-        const seen = new Set(events.map((e) => e.event));
-        const last = events[events.length - 1];
-        const findings = [];
-        const suggestions = [];
-        // Where did the flow get to?
-        if (session.status === 'pending') {
-            if (new Date(session.expiresAt).getTime() < Date.now()) {
-                findings.push('Session is past expiresAt — it will flip to expired on the ' +
-                    'next sweep; the end-user can no longer complete it.');
-                suggestions.push('Create a new session and share a fresh link.');
-            }
-            else if (!seen.has('verification_client_opened')) {
-                findings.push('The end-user has not opened the verification link yet.');
-                suggestions.push(`Re-share the link (${session.verificationUrl}) before ` +
-                    `it expires at ${session.expiresAt}.`);
-            }
-            else if (!seen.has('request_matched')) {
-                findings.push('The page was opened but the target request was never ' +
-                    'captured — the end-user likely has not completed the ' +
-                    'login/journey on the provider site.');
-            }
-            else {
-                findings.push('Proof flow is in progress — the target request was ' +
-                    'captured and the run has not reached a terminal event.');
-            }
-        }
-        if (session.status === 'expired') {
-            findings.push(seen.has('verification_client_opened')
-                ? 'Session expired mid-flow — the end-user started but did ' +
-                    'not finish before expiresAt.'
-                : 'Session expired without the link ever being opened.');
-            suggestions.push('Create a new session and share a fresh link.');
-        }
-        // Surface failure detail from the event log.
-        for (const e of events) {
-            if (e.event === 'request_claim_failed' ||
-                e.event === 'request_claim_rejected' ||
-                e.event === 'verification_error' ||
-                e.event === 'verification_rejected') {
-                findings.push(`${e.event} at ${e.createdAt}` +
-                    (e.eventData ? `: ${JSON.stringify(e.eventData)}` : ''));
-            }
-        }
-        // Callback delivery health (only meaningful after a terminal event).
-        for (const d of deliveries) {
-            if (d.deliveryStatus === 'delivered') {
-                continue;
-            }
-            findings.push(`Callback to ${d.callbackUrl} is ${d.deliveryStatus} after ` +
-                `${d.attempts} attempt(s)` +
-                (d.lastError ? ` — last error: ${d.lastError}` : '') +
-                (d.deadLettered ? ' (dead-lettered; retries exhausted)' : ''));
-            suggestions.push(`Check that ${d.callbackUrl} is reachable and answers 2xx.`);
-            if (d.deadLettered) {
-                suggestions.push('Once the endpoint is fixed, re-deliver via ' +
-                    'POST /verifications/sessions/{sessionId}/retry-callback ' +
-                    '(or ask an admin to retry it from the Callback DLQ).');
-            }
-        }
-        if (TERMINAL.has(session.status) &&
-            deliveries.every((d) => d.deliveryStatus === 'delivered')) {
-            suggestions.push('Result delivered. Use get_verification_result to fetch and ' +
-                'decrypt it locally.');
-        }
-        if (!findings.length) {
-            findings.push('No problems detected.');
-        }
-        return {
-            sessionId: session.id,
-            status: session.status,
-            callbackDeliveryStatus: session.callbackDeliveryStatus,
-            mode: session.mode,
-            createdAt: session.createdAt,
-            expiresAt: session.expiresAt,
-            completedAt: session.completedAt,
-            lastEvent: last
-                ? { event: last.event, at: last.createdAt }
-                : undefined,
-            events: events.map((e) => ({
-                event: e.event,
-                at: e.createdAt,
-                ...(e.eventData ? { data: e.eventData } : {}),
-            })),
-            deliveries,
-            findings,
-            suggestions,
-        };
-    });
-}

package/lib/mcp/verifications/build.d.ts

@@ -1,5 +0,0 @@
-import type { ReclaimClient } from '@reclaimprotocol/client';
-import type { RegisteredTool } from '../server.ts';
-/** Verification CRUD tools — build the flat list of RegisteredTool
- *  entries. Mirrors buildAgentTools() in mcp/register.ts. */
-export declare function buildVerificationTools(client: ReclaimClient): RegisteredTool[];

package/lib/mcp/verifications/build.js

@@ -1,14 +0,0 @@
-import { createTool } from "./create.js";
-import { findTool } from "./find.js";
-import { getTool } from "./get.js";
-import { updateTool } from "./update.js";
-/** Verification CRUD tools — build the flat list of RegisteredTool
- *  entries. Mirrors buildAgentTools() in mcp/register.ts. */
-export function buildVerificationTools(client) {
-    return [
-        findTool(client),
-        getTool(client),
-        createTool(client),
-        updateTool(client),
-    ];
-}

package/lib/mcp/verifications/create.d.ts

@@ -1,3 +0,0 @@
-import type { ReclaimClient } from '@reclaimprotocol/client';
-import { type RegisteredTool } from '../server.ts';
-export declare function createTool(client: ReclaimClient): RegisteredTool;

package/lib/mcp/verifications/create.js

@@ -1,57 +0,0 @@
-import { defineTool } from "../server.js";
-export function createTool(client) {
-    return defineTool({
-        name: 'create_verification',
-        description: 'Create a new Reclaim verification. Use this only ' +
-            'after `find_verification` returned nothing useful ' +
-            'for the domain. The caller must be an active ' +
-            'member of the target organization.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: {
-                    type: 'string',
-                    description: 'uuid identifier of the organization ' +
-                        'that will own the verification.'
-                },
-                domain: {
-                    type: 'string',
-                    minLength: 1,
-                    maxLength: 200,
-                    description: 'Canonical root domain (e.g. `github.com`). ' +
-                        'No scheme, no port, no path.',
-                },
-                slug: {
-                    type: 'string',
-                    pattern: '^[a-z0-9]+(?:-[a-z0-9]+)*$',
-                    minLength: 1,
-                    maxLength: 100,
-                    description: 'URL-safe identifier. Globally unique — pick ' +
-                        'something domain-specific like `github-followers`.',
-                },
-                title: {
-                    type: 'string',
-                    minLength: 1,
-                    maxLength: 100,
-                    description: 'Short headline shown to end-users. Defaults ' +
-                        'to a domain-derived brand name.',
-                },
-                description: { type: 'string', minLength: 1, maxLength: 2000 },
-                iconUrl: { type: 'string', description: 'uri of the icon' },
-                tags: { type: 'array', items: { type: 'string' }, maxItems: 50 },
-            },
-            required: ['orgId', 'domain', 'slug'],
-        },
-    }, async (args) => client.call('CreateProvider', {
-        body: {
-            orgId: args.orgId,
-            domain: args.domain,
-            slug: args.slug,
-            title: args.title,
-            description: args.description,
-            iconUrl: args.iconUrl,
-            tags: args.tags ?? [],
-            visibility: 'PRIVATE'
-        },
-    }));
-}

package/lib/mcp/verifications/find.d.ts

@@ -1,3 +0,0 @@
-import type { ReclaimClient } from '@reclaimprotocol/client';
-import { type RegisteredTool } from '../server.ts';
-export declare function findTool(client: ReclaimClient): RegisteredTool;

package/lib/mcp/verifications/find.js

@@ -1,37 +0,0 @@
-import { defineTool } from "../server.js";
-export function findTool(client) {
-    return defineTool({
-        name: 'find_verification',
-        description: 'Search published Reclaim verifications by domain or ' +
-            'data point. A verification is the recipe an end-user ' +
-            'follows to prove something about themselves (e.g. ' +
-            '"I have N followers on Twitter"). Returns a list of ' +
-            'matches. Call this BEFORE `create_verification` — ' +
-            'most popular domains already have a public ' +
-            'verification you can reuse.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    minLength: 1,
-                    maxLength: 200,
-                    description: 'Free-text query. Matches domain (e.g. ' +
-                        '"github.com"), title, description, and the ' +
-                        'data points a verification can prove.',
-                },
-                tags: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Restrict to verifications carrying every tag.',
-                },
-                limit: { type: 'number', minimum: 1, maximum: 100 },
-            },
-        },
-    }, async (args) => client.call('Providers', {
-        query: {
-            q: args.query,
-            tag: args.tags ?? [],
-        },
-    }));
-}

package/lib/mcp/verifications/get.d.ts

@@ -1,3 +0,0 @@
-import type { ReclaimClient } from '@reclaimprotocol/client';
-import { type RegisteredTool } from '../server.ts';
-export declare function getTool(client: ReclaimClient): RegisteredTool;

package/lib/mcp/verifications/get.js

@@ -1,26 +0,0 @@
-import { defineTool } from "../server.js";
-export function getTool(client) {
-    return defineTool({
-        name: 'get_verification',
-        description: 'Fetch a single Reclaim verification by id. Returns ' +
-            'every field needed to integrate it into a flow: ' +
-            'domain, the live version (initialUrl + requests), ' +
-            'and the data points it can prove. Use ' +
-            '`find_verification` first if you only have a query ' +
-            'string.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                providerId: {
-                    type: 'string',
-                    description: 'UUID of the verification. (Internally stored ' +
-                        'as `providerId` — the field name reflects ' +
-                        'the openapi schema.)',
-                },
-            },
-            required: ['providerId'],
-        },
-    }, async (args) => client.call('GetProvider', {
-        params: { providerId: args.providerId },
-    }));
-}

package/lib/mcp/verifications/update.d.ts

@@ -1,3 +0,0 @@
-import type { ReclaimClient } from '@reclaimprotocol/client';
-import { type RegisteredTool } from '../server.ts';
-export declare function updateTool(client: ReclaimClient): RegisteredTool;

package/lib/mcp/verifications/update.js

@@ -1,78 +0,0 @@
-import { defineTool } from "../server.js";
-export function updateTool(client) {
-    return defineTool({
-        name: 'update_verification',
-        description: "Update a Reclaim verification's metadata. Partial " +
-            'PATCH — pass only fields you want to change. The ' +
-            'caller must be an active member of the owning ' +
-            "organization. To change the verification's " +
-            'recipe (initialUrl, requests, …) cut a new ' +
-            'version via the dashboard. Use `seo` to control how ' +
-            'the verification appears in search results and social ' +
-            'shares; omit a subfield to keep the server default.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                providerId: {
-                    type: 'string',
-                    description: 'UUID of the verification. (Internally stored ' +
-                        'as `providerId` — the field name reflects ' +
-                        'the openapi schema.)',
-                },
-                title: { type: 'string', minLength: 1, maxLength: 100 },
-                description: { type: 'string', minLength: 1, maxLength: 2000 },
-                iconUrl: { type: 'string', description: 'uri of icon' },
-                clearIcon: {
-                    type: 'boolean',
-                    description: 'Set true to wipe the icon explicitly.',
-                },
-                visibility: { type: 'string', enum: ['PRIVATE', 'PUBLIC'] },
-                status: { type: 'string', enum: ['ACTIVE', 'ARCHIVED'] },
-                tags: { type: 'array', items: { type: 'string' }, maxItems: 50 },
-                seo: {
-                    type: 'object',
-                    additionalProperties: false,
-                    description: 'Author SEO overrides. Each field falls back to a ' +
-                        'server-derived suggestion when unset.',
-                    properties: {
-                        brandUrl: {
-                            type: 'string',
-                            maxLength: 2000,
-                            description: 'Canonical homepage url of the brand.',
-                        },
-                        primaryDataPoint: {
-                            type: 'string',
-                            maxLength: 200,
-                            description: 'Headline data point (e.g. "subscriber ' +
-                                'count"); used in the SEO title.',
-                        },
-                        dataPoints: {
-                            type: 'array',
-                            items: { type: 'string', maxLength: 200 },
-                            maxItems: 50,
-                            description: 'Full list of verifiable data points.',
-                        },
-                        titleOverride: {
-                            type: 'string',
-                            maxLength: 200,
-                            description: 'Replaces the composed page title.',
-                        },
-                        descriptionOverride: {
-                            type: 'string',
-                            maxLength: 320,
-                            description: 'Replaces the composed meta description.',
-                        },
-                    },
-                },
-            },
-            required: ['providerId'],
-        },
-    }, async (args) => {
-        const { providerId, ...rest } = args;
-        return client.call('UpdateProvider', {
-            params: { providerId },
-            headers: {},
-            body: rest,
-        });
-    });
-}

package/lib/old/tools/get-version-config.d.ts

@@ -1,17 +0,0 @@
-import { type RegisteredTool } from '../../mcp/server.ts';
-import type { ReclaimOldClient } from '../client.ts';
-/**
- * Read the full `providerConfig` (loginUrl, customInjection, requestData,
- * geoLocation, ...) of one provider version on the old devtools backend —
- * the latest version when `version` is omitted.
- *
- * Exists so a dev/agent can see what's CURRENTLY published before adding a
- * new version with `create_provider_version_from_capture`. That tool always
- * takes a FULL replacement `providerConfig` (no partial-patch endpoint on
- * this backend), so a version added without knowing the current
- * `customInjection` would silently publish it blank — wiping a working
- * login script instead of preserving it. Read it here first, then pass it
- * straight through (or omit `customInjection` on publish to have it carried
- * forward automatically).
- */
-export declare function getProviderVersionConfigTool(client: ReclaimOldClient): RegisteredTool;