@toon-protocol/client-mcp 0.26.2

package/dist/index.d.ts

@@ -0,0 +1,642 @@
+import { NostrEvent } from 'nostr-tools/pure';
+import { ToonClientConfig } from '@toon-protocol/client';
+import { FastifyInstance } from 'fastify';
+
+/**
+ * Shared request/response contract for the `toon-clientd` localhost control
+ * plane. Both the daemon (server) and the MCP server / control-client (caller)
+ * import these types so the wire shape stays in lockstep.
+ *
+ * Every endpoint is plain JSON over HTTP on `127.0.0.1:<port>`. The daemon owns
+ * the long-lived BTP session + payment channels + relay subscription; callers
+ * are stateless and never see chain keys.
+ */
+
+/** The chain family a paid write settles on. */
+type SettlementChain = 'evm' | 'solana' | 'mina';
+/** Per-chain settlement readiness, mirrored from `ToonClient.getNetworkStatus()`. */
+interface ChainStatus {
+    chain: string;
+    /** Whether settlement is configured + the apex can verify inbound claims. */
+    ready: boolean;
+    detail?: string;
+}
+/** `GET /status` — daemon + connection health. */
+interface StatusResponse {
+    /** Daemon process uptime, ms. */
+    uptimeMs: number;
+    /**
+     * True while the managed anon proxy / BTP session / channel are still coming
+     * up. Tools should surface "bootstrapping — retry" rather than blocking.
+     */
+    bootstrapping: boolean;
+    /** True once the client has started and a channel is open (ready to publish). */
+    ready: boolean;
+    /** The active settlement chain for paid writes to the apex. */
+    settlementChain: SettlementChain;
+    identity: {
+        nostrPubkey: string;
+        evmAddress?: string;
+        solanaAddress?: string;
+        minaAddress?: string;
+    };
+    transport: {
+        type: 'direct' | 'socks5' | 'gateway';
+        socksProxy?: string;
+        btpUrl?: string;
+    };
+    relay: {
+        url: string;
+        connected: boolean;
+        /** Number of events currently held in the read buffer. */
+        buffered: number;
+        /** Active subscription ids. */
+        subscriptions: string[];
+    };
+    /** Per-chain settlement status when a named `network` tier is configured. */
+    network?: ChainStatus[];
+    /** Last error observed during bootstrap, if any (non-fatal). */
+    lastError?: string;
+}
+/** `POST /publish` — pay-to-write a single Nostr event. */
+interface PublishRequest {
+    /** A fully-signed Nostr event (id + sig present). */
+    event: NostrEvent;
+    /** ILP destination override (default: the configured apex/town address). */
+    destination?: string;
+    /** Fee override in base units. Defaults to the daemon's configured fee. */
+    fee?: string;
+}
+interface PublishResponse {
+    eventId: string;
+    /** FULFILL response data (base64), e.g. an Arweave tx id from a DVM. */
+    data?: string;
+    /** Channel the claim was signed against. */
+    channelId: string;
+    /** Channel nonce after this publish (advances by one per paid write). */
+    nonce: number;
+}
+/** `POST /subscribe` — register a persistent free-read subscription. */
+interface SubscribeRequest {
+    /** NIP-01 filter(s). A single object or an array of OR-ed filters. */
+    filters: NostrFilter | NostrFilter[];
+    /** Optional caller-supplied subscription id (else one is generated). */
+    subId?: string;
+}
+interface SubscribeResponse {
+    subId: string;
+}
+/** `GET /events` — drain buffered events for a subscription (free read). */
+interface EventsQuery {
+    /** Restrict to a single subscription id. */
+    subId?: string;
+    /** Cursor from a prior `EventsResponse.cursor`; returns only newer events. */
+    cursor?: number;
+    /** Max events to return (default 200). */
+    limit?: number;
+}
+interface EventsResponse {
+    events: NostrEvent[];
+    /** Opaque monotonic cursor; pass back to fetch only events after these. */
+    cursor: number;
+    /** Whether more events remain beyond `limit`. */
+    hasMore: boolean;
+}
+/** `POST /channels` — open (or return existing) a payment channel. */
+interface OpenChannelRequest {
+    /** ILP destination of the peer to open against (default: configured apex). */
+    destination?: string;
+}
+interface ChannelInfo {
+    channelId: string;
+    nonce: number;
+    cumulativeAmount: string;
+}
+/** `GET /channels` — list tracked channels with nonce watermarks. */
+interface ChannelsResponse {
+    channels: ChannelInfo[];
+}
+/** `POST /swap` — pay asset A to a mill peer, receive asset B + a target claim. */
+interface SwapRequest {
+    /** Mill peer ILP destination. */
+    destination: string;
+    /** Amount to send in base units. */
+    amount: string;
+    /** Optional base64 TOON payload describing the swap intent. */
+    toonData?: string;
+}
+interface SwapResponse {
+    accepted: boolean;
+    /** base64 FULFILL data (the signed target-chain claim), when accepted. */
+    data?: string;
+    code?: string;
+    message?: string;
+}
+/** Uniform error envelope returned with non-2xx responses. */
+interface ErrorResponse {
+    error: string;
+    detail?: string;
+    /** True when the caller should retry (e.g. still bootstrapping). */
+    retryable?: boolean;
+}
+/**
+ * NIP-01 subscription filter. Tag filters use `#<single-letter>` keys, e.g.
+ * `{ '#e': [...], '#p': [...] }`.
+ */
+interface NostrFilter {
+    ids?: string[];
+    authors?: string[];
+    kinds?: number[];
+    since?: number;
+    until?: number;
+    limit?: number;
+    search?: string;
+    [tag: `#${string}`]: string[] | undefined;
+}
+
+/**
+ * Thin HTTP client for the `toon-clientd` localhost control plane. Used by the
+ * MCP server (and any other caller) to drive the daemon without holding any
+ * chain keys or long-lived connections itself.
+ */
+
+/** Error thrown when the daemon returns a non-2xx response. */
+declare class ControlApiError extends Error {
+    readonly status: number;
+    readonly retryable: boolean;
+    readonly detail?: string | undefined;
+    constructor(message: string, status: number, retryable: boolean, detail?: string | undefined);
+}
+/** Thrown when the daemon is unreachable (not running / wrong port). */
+declare class DaemonUnreachableError extends Error {
+    readonly baseUrl: string;
+    readonly causedBy?: unknown | undefined;
+    constructor(baseUrl: string, causedBy?: unknown | undefined);
+}
+interface ControlClientOptions {
+    /** Base URL of the daemon, e.g. `http://127.0.0.1:8787`. */
+    baseUrl: string;
+    /** Per-request timeout, ms. Default 35000 (publishes can wait on FULFILL). */
+    timeoutMs?: number;
+    /** Inject a fetch implementation (tests). Defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+declare class ControlClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(opts: ControlClientOptions);
+    /** True if the daemon answers `GET /status` (used as a liveness probe). */
+    ping(): Promise<boolean>;
+    status(): Promise<StatusResponse>;
+    publish(body: PublishRequest): Promise<PublishResponse>;
+    subscribe(body: SubscribeRequest): Promise<SubscribeResponse>;
+    events(query?: EventsQuery): Promise<EventsResponse>;
+    openChannel(body?: OpenChannelRequest): Promise<{
+        channelId: string;
+    }>;
+    channels(): Promise<ChannelsResponse>;
+    swap(body: SwapRequest): Promise<SwapResponse>;
+    private request;
+}
+
+/**
+ * Persistent town-relay Nostr-WS subscription — the read half of the TOON
+ * client, which `@toon-protocol/client` does not provide (its bootstrap only
+ * issues one-shot WS queries and `DiscoveryTracker` is passive).
+ *
+ * Reads are FREE: this opens a long-lived NIP-01 connection to the town relay,
+ * keeps a bounded ring buffer of received events (de-duplicated by `event.id`),
+ * and lets callers drain new events via a monotonic cursor. It auto-reconnects
+ * with exponential backoff and re-issues every active REQ on reconnect.
+ *
+ * The WebSocket is injectable (`wsFactory`) so unit tests can drive the wire
+ * protocol without a real relay; the default factory uses the `ws` package and,
+ * when a `socks5h://` proxy is configured, routes through it so `.anyone`
+ * hidden-service relays are reachable.
+ */
+
+/** Minimal WebSocket surface this module depends on (subset of `ws`). */
+interface MinimalWebSocket {
+    send(data: string): void;
+    close(): void;
+    on(event: 'open' | 'close', cb: () => void): void;
+    on(event: 'message', cb: (data: unknown) => void): void;
+    on(event: 'error', cb: (err: unknown) => void): void;
+}
+type WebSocketFactory = (url: string) => MinimalWebSocket;
+interface RelaySubscriptionOptions {
+    /** Town relay WS URL, e.g. `wss://<host>.anyone/` or `ws://localhost:7100`. */
+    relayUrl: string;
+    /** Optional `socks5h://host:port` proxy for `.anyone` relays. */
+    socksProxy?: string;
+    /** Max events retained in the ring buffer (oldest evicted). Default 5000. */
+    bufferSize?: number;
+    /** Base reconnect delay, ms. Default 1000. */
+    reconnectBaseMs?: number;
+    /** Max reconnect delay, ms. Default 30000. */
+    reconnectMaxMs?: number;
+    /** Inject a WebSocket factory (tests / proxy customisation). */
+    wsFactory?: WebSocketFactory;
+    /**
+     * Decode an `EVENT` payload that arrived as a string. The TOON relay sends
+     * events TOON-encoded (key/value text) rather than as a JSON object, so the
+     * daemon injects a TOON decoder here. When the payload is already a JSON
+     * object it is used directly and this is not called.
+     */
+    decodeEvent?: (raw: string) => NostrEvent;
+    /** Optional logger. */
+    logger?: (msg: string) => void;
+}
+/** Result of {@link RelaySubscription.getEvents}. */
+interface DrainResult {
+    events: NostrEvent[];
+    cursor: number;
+    hasMore: boolean;
+}
+declare class RelaySubscription {
+    private readonly relayUrl;
+    private readonly socksProxy?;
+    private readonly bufferSize;
+    private readonly reconnectBaseMs;
+    private readonly reconnectMaxMs;
+    private readonly log;
+    private readonly wsFactory;
+    private readonly decodeEvent?;
+    /** Active subscriptions: subId -> filters (re-sent on every (re)connect). */
+    private readonly subscriptions;
+    /** Ring buffer of received events, ordered by ascending `seq`. */
+    private buffer;
+    /** De-dup index: event.id -> seq (kept in lockstep with the buffer). */
+    private readonly seen;
+    private seqCounter;
+    private subIdCounter;
+    private ws;
+    private connected;
+    private closing;
+    private reconnectAttempts;
+    private reconnectTimer;
+    constructor(opts: RelaySubscriptionOptions);
+    /** Whether the underlying socket is currently open. */
+    isConnected(): boolean;
+    /** Number of events currently held in the buffer. */
+    bufferedCount(): number;
+    /** Active subscription ids. */
+    activeSubscriptions(): string[];
+    /** Open the connection (idempotent). */
+    start(): void;
+    /**
+     * Register a persistent subscription and (if connected) send the REQ.
+     * Returns the subscription id (caller-supplied or generated).
+     */
+    subscribe(filters: NostrFilter | NostrFilter[], subId?: string): string;
+    /** Cancel a subscription and send CLOSE if connected. */
+    unsubscribe(subId: string): void;
+    /**
+     * Drain events newer than `cursor`. The cursor is the highest `seq` returned;
+     * pass it back to fetch only events received since. Filtering by `subId`
+     * restricts to one subscription.
+     */
+    getEvents(opts?: {
+        subId?: string;
+        cursor?: number;
+        limit?: number;
+    }): DrainResult;
+    /** Close the connection permanently and stop reconnecting. */
+    close(): void;
+    private open;
+    private scheduleReconnect;
+    private sendReq;
+    private sendRaw;
+    private handleMessage;
+    /**
+     * Normalise an `EVENT` payload to a NostrEvent. Standard relays send a JSON
+     * object; the TOON relay sends a TOON-encoded string, decoded via the injected
+     * `decodeEvent`. Returns undefined when it can't be parsed.
+     */
+    private parseEventPayload;
+    private bufferEvent;
+}
+
+/**
+ * Daemon configuration: resolved from a JSON config file and/or environment
+ * variables, then expanded into a `ToonClientConfig` (BTP + channels + signer)
+ * plus daemon-only settings (HTTP port, relay URL, apex negotiation).
+ *
+ * The mnemonic is sourced from (in precedence order):
+ *   1. `TOON_CLIENT_MNEMONIC` env var,
+ *   2. an encrypted keystore (#207) at `keystorePath`, decrypted with
+ *      `TOON_CLIENT_KEYSTORE_PASSWORD`,
+ *   3. the `mnemonic` field of the config file (discouraged — plaintext on disk).
+ */
+
+/** Apex/town settlement parameters injected as a peer negotiation. */
+interface ApexNegotiationConfig {
+    /** ILP destination address, e.g. `g.townhouse.town`. */
+    destination: string;
+    /** Peer id key used in the negotiation map (last ILP segment, e.g. `town`). */
+    peerId: string;
+    /** Settlement chain family. */
+    chain: SettlementChain;
+    /** Negotiated chain key, e.g. `evm:base:84532`. */
+    chainKey: string;
+    /** Numeric chain id (EVM only; 0 for solana/mina). */
+    chainId: number;
+    /** The apex's settlement (receive) address on `chain`. */
+    settlementAddress: string;
+    /** Token contract / mint / zkApp address. */
+    tokenAddress?: string;
+    /** EVM TokenNetwork / Solana programId / Mina zkApp address. */
+    tokenNetwork?: string;
+}
+interface DaemonConfigFile {
+    /** Named network tier (drives settlement presets, #209). */
+    network?: 'mainnet' | 'testnet' | 'devnet' | 'custom';
+    mnemonic?: string;
+    mnemonicAccountIndex?: number;
+    keystorePath?: string;
+    /** BTP WebSocket URL of the apex/connector. */
+    btpUrl?: string;
+    /** Transport: `direct` or a `socks5h://` proxy for `.anyone` hosts. */
+    socksProxy?: string;
+    /** Auto-manage the anon proxy for `.anyone` BTP hosts. Default true for HS. */
+    managedAnonProxy?: boolean;
+    /** Loopback SOCKS port the managed anon proxy binds (also used for reads). Default 9050. */
+    managedAnonSocksPort?: number;
+    /** Town relay WS URL for FREE reads. */
+    relayUrl?: string;
+    /** Default ILP publish destination. Default `g.townhouse.town`. */
+    destination?: string;
+    /** Default fee per paid write, base units. Default `1`. */
+    feePerEvent?: string;
+    /** Channel nonce-watermark persistence file. Default `<dir>/channels.json`. */
+    channelStorePath?: string;
+    /** Localhost control-plane port. Default 8787. */
+    httpPort?: number;
+    /**
+     * Active settlement chain for paid writes to the apex. A single daemon settles
+     * to a given peer on ONE chain (the `ChannelManager` keys channels per peer +
+     * each `ToonClient` owns one BTP session). Default `evm`. Override with
+     * `TOON_CLIENT_CHAIN`. For simultaneous multi-chain, run one daemon per chain
+     * (distinct `httpPort` + `channelStorePath`).
+     */
+    chain?: SettlementChain;
+    /** Manual apex negotiation (HS / direct-apex mode where bootstrap finds 0 peers). */
+    apex?: ApexNegotiationConfig;
+    /**
+     * Per-chain apex negotiations. The entry for the active `chain` is used; the
+     * others are retained so switching chains needs only a `chain`/restart change.
+     */
+    apexChains?: Partial<Record<SettlementChain, ApexNegotiationConfig>>;
+    /** Extra settlement overrides passed straight through to ToonClient. */
+    supportedChains?: string[];
+    settlementAddresses?: Record<string, string>;
+    preferredTokens?: Record<string, string>;
+    tokenNetworks?: Record<string, string>;
+    chainRpcUrls?: Record<string, string>;
+    /** Solana on-chain payment-channel params (required when `chain` is solana). */
+    solanaChannel?: ToonClientConfig['solanaChannel'];
+    /** Mina on-chain payment-channel params (required when `chain` is mina). */
+    minaChannel?: ToonClientConfig['minaChannel'];
+}
+interface ResolvedDaemonConfig {
+    httpPort: number;
+    relayUrl: string;
+    socksProxy?: string;
+    destination: string;
+    feePerEvent: bigint;
+    apex?: ApexNegotiationConfig;
+    /** The active settlement chain for paid writes. */
+    chain: SettlementChain;
+    /** File mapping (destination, chain) → on-chain channelId for restart resume. */
+    apexChannelStorePath: string;
+    /** Fully-built config for the `ToonClient` constructor. */
+    toonClientConfig: ToonClientConfig;
+    network?: string;
+}
+/** Default config directory: `~/.toon-client`. Overridable via env. */
+declare function configDir(): string;
+/** Default config file path. */
+declare function defaultConfigPath(): string;
+/** Read + parse the JSON config file, returning `{}` when absent. */
+declare function readConfigFile(path: string): DaemonConfigFile;
+/** Resolve the mnemonic from env / keystore / config (in precedence order). */
+declare function resolveMnemonic(file: DaemonConfigFile): string;
+/**
+ * Build the full resolved daemon config (file overlaid with env, mnemonic
+ * resolved, ToonClientConfig assembled). Env overrides supported:
+ *   TOON_CLIENT_BTP_URL, TOON_CLIENT_RELAY_URL, TOON_CLIENT_SOCKS,
+ *   TOON_CLIENT_HTTP_PORT, TOON_CLIENT_NETWORK.
+ */
+declare function resolveConfig(file: DaemonConfigFile): ResolvedDaemonConfig;
+
+/**
+ * ClientRunner — the daemon's connection owner. Wraps a single `ToonClient`
+ * (BTP session + payment channels + signer) plus a persistent
+ * `RelaySubscription` (free reads), and exposes the high-level operations the
+ * HTTP routes map onto.
+ *
+ * Bootstrap is asynchronous and non-blocking: `start()` returns immediately and
+ * the connection comes up in the background (the managed anon proxy alone can
+ * take 30–90s). Until it is ready, write operations report `bootstrapping` so
+ * tools surface "retry" rather than hang.
+ *
+ * The `ToonClient` is injected via `ToonClientLike` so unit tests can drive the
+ * runner with a fake — no BTP/anon/on-chain dependency.
+ */
+
+/** The subset of `ToonClient` the runner depends on. */
+interface ToonClientLike {
+    start(): Promise<{
+        peersDiscovered: number;
+        mode: string;
+    }>;
+    stop(): Promise<void>;
+    getPublicKey(): string;
+    getEvmAddress(): string | undefined;
+    getSolanaAddress(): string | undefined;
+    getMinaAddress(): string | undefined;
+    getNetworkStatus(): {
+        evm: string;
+        solana: string;
+        mina: string;
+    } | undefined;
+    publishEvent(event: NostrEvent, options?: {
+        destination?: string;
+        claim?: unknown;
+        ilpAmount?: bigint;
+    }): Promise<{
+        success: boolean;
+        eventId?: string;
+        data?: string;
+        error?: string;
+    }>;
+    signBalanceProof(channelId: string, amount: bigint): Promise<unknown>;
+    openChannel(destination?: string): Promise<string>;
+    getTrackedChannels(): string[];
+    getChannelNonce(channelId: string): number;
+    getChannelCumulativeAmount(channelId: string): bigint;
+    sendSwapPacket(params: {
+        destination: string;
+        amount: bigint;
+        toonData: Uint8Array;
+        claim?: unknown;
+    }): Promise<{
+        accepted: boolean;
+        data?: string;
+        code?: string;
+        message?: string;
+    }>;
+}
+interface ClientRunnerDeps {
+    config: ResolvedDaemonConfig;
+    /** Factory producing the (real or fake) ToonClient. */
+    createClient: () => ToonClientLike;
+    /** Factory producing the relay subscription (defaults to the real one). */
+    createRelay?: () => RelaySubscription;
+    logger?: (msg: string) => void;
+}
+declare class ClientRunner {
+    private readonly config;
+    private readonly client;
+    private readonly relay;
+    private readonly log;
+    private readonly startedAt;
+    private bootstrapping;
+    private ready;
+    private lastError;
+    /** Channel opened against the default apex destination. */
+    private apexChannelId;
+    private stopped;
+    constructor(deps: ClientRunnerDeps);
+    /**
+     * Begin bootstrapping in the background. Resolves once kicked off; the
+     * connection becomes ready asynchronously. Awaitable for tests via the
+     * returned promise of the underlying work.
+     */
+    start(): void;
+    /** The background bootstrap routine (exposed for awaiting in tests). */
+    bootstrap(): Promise<void>;
+    /**
+     * Open the apex channel — or, on a restart, RESUME the existing one.
+     *
+     * `ChannelManager` persists the nonce watermark (by channelId) but not the
+     * peer→channelId mapping, so a naive `openChannel()` after restart re-deposits
+     * into a fresh channel and reverts on-chain. We persist the channelId here and,
+     * when present, `trackChannel()` the live channel (which rehydrates the nonce
+     * from the channel store) — no on-chain write, watermark continues.
+     */
+    private openOrResumeApexChannel;
+    /**
+     * Inject the apex settlement negotiation directly into the ToonClient when
+     * configured. Required for HS / direct-apex mode where bootstrap discovers 0
+     * peers (no relay-based discovery). Mirrors the docker entrypoint's approach.
+     */
+    private injectApexNegotiation;
+    isReady(): boolean;
+    isBootstrapping(): boolean;
+    getStatus(): StatusResponse;
+    /** Pay-to-write a single event. Throws NOT_READY while bootstrapping. */
+    publish(req: PublishRequest): Promise<PublishResponse>;
+    /** Register a free-read subscription (does not require the paid path). */
+    subscribe(req: SubscribeRequest): SubscribeResponse;
+    /** Drain buffered events newer than the cursor (free read). */
+    getEvents(query: EventsQuery): EventsResponse;
+    /** Open (or return) a payment channel for a destination. */
+    openChannel(destination?: string): Promise<{
+        channelId: string;
+    }>;
+    /** List tracked channels with their nonce watermark + cumulative amount. */
+    getChannels(): ChannelsResponse;
+    /** Send a swap packet to a mill peer. */
+    swap(req: SwapRequest): Promise<SwapResponse>;
+    /** Graceful teardown of the relay subscription + ToonClient. */
+    stop(): Promise<void>;
+    private assertReady;
+}
+/** Thrown by paid-write operations while the daemon is not yet ready. */
+declare class NotReadyError extends Error {
+    readonly retryable = true;
+    constructor(message: string);
+}
+/** Thrown when the relay/connector rejects a paid write. */
+declare class PublishRejectedError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Fastify route registration for the `toon-clientd` control plane. Each route
+ * is a thin adapter: parse/validate the request, call the `ClientRunner`, map
+ * errors to the uniform `ErrorResponse` envelope.
+ *
+ * Bound to loopback only by the daemon entry — there is no auth layer because
+ * the surface never leaves `127.0.0.1`.
+ */
+
+declare function registerRoutes(app: FastifyInstance, runner: ClientRunner): void;
+
+/** Whether a process with `pid` is currently alive. */
+declare function isProcessAlive(pid: number): boolean;
+/** Read the recorded daemon PID, or null when absent/invalid. */
+declare function readPid(path?: string): number | null;
+/**
+ * Acquire the single-instance lock for the current process. Throws if another
+ * live daemon already holds it. Reclaims a stale lock (dead PID).
+ */
+declare function acquireLock(path?: string): void;
+/** Release the lock if it belongs to this process. */
+declare function releaseLock(path?: string): void;
+/** Whether a daemon is currently running per the PID lock. */
+declare function isDaemonRunning(path?: string): boolean;
+interface SpawnDaemonOptions {
+    /** Path to the `toon-clientd` bin (defaults to this package's daemon entry). */
+    daemonEntry?: string;
+    /** Extra env for the spawned process. */
+    env?: NodeJS.ProcessEnv;
+    /** Directory for the detached stdout/stderr log. */
+    logDir?: string;
+}
+/**
+ * Spawn the daemon as a detached, fully background process (survives the
+ * parent — e.g. the ephemeral MCP/agent session — exiting). Returns the child
+ * PID. The caller should poll {@link waitForReady} before issuing requests.
+ */
+declare function spawnDaemonDetached(opts?: SpawnDaemonOptions): number;
+/**
+ * Poll the control plane until the daemon answers `GET /status`, up to
+ * `timeoutMs`. Resolves true once reachable (NOT necessarily done
+ * bootstrapping — anon can take 30–90s; callers surface `bootstrapping`).
+ */
+declare function waitForReady(baseUrl: string, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
+
+/**
+ * MCP tool definitions + dispatch. The MCP server is a thin proxy: each tool
+ * maps to a `toon-clientd` control-plane call. This module is the testable core
+ * (no stdio / SDK transport) so the tool→HTTP mapping and the
+ * "bootstrapping — retry" handling can be unit-tested directly.
+ */
+
+/** A JSON-Schema-described MCP tool. */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** MCP tool-call result shape (subset of the SDK's CallToolResult). */
+interface ToolResult {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+}
+declare const TOOL_DEFINITIONS: ToolDefinition[];
+/**
+ * Dispatch an MCP tool call to the daemon control plane. Always resolves with a
+ * `ToolResult` (errors are encoded as `isError: true` text, not thrown, so the
+ * agent sees a readable message). A retryable error (daemon still
+ * bootstrapping) yields a clear "retry shortly" message.
+ */
+declare function dispatchTool(client: ControlClient, name: string, args: Record<string, unknown>): Promise<ToolResult>;
+
+export { type ApexNegotiationConfig, type ChainStatus, type ChannelInfo, type ChannelsResponse, ClientRunner, type ClientRunnerDeps, ControlApiError, ControlClient, type ControlClientOptions, type DaemonConfigFile, DaemonUnreachableError, type DrainResult, type ErrorResponse, type EventsQuery, type EventsResponse, type MinimalWebSocket, type NostrFilter, NotReadyError, type OpenChannelRequest, PublishRejectedError, type PublishRequest, type PublishResponse, RelaySubscription, type RelaySubscriptionOptions, type ResolvedDaemonConfig, type SettlementChain, type StatusResponse, type SubscribeRequest, type SubscribeResponse, type SwapRequest, type SwapResponse, TOOL_DEFINITIONS, type ToolDefinition, type ToolResult, type ToonClientLike, type WebSocketFactory, acquireLock, configDir, defaultConfigPath, dispatchTool, isDaemonRunning, isProcessAlive, readConfigFile, readPid, registerRoutes, releaseLock, resolveConfig, resolveMnemonic, spawnDaemonDetached, waitForReady };

package/dist/index.js

@@ -0,0 +1,59 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+import {
+  ClientRunner,
+  NotReadyError,
+  PublishRejectedError,
+  RelaySubscription,
+  registerRoutes
+} from "./chunk-2SGZPDGE.js";
+import {
+  TOOL_DEFINITIONS,
+  dispatchTool
+} from "./chunk-5YIZ2JQO.js";
+import {
+  ControlApiError,
+  ControlClient,
+  DaemonUnreachableError,
+  acquireLock,
+  configDir,
+  defaultConfigPath,
+  isDaemonRunning,
+  isProcessAlive,
+  readConfigFile,
+  readPid,
+  releaseLock,
+  resolveConfig,
+  resolveMnemonic,
+  spawnDaemonDetached,
+  waitForReady
+} from "./chunk-WMYY5I3H.js";
+import "./chunk-32QD72IL.js";
+import "./chunk-QTDCFXPF.js";
+import "./chunk-LR7W2ISE.js";
+import "./chunk-VA7XC4FD.js";
+import "./chunk-245J23EB.js";
+export {
+  ClientRunner,
+  ControlApiError,
+  ControlClient,
+  DaemonUnreachableError,
+  NotReadyError,
+  PublishRejectedError,
+  RelaySubscription,
+  TOOL_DEFINITIONS,
+  acquireLock,
+  configDir,
+  defaultConfigPath,
+  dispatchTool,
+  isDaemonRunning,
+  isProcessAlive,
+  readConfigFile,
+  readPid,
+  registerRoutes,
+  releaseLock,
+  resolveConfig,
+  resolveMnemonic,
+  spawnDaemonDetached,
+  waitForReady
+};
+//# sourceMappingURL=index.js.map