@reclaimprotocol/agent 0.1.5 → 0.1.6

package/lib/authoring/tools.js

@@ -1,21 +1,25 @@
-import { draftProvider } from "../provider/draft.js";
-import { OPRF_MAX_BYTES } from "../provider/matcher.js";
-import { normalizeCandidates } from "../provider/normalize.js";
-import { verificationWarnings } from "../provider/verification-checks.js";
+/**
+ * The authoring tools, authored ONCE — each directly with the shared
+ * `defineTool` primitive (no parallel tool spec). `authoringTools(resolve)`
+ * returns them as plain {@link RegisteredTool}s; the MCP (local Chrome +
+ * attestor) and the cloud loop (Popcorn + TEE) each pass their own backend
+ * resolver, so navigate/inspect/propose/replay/prove logic lives in one place.
+ *
+ * The resolver hands back the backend per call — the MCP keys it by `captureId`
+ * (multi-session), the cloud returns its one run backend. A host that needs
+ * extra input schema (the MCP's `captureId` + rich `run_proof` contract) MAPS
+ * these tools through `extendTool` at registration; the tools stay plain.
+ *
+ * Secret guarantee: captured cookie/auth values never enter a tool result. The
+ * draft (recipe + secrets) is held server-side; the model only sees an opaque
+ * `draftId` and the secret-free provider.
+ */
+import { findTool } from "../mcp/tools/agent/find.js";
+import { proposeTool } from "../mcp/tools/agent/propose.js";
+import { replayTool } from "../mcp/tools/agent/replay.js";
 import { defineTool } from "../tools/registry.js";
+import { objectSchema, publicRequest } from "./util.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-/** Secret-free projection of a captured request for tool output. */
-function publicRequest(r) {
-    return {
-        requestId: r.requestId,
-        method: r.method,
-        url: r.url,
-        status: r.status,
-        contentType: r.contentType,
-        size: r.size,
-        ...(r.graphqlOp ? { graphqlOp: r.graphqlOp } : {}),
-    };
-}
 function matchesFilter(r, f) {
     if (f.method && r.method !== f.method.toUpperCase()) {
         return false;
@@ -57,111 +61,86 @@ async function evalInPage(backend, expression) {
     return { value: res.result?.value };
 }
 /**
- * Build the authoring tools for a host as plain {@link RegisteredTool}s — the
- * same primitive the MCP-only tools use. Each handler resolves the backend via
- * `host.resolveBackend(args)`; the schema merges the host's `sessionSchema`
- * (e.g. `captureId`) and any per-tool `toolExtras`.
+ * The authoring tools — navigate/inspect authored inline here; find/propose/
+ * replay live in their own files ({@link findTool}/{@link proposeTool}/
+ * {@link replayTool}) and are composed in below. Each is a plain `defineTool`
+ * primitive, so there is one canonical `RegisteredTool` per tool and no
+ * parallel tool shape. Every handler resolves its session backend via
+ * `resolveBackend(args)`: the cloud passes `() => backend` (one backend per
+ * run); the MCP passes an `args.captureId`-keyed resolver. Hosts that need
+ * extra input schema (the MCP's `captureId` session handle + the
+ * credential-aware `run_proof` contract) MAP these tools through `extendTool`
+ * (see mcp/tools/agent/shared.ts) — the tools themselves stay plain, and args
+ * parse loosely so the extra fields still reach the resolver/handler.
  */
-export function buildAuthoringTools(host) {
-    const mk = (spec) => {
-        const extra = host.toolExtras?.[spec.name];
-        const required = [
-            ...(host.sessionSchema?.required ?? []),
-            ...(spec.required ?? []),
-            ...(extra?.required ?? []),
-        ];
-        const inputSchema = {
-            type: 'object',
-            properties: {
-                ...(host.sessionSchema?.properties ?? {}),
-                ...spec.properties,
-                ...(extra?.properties ?? {}),
-            },
-            ...(required.length ? { required } : {}),
-        };
-        return defineTool({
-            name: spec.name,
-            description: extra?.description ?? spec.description,
-            inputSchema,
-        }, (args) => spec.run(host.resolveBackend(args), args));
-    };
+export function authoringTools(resolveBackend) {
     return [
-        mk({
+        defineTool({
             name: 'navigate',
             description: 'Navigate the browser tab to a URL, waiting for load.',
-            properties: {
-                url: { type: 'string' },
-                timeoutMs: { type: 'number' },
-            },
-            required: ['url'],
-            run: async (backend, args) => {
-                const timeoutMs = Number(args.timeoutMs) || 30_000;
-                await backend.sendCdp('Page.enable');
-                // Start listening BEFORE navigating so the load event isn't missed.
-                const load = backend.waitForEvent('Page.loadEventFired', timeoutMs);
-                const nav = (await backend.sendCdp('Page.navigate', { url: String(args.url) }));
-                if (nav.errorText) {
-                    return { ok: false, error: nav.errorText };
-                }
-                const loadStatus = await load;
-                const final = await evalInPage(backend, 'location.href');
-                return { ok: true, loadStatus, finalUrl: final.value };
-            },
+            inputSchema: objectSchema({ url: { type: 'string' }, timeoutMs: { type: 'number' } }, ['url']),
+        }, async (args) => {
+            const backend = resolveBackend(args);
+            const timeoutMs = Number(args.timeoutMs) || 30_000;
+            await backend.sendCdp('Page.enable');
+            // Start listening BEFORE navigating so the load event isn't missed.
+            const load = backend.waitForEvent('Page.loadEventFired', timeoutMs);
+            const nav = (await backend.sendCdp('Page.navigate', { url: String(args.url) }));
+            if (nav.errorText) {
+                return { ok: false, error: nav.errorText };
+            }
+            const loadStatus = await load;
+            const final = await evalInPage(backend, 'location.href');
+            return { ok: true, loadStatus, finalUrl: final.value };
         }),
-        mk({
+        defineTool({
             name: 'eval_in_page',
             description: 'Evaluate a JavaScript expression in the page and return its value '
                 + '(use to read the displayed value, check login state, etc.).',
-            properties: { expression: { type: 'string' } },
-            required: ['expression'],
-            run: (backend, args) => evalInPage(backend, String(args.expression)),
-        }),
-        mk({
+            inputSchema: objectSchema({ expression: { type: 'string' } }, ['expression']),
+        }, (args) => evalInPage(resolveBackend(args), String(args.expression))),
+        defineTool({
             name: 'wait_for_page',
             description: 'Poll a JavaScript expression until it is truthy or the timeout '
                 + 'elapses (e.g. wait for the user to finish logging in).',
-            properties: {
-                expression: { type: 'string' },
-                timeoutMs: { type: 'number' },
-            },
-            required: ['expression'],
-            run: async (backend, args) => {
-                const expr = String(args.expression);
-                const deadline = Date.now() + (Number(args.timeoutMs) || 180_000);
-                while (Date.now() < deadline) {
-                    const { value } = await evalInPage(backend, expr);
-                    if (value) {
-                        return { ready: true };
-                    }
-                    await sleep(1000);
+            inputSchema: objectSchema({ expression: { type: 'string' }, timeoutMs: { type: 'number' } }, ['expression']),
+        }, async (args) => {
+            const backend = resolveBackend(args);
+            const expr = String(args.expression);
+            const deadline = Date.now() + (Number(args.timeoutMs) || 180_000);
+            while (Date.now() < deadline) {
+                const { value } = await evalInPage(backend, expr);
+                if (value) {
+                    return { ready: true };
                 }
-                return { ready: false };
-            },
+                await sleep(1000);
+            }
+            return { ready: false };
         }),
-        mk({
+        defineTool({
             name: 'get_cookies',
             description: 'List the NAMES of cookies currently set for the page (values are '
                 + 'NEVER returned). The most reliable, language- and DOM-independent '
                 + 'login signal: after the user logs in, an auth/session cookie '
                 + 'appears (e.g. session/sid/token/auth/jwt/_user/logged_in). '
                 + 'Includes httpOnly cookies the page JS cannot see.',
-            properties: {},
-            run: async (backend) => {
-                const res = (await backend.sendCdp('Network.getCookies'));
-                return (res.cookies ?? []).map((c) => ({
-                    name: c.name,
-                    ...(c.domain ? { domain: c.domain } : {}),
-                    ...(c.session ? { session: true } : {}),
-                    ...(c.httpOnly ? { httpOnly: true } : {}),
-                }));
-            },
+            inputSchema: objectSchema({}),
+        }, async (args) => {
+            const backend = resolveBackend(args);
+            const res = (await backend.sendCdp('Network.getCookies'));
+            return (res.cookies ?? []).map((c) => ({
+                name: c.name,
+                ...(c.domain ? { domain: c.domain } : {}),
+                ...(c.session ? { session: true } : {}),
+                ...(c.httpOnly ? { httpOnly: true } : {}),
+            }));
         }),
-        mk({
+        defineTool({
             name: 'list_requests',
             description: 'List captured network requests (method/url/status/size), newest '
                 + 'last. Optionally filter by method / urlGlob / status range / '
                 + 'contentType / graphqlOp. Metadata only — secrets never included.',
-            properties: {
+            inputSchema: objectSchema({
                 filter: {
                     type: 'object',
                     properties: {
@@ -173,206 +152,42 @@ export function buildAuthoringTools(host) {
                         graphqlOp: { type: 'string' },
                     },
                 },
-            },
-            run: async (backend, args) => {
-                const filter = (args.filter ?? {});
-                return [...backend.capture.requests.values()]
-                    .filter((r) => matchesFilter(r, filter))
-                    .map(publicRequest);
-            },
+            }),
+        }, async (args) => {
+            const backend = resolveBackend(args);
+            const filter = (args.filter ?? {});
+            return [...backend.capture.requests.values()]
+                .filter((r) => matchesFilter(r, filter))
+                .map(publicRequest);
         }),
-        mk({
-            name: 'find_requests_containing',
-            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.',
-            properties: {
-                value: { type: 'string' },
-                limit: { type: 'number' },
-            },
-            required: ['value'],
-            run: async (backend, args) => {
-                const variants = normalizeCandidates(String(args.value));
-                const ranked = [];
-                for (const r of backend.capture.requests.values()) {
-                    if (!r.responseBody) {
-                        continue;
-                    }
-                    let hit;
-                    for (const v of variants) {
-                        const idx = r.responseBody.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,
-                            };
-                            break;
-                        }
-                    }
-                    if (!hit) {
-                        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,
-                    });
-                }
-                ranked.sort((a, b) => b.score - a.score);
-                const limit = Number(args.limit) || 10;
-                return { candidates: ranked.slice(0, limit) };
-            },
-        }),
-        mk({
-            name: 'propose_provider',
-            description: 'Draft a provider from ONE captured request. Pass `targets` (an '
-                + 'array): one entry per value to extract, each with its `value` '
-                + '(verbatim) and a distinct `name` (its param). The provider gets '
-                + 'one match + redaction per target. Returns a draftId + recipe '
-                + '(never secrets). Prefer a SINGLE request holding ALL values. '
-                + 'Single-value shorthand: `target` + `name`. Per-target `hash` '
-                + 'OPRF-hashes that value.',
-            properties: {
-                requestId: { type: 'string' },
-                name: { type: 'string' },
-                targets: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            value: { type: 'string' },
-                            name: { type: 'string' },
-                            hash: {
-                                type: 'string',
-                                enum: ['oprf-raw', 'oprf', 'oprf-mpc'],
-                            },
-                        },
-                        required: ['value', 'name'],
-                    },
-                },
-                target: { type: 'string' },
-                hash: { type: 'string', enum: ['oprf-raw', 'oprf', 'oprf-mpc'] },
-            },
-            required: ['requestId', 'name'],
-            run: async (backend, args) => {
-                const requestId = String(args.requestId);
-                const providerName = String(args.name);
-                const defaultHash = args.hash;
-                // Explicit multi-value `targets`, else the single `target` shorthand.
-                const raw = Array.isArray(args.targets) ? args.targets : [];
-                const targets = raw.length
-                    ? raw.map((t) => {
-                        const o = t;
-                        return {
-                            value: String(o.value),
-                            name: String(o.name),
-                            ...(typeof o.hash === 'string'
-                                ? { hash: o.hash }
-                                : {}),
-                        };
-                    })
-                    : typeof args.target === 'string'
-                        ? [{
-                                value: args.target,
-                                name: providerName,
-                                ...(defaultHash ? { hash: defaultHash } : {}),
-                            }]
-                        : [];
-                if (targets.length === 0) {
-                    throw new Error('propose_provider needs a `target` value or a non-empty '
-                        + '`targets` array');
-                }
-                for (const t of targets) {
-                    if ((t.hash ?? defaultHash) !== undefined
-                        && t.value.length > 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`.');
-                    }
-                }
-                const captured = backend.capture.requests.get(requestId);
-                if (!captured) {
-                    throw new Error(`no captured request ${requestId}`);
-                }
-                if (!captured.responseBody) {
-                    throw new Error(`request body unavailable for ${requestId}`);
-                }
-                const { provider, secretRefs, extractions } = draftProvider(captured, targets, providerName, defaultHash);
-                // Materialize the real secret header values for later replay/prove;
-                // they stay in the server-side draft, never in this result.
-                const secrets = {};
-                for (const ref of secretRefs) {
-                    const real = captured.requestHeaders[ref.name];
-                    if (real !== undefined) {
-                        secrets[ref.name] = real;
-                    }
-                }
-                const draftId = backend.drafts.put({
-                    provider, secretRefs, secrets, requestId, extractions,
-                });
-                const warnings = verificationWarnings(provider);
-                return {
-                    draftId,
-                    provider,
-                    secretRefs,
-                    ...(warnings.length ? { verificationWarnings: warnings } : {}),
-                };
-            },
-        }),
-        mk({
-            name: 'replay_request',
-            description: 'Validate the drafted recipe before proving — confirm its selectors '
-                + 'extract the target value. Returns diagnostics; run before '
-                + 'proving. Set `withoutSecrets: true` for the AUTH-BOUND check: it '
-                + 're-issues the request with NO secrets/cookies (an anonymous '
-                + 'visitor). If the values still extract (valid:true), the endpoint '
-                + 'is PUBLIC and the proof would not bind to the user — reject it and '
-                + 'find an auth-bound request instead.',
-            properties: {
-                draftId: { type: 'string' },
-                withoutSecrets: { type: 'boolean' },
-            },
-            required: ['draftId'],
-            run: async (backend, args) => {
-                const draft = backend.drafts.get(String(args.draftId));
-                if (!draft) {
-                    throw new Error(`no draft ${String(args.draftId)}`);
-                }
-                return backend.replay(draft, {
-                    withoutSecrets: Boolean(args.withoutSecrets),
-                });
-            },
-        }),
-        mk({
+        findTool(resolveBackend),
+        proposeTool(resolveBackend),
+        replayTool(resolveBackend),
+        defineTool({
             name: 'run_proof',
             description: 'Prove the drafted recipe (zkTLS). Only call after replay_request '
                 + 'looks right. Returns the proof result.',
-            properties: { draftId: { type: 'string' } },
-            required: ['draftId'],
-            // The backend shapes its own result: the cloud returns a lean,
-            // secret-free summary (and records the proven recipe for publish); the
-            // MCP persists the claim + returns the rich developer view. The MCP adds
-            // `ownerAddress`/`attestorUrl` to the schema via the host's toolExtras.
-            run: async (backend, args) => {
-                const draft = backend.drafts.get(String(args.draftId));
-                if (!draft) {
-                    throw new Error(`no draft ${String(args.draftId)}`);
-                }
-                const opts = {};
-                if (typeof args.ownerAddress === 'string') {
-                    opts.ownerAddress = args.ownerAddress;
-                }
-                if (typeof args.attestorUrl === 'string') {
-                    opts.attestorUrl = args.attestorUrl;
-                }
-                return backend.prove(draft, opts);
-            },
+            inputSchema: objectSchema({ draftId: { type: 'string' } }, ['draftId']),
+        }, 
+        // The backend shapes its own result: the cloud returns a lean,
+        // secret-free summary (and records the proven recipe for publish); the
+        // MCP persists the claim + returns the rich developer view. The MCP adds
+        // `ownerAddress`/`attestorUrl` to the schema via `extendTool`; the
+        // handler reads them from args (loose parse keeps them).
+        async (args) => {
+            const backend = resolveBackend(args);
+            const draft = backend.drafts.get(String(args.draftId));
+            if (!draft) {
+                throw new Error(`no draft ${String(args.draftId)}`);
+            }
+            const opts = {};
+            if (typeof args.ownerAddress === 'string') {
+                opts.ownerAddress = args.ownerAddress;
+            }
+            if (typeof args.attestorUrl === 'string') {
+                opts.attestorUrl = args.attestorUrl;
+            }
+            return backend.prove(draft, opts);
         }),
     ];
 }

package/lib/authoring/util.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Small shared helpers for the authoring tools (see tools.ts). Kept separate so
+ * the per-tool files (find.ts, propose.ts, replay.ts) and the inline tools in
+ * tools.ts share one copy without a circular import.
+ */
+import type { JSONSchema } from 'zod/v4/core';
+import type { CapturedRequest } from '../provider/schema.ts';
+import type { AuthoringBackend } from './backend.ts';
+/**
+ * Resolves the session backend for a tool call. The MCP keys it by
+ * `args.captureId` (multi-session); the cloud loop returns its one run backend.
+ * Each authoring tool closes over this so the same tool works for both hosts.
+ */
+export type ResolveBackend = (args: Record<string, unknown>) => AuthoringBackend;
+/** Build an `object` JSON Schema for a tool input — a small literal shortener,
+ *  not a tool abstraction. */
+export declare function objectSchema(properties: Record<string, unknown>, required?: string[]): JSONSchema.ObjectSchema;
+/** Secret-free projection of a captured request for tool output. */
+export declare function publicRequest(r: CapturedRequest): {
+    graphqlOp?: string | undefined;
+    requestId: string;
+    method: string;
+    url: string;
+    status: number;
+    contentType: string;
+    size: number;
+};

package/lib/authoring/util.js

@@ -0,0 +1,21 @@
+/** Build an `object` JSON Schema for a tool input — a small literal shortener,
+ *  not a tool abstraction. */
+export function objectSchema(properties, required) {
+    return {
+        type: 'object',
+        properties,
+        ...(required?.length ? { required } : {}),
+    };
+}
+/** Secret-free projection of a captured request for tool output. */
+export function publicRequest(r) {
+    return {
+        requestId: r.requestId,
+        method: r.method,
+        url: r.url,
+        status: r.status,
+        contentType: r.contentType,
+        size: r.size,
+        ...(r.graphqlOp ? { graphqlOp: r.graphqlOp } : {}),
+    };
+}

package/lib/consts.d.ts

@@ -17,11 +17,12 @@
  */
 import { DEFAULT_BASE_URL } from '@reclaimprotocol/client';
 import { DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL } from './old/client.ts';
+import { DEFAULT_SDK_API_URL } from './old/sdk-client.ts';
 /** Public attestor websocket URL — fallback for `RECLAIM_ATTESTOR_URL`. */
 export declare const FALLBACK_ATTESTOR_URL = "wss://attestor.reclaimprotocol.org:444/ws";
 /** The devtools dashboard login page — fallback for `RECLAIM_OLD_LOGIN_URL`. */
 export declare const DEFAULT_LOGIN_URL = "https://dev.reclaimprotocol.org";
-export { DEFAULT_BASE_URL, DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL };
+export { DEFAULT_BASE_URL, DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL, DEFAULT_SDK_API_URL, };
 /** Pino log level. Read once at logger construction, so an eager const is
  *  safe (no test mutates LOG_LEVEL at runtime). */
 export declare const LOG_LEVEL: string;
@@ -47,6 +48,10 @@ export declare function agentDisabled(): boolean;
 export declare function oldApiUrl(): string;
 /** Old-devtools analytics-logs service base URL (separate host). */
 export declare function oldLogsUrl(): string;
+/** Public production SDK-backend base URL — the service the verification
+ *  SDK/attestor itself reads a provider's recipe from at runtime. A
+ *  DIFFERENT host from the old-devtools dashboard backend (`oldApiUrl`). */
+export declare function sdkApiUrl(): string;
 /** Builder backend base URL. Shared by mcp/start and the verification tool. */
 export declare function apiUrl(): string;
 /** Explicit builder API token (overrides the cached session token). */

package/lib/consts.js

@@ -19,6 +19,7 @@ import { DEFAULT_BASE_URL } from '@reclaimprotocol/client';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL } from "./old/client.js";
+import { DEFAULT_SDK_API_URL } from "./old/sdk-client.js";
 // ---------------------------------------------------------------------------
 // Default / fallback literals (used only as env fallbacks).
 // ---------------------------------------------------------------------------
@@ -26,9 +27,9 @@ import { DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL } from "./old/client.js";
 export const FALLBACK_ATTESTOR_URL = 'wss://attestor.reclaimprotocol.org:444/ws';
 /** The devtools dashboard login page — fallback for `RECLAIM_OLD_LOGIN_URL`. */
 export const DEFAULT_LOGIN_URL = 'https://dev.reclaimprotocol.org';
-// Re-export the two non-env-fallback defaults so callers can keep importing
+// Re-export the non-env-fallback defaults so callers can keep importing
 // their URL defaults from a single place if they wish.
-export { DEFAULT_BASE_URL, DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL };
+export { DEFAULT_BASE_URL, DEFAULT_OLD_API_URL, DEFAULT_OLD_LOGS_URL, DEFAULT_SDK_API_URL, };
 // ---------------------------------------------------------------------------
 // Logging.
 // ---------------------------------------------------------------------------
@@ -83,6 +84,12 @@ export function oldApiUrl() {
 export function oldLogsUrl() {
     return process.env.RECLAIM_OLD_LOGS_URL || DEFAULT_OLD_LOGS_URL;
 }
+/** Public production SDK-backend base URL — the service the verification
+ *  SDK/attestor itself reads a provider's recipe from at runtime. A
+ *  DIFFERENT host from the old-devtools dashboard backend (`oldApiUrl`). */
+export function sdkApiUrl() {
+    return process.env.RECLAIM_SDK_API_URL || DEFAULT_SDK_API_URL;
+}
 /** Builder backend base URL. Shared by mcp/start and the verification tool. */
 export function apiUrl() {
     return process.env.RECLAIM_API_URL || DEFAULT_BASE_URL;

package/lib/mcp/server.d.ts

@@ -1,45 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { JSONSchema } from 'zod/v4/core';
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    inputSchema: JSONSchema.ObjectSchema;
-}
-/**
- * Passed to every tool handler alongside its parsed args. Long-running,
- * human-in-the-loop tools (e.g. a browser login flow that waits for someone
- * to sign in) should call `reportProgress` every few seconds while waiting.
- * MCP clients that attach a progress token to their request (most desktop
- * clients do) treat an incoming `notifications/progress` as proof the call
- * is still alive and reset their own request timeout instead of giving up —
- * the SDK's client-side default is 60s, far shorter than a human can be
- * expected to take to log in. A no-op when the client didn't request
- * progress tracking for this call.
- */
-export interface ToolContext {
-    reportProgress: (message: string) => Promise<void>;
-}
-export interface RegisteredTool {
-    definition: ToolDefinition;
-    /**
-     * @param args Tool arguments
-     * @param ctx Progress-reporting context (see {@link ToolContext}).
-     *   Optional so direct/test callers can omit it.
-     * @returns A JSON stringifiable content to be returned to the llm
-     * @throws Any error encountered during tool execution will be caught and
-     * returned as a response using
-     * [remapErrorAsResponse](./src/mcp/remap_errors.ts).
-     */
-    handler: (args: unknown, ctx?: ToolContext) => Promise<unknown>;
-}
-/**
- * Define a tool with a single inputSchema (JSON Schema) used as the
- * source of truth. The handler receives args already parsed and
- * type-narrowed via a Zod schema derived from that same JSON Schema —
- * so the description sent to the MCP client and the validation applied
- * to inbound args cannot drift.
- */
-export declare function defineTool<TArgs>(definition: ToolDefinition, handler: (args: TArgs, ctx: ToolContext) => Promise<unknown>): RegisteredTool;
+import { type RegisteredTool } from '../tools/registry.ts';
+export { defineTool, type RegisteredTool, type ToolDefinition, } from '../tools/registry.ts';
 /**
  * Registers a list of RegisteredTool entries on a high-level McpServer.
  * Converts JSON Schema definitions to Zod and provides consistent