@toon-protocol/client-mcp 0.1.0 → 0.2.0

package/dist/chunk-KNQ2DKNN.js

@@ -0,0 +1,861 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+import {
+  ControlApiError,
+  DaemonUnreachableError
+} from "./chunk-NP35YO5O.js";
+
+// ../views/dist/tool-names.js
+var PUBLISH_TOOL = "toon_publish_unsigned";
+var UPLOAD_TOOL = "toon_upload_media";
+var APP_RESOURCE_URI = "ui://toon/app";
+var WRITE_TOOLS = /* @__PURE__ */ new Set([PUBLISH_TOOL, UPLOAD_TOOL]);
+
+// ../views/dist/filters.js
+function buildRepoListFilter() {
+  return { kinds: [30617] };
+}
+function buildIssueListFilter(ownerPubkey, repoId) {
+  return { kinds: [1621], "#a": [`30617:${ownerPubkey}:${repoId}`], limit: 100 };
+}
+function buildCommentFilter(eventIds) {
+  return { kinds: [1622], "#e": eventIds, limit: 500 };
+}
+function buildEventByIdFilter(eventIds) {
+  return { ids: eventIds };
+}
+function buildProfileFilter(pubkeys) {
+  return { kinds: [0], authors: pubkeys };
+}
+function buildFeedFilter(authors, limit = 100) {
+  const f = { kinds: [1], limit };
+  if (authors && authors.length > 0)
+    f.authors = authors;
+  return f;
+}
+function buildMediaFeedFilter(authors, limit = 100) {
+  const f = { kinds: [20, 21, 22], limit };
+  if (authors && authors.length > 0)
+    f.authors = authors;
+  return f;
+}
+
+// ../views/dist/spec.js
+var DEFAULT_MAX_DEPTH = 32;
+var DEFAULT_MAX_NODES = 500;
+var FILTER_ARRAY_KEYS = /* @__PURE__ */ new Set([
+  "kinds",
+  "authors",
+  "ids",
+  "#d",
+  "#e",
+  "#a",
+  "#p",
+  "#t"
+]);
+var FILTER_NUM_KEYS = /* @__PURE__ */ new Set(["since", "until", "limit"]);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function toSet(v) {
+  return v instanceof Set ? v : new Set(v);
+}
+function validateFilter(filter, path, errors) {
+  if (!isPlainObject(filter)) {
+    errors.push(`${path}: filter must be an object`);
+    return;
+  }
+  for (const [key, value] of Object.entries(filter)) {
+    if (FILTER_ARRAY_KEYS.has(key)) {
+      if (!Array.isArray(value) || !value.every((x) => typeof x === "string" || typeof x === "number")) {
+        errors.push(`${path}.${key}: must be an array of string/number`);
+      }
+    } else if (FILTER_NUM_KEYS.has(key)) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        errors.push(`${path}.${key}: must be a finite number`);
+      }
+    } else {
+      errors.push(`${path}.${key}: unsupported filter key`);
+    }
+  }
+}
+function isJsonSafe(value, depth = 0) {
+  if (depth > 8)
+    return false;
+  if (value === null)
+    return true;
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return true;
+    case "number":
+      return Number.isFinite(value);
+    case "object":
+      if (Array.isArray(value))
+        return value.every((v) => isJsonSafe(v, depth + 1));
+      if (isPlainObject(value))
+        return Object.values(value).every((v) => isJsonSafe(v, depth + 1));
+      return false;
+    default:
+      return false;
+  }
+}
+function validateViewSpec(input, opts) {
+  const errors = [];
+  const allowedAtoms = toSet(opts.allowedAtoms);
+  const allowedTools = opts.allowedTools ? toSet(opts.allowedTools) : void 0;
+  const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const maxNodes = opts.maxNodes ?? DEFAULT_MAX_NODES;
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["spec must be an object"] };
+  }
+  if (input["title"] !== void 0 && typeof input["title"] !== "string") {
+    errors.push("spec.title: must be a string");
+  }
+  if (!isPlainObject(input["root"])) {
+    return { ok: false, errors: ["spec.root: required object"] };
+  }
+  let nodeCount = 0;
+  const walk = (node, path, depth) => {
+    if (depth > maxDepth) {
+      errors.push(`${path}: exceeds max depth ${maxDepth}`);
+      return;
+    }
+    if (++nodeCount > maxNodes) {
+      errors.push(`spec: exceeds max node count ${maxNodes}`);
+      return;
+    }
+    if (!isPlainObject(node)) {
+      errors.push(`${path}: node must be an object`);
+      return;
+    }
+    if (typeof node["atom"] !== "string") {
+      errors.push(`${path}.atom: must be a string`);
+    } else if (!allowedAtoms.has(node["atom"])) {
+      errors.push(`${path}.atom: unknown atom "${node["atom"]}"`);
+    }
+    if (node["props"] !== void 0) {
+      if (!isPlainObject(node["props"]) || !isJsonSafe(node["props"])) {
+        errors.push(`${path}.props: must be a JSON-serializable object`);
+      }
+    }
+    if (node["bind"] !== void 0) {
+      const bind = node["bind"];
+      if (!isPlainObject(bind)) {
+        errors.push(`${path}.bind: must be an object`);
+      } else {
+        if (bind["query"] !== void 0)
+          validateFilter(bind["query"], `${path}.bind.query`, errors);
+        if (bind["eventId"] !== void 0 && typeof bind["eventId"] !== "string") {
+          errors.push(`${path}.bind.eventId: must be a string`);
+        }
+        if (bind["kindAuto"] !== void 0 && typeof bind["kindAuto"] !== "boolean") {
+          errors.push(`${path}.bind.kindAuto: must be a boolean`);
+        }
+      }
+    }
+    if (node["actions"] !== void 0) {
+      const actions = node["actions"];
+      if (!isPlainObject(actions)) {
+        errors.push(`${path}.actions: must be an object`);
+      } else {
+        for (const [name, ref] of Object.entries(actions)) {
+          const p = `${path}.actions.${name}`;
+          if (!isPlainObject(ref)) {
+            errors.push(`${p}: must be an object`);
+            continue;
+          }
+          if (typeof ref["tool"] !== "string") {
+            errors.push(`${p}.tool: must be a string`);
+          } else if (allowedTools && !allowedTools.has(ref["tool"])) {
+            errors.push(`${p}.tool: tool "${ref["tool"]}" not allowed`);
+          }
+          if (ref["args"] !== void 0 && (!isPlainObject(ref["args"]) || !isJsonSafe(ref["args"]))) {
+            errors.push(`${p}.args: must be a JSON-serializable object`);
+          }
+          if (ref["spendy"] !== void 0 && typeof ref["spendy"] !== "boolean") {
+            errors.push(`${p}.spendy: must be a boolean`);
+          }
+          if (ref["confirmLabel"] !== void 0 && typeof ref["confirmLabel"] !== "string") {
+            errors.push(`${p}.confirmLabel: must be a string`);
+          }
+        }
+      }
+    }
+    if (node["children"] !== void 0) {
+      if (!Array.isArray(node["children"])) {
+        errors.push(`${path}.children: must be an array`);
+      } else {
+        node["children"].forEach((child, i) => walk(child, `${path}.children[${i}]`, depth + 1));
+      }
+    }
+  };
+  walk(input["root"], "spec.root", 0);
+  if (errors.length > 0)
+    return { ok: false, errors };
+  return { ok: true, spec: input };
+}
+
+// ../views/dist/catalog.js
+var ATOM_CATALOG = [
+  // layout
+  {
+    id: "stack",
+    description: "Vertical (default) or horizontal stack of child nodes.",
+    propsSchema: { direction: "'row' | 'col'", gap: "number (tailwind gap step)" }
+  },
+  { id: "section", description: "Titled section wrapper.", propsSchema: { title: "string" } },
+  { id: "card", description: "Bordered card container." },
+  {
+    id: "tabs",
+    description: "Tabbed container; one child node per tab. Use for multi-section journeys.",
+    propsSchema: { labels: "string[] (tab names, in child order)" }
+  },
+  // social
+  { id: "profile-header", description: "NIP-01 kind:0 profile header (avatar, name, nip05, bio).", kinds: [0] },
+  { id: "note-card", description: 'NIP-01 kind:1 text note; optional "reply" action.', kinds: [1] },
+  { id: "reaction-bar", description: 'NIP-25 kind:7 reaction counts; optional "react" action.', kinds: [7] },
+  {
+    id: "follow-button",
+    description: "NIP-02 follow/unfollow (publishes kind:3).",
+    writes: [{ name: "toon_publish_unsigned" }],
+    propsSchema: { label: "string" }
+  },
+  {
+    id: "composer",
+    description: 'Text composer that publishes a note (kind:1) via its "post" action.',
+    writes: [{ name: "toon_publish_unsigned" }],
+    propsSchema: { placeholder: "string", label: "string" }
+  },
+  // media
+  {
+    id: "media-embed",
+    description: "Render image/video streamed from Arweave (NIP-68/71/94).",
+    kinds: [20, 21, 22, 1063]
+  },
+  {
+    id: "media-uploader",
+    description: "Upload media to Arweave then publish a media event. Spendy.",
+    writes: [{ name: "toon_upload_media", spendy: true }],
+    propsSchema: { label: "string" }
+  },
+  // forge
+  { id: "repo-card", description: "NIP-34 kind:30617 repository card.", kinds: [30617] },
+  {
+    id: "issue-card",
+    description: 'NIP-34 kind:1621 issue; optional "comment" action.',
+    kinds: [1621],
+    writes: [{ name: "toon_publish_unsigned" }]
+  },
+  { id: "pr-card", description: "NIP-34 kind:1617 patch/PR summary (status, commits, base).", kinds: [1617] },
+  {
+    id: "comment-thread",
+    description: 'NIP-34 kind:1622 comment list; optional "comment" action.',
+    kinds: [1622],
+    writes: [{ name: "toon_publish_unsigned" }]
+  },
+  // fallback
+  { id: "generic-event", description: "Fallback: decoded JSON + tags for any kind without a bespoke atom." }
+];
+var CATALOG_ATOM_IDS = new Set(ATOM_CATALOG.map((a) => a.id));
+
+// ../views/dist/examples.js
+function feedView() {
+  return {
+    title: "Feed",
+    root: {
+      atom: "stack",
+      children: [
+        { atom: "composer", actions: { post: { tool: PUBLISH_TOOL, args: { kind: 1 } } } },
+        { atom: "note-card", bind: { query: buildFeedFilter(void 0, 50), kindAuto: true } }
+      ]
+    }
+  };
+}
+function profileView(pubkey) {
+  return {
+    title: "Profile",
+    root: {
+      atom: "stack",
+      children: [
+        { atom: "profile-header", bind: { query: buildProfileFilter([pubkey]) } },
+        {
+          atom: "follow-button",
+          props: { label: "Follow" },
+          actions: { follow: { tool: PUBLISH_TOOL, args: { kind: 3, tags: [["p", pubkey]] } } }
+        },
+        { atom: "note-card", bind: { query: buildFeedFilter([pubkey], 50), kindAuto: true } }
+      ]
+    }
+  };
+}
+function threadView(rootId) {
+  return {
+    title: "Thread",
+    root: {
+      atom: "stack",
+      children: [
+        { atom: "note-card", bind: { query: buildEventByIdFilter([rootId]), kindAuto: true } },
+        { atom: "note-card", bind: { query: buildCommentFilter([rootId]), kindAuto: true } },
+        {
+          atom: "composer",
+          props: { placeholder: "Reply\u2026", label: "Reply" },
+          actions: { post: { tool: PUBLISH_TOOL, args: { kind: 1, tags: [["e", rootId, "", "root"]] } } }
+        }
+      ]
+    }
+  };
+}
+function forgeView(ownerPubkey, repoId) {
+  return {
+    title: "Forge",
+    root: {
+      atom: "tabs",
+      props: { labels: ["Repos", "Issues"] },
+      children: [
+        {
+          atom: "section",
+          props: { title: "Repositories" },
+          children: [{ atom: "repo-card", bind: { query: buildRepoListFilter(), kindAuto: true } }]
+        },
+        {
+          atom: "section",
+          props: { title: "Issues" },
+          children: [
+            { atom: "issue-card", bind: { query: buildIssueListFilter(ownerPubkey, repoId), kindAuto: true } }
+          ]
+        }
+      ]
+    }
+  };
+}
+function mediaView() {
+  return {
+    title: "Media",
+    root: {
+      atom: "stack",
+      children: [
+        { atom: "media-uploader", props: { label: "Post a picture" }, actions: { upload: { tool: UPLOAD_TOOL, args: { kind: 20 }, spendy: true } } },
+        { atom: "media-embed", bind: { query: buildMediaFeedFilter(void 0, 30), kindAuto: true } }
+      ]
+    }
+  };
+}
+var EXAMPLE_VIEWSPECS = [
+  { name: "feed", description: "Social feed with a post composer.", spec: feedView() },
+  { name: "profile", description: "A profile header, follow button, and the author\u2019s notes.", spec: profileView("<pubkey-hex>") },
+  { name: "thread", description: "A note with its replies and a reply composer.", spec: threadView("<root-event-id>") },
+  { name: "forge", description: "Tabbed repos + issues (NIP-34).", spec: forgeView("<owner-pubkey>", "<repo-id>") },
+  { name: "media", description: "Media gallery with an uploader.", spec: mediaView() }
+];
+
+// src/mcp-tools.ts
+var TOOL_DEFINITIONS = [
+  {
+    name: "toon_status",
+    description: "Report TOON client daemon health: bootstrapping/ready state, transport, relay connection, buffered-event count, and per-chain settlement status.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_identity",
+    description: "Return this client's public identity (Nostr pubkey + EVM/Solana/Mina addresses). Never returns private keys.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_publish",
+    description: "Pay-to-write: publish a fully-signed Nostr event to the TOON network. Signs an off-chain payment-channel claim and forwards it over BTP. Returns the event id, channel id, and the advanced channel nonce.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event: {
+          type: "object",
+          description: "A fully-signed Nostr event (must include id, pubkey, sig, kind, created_at, tags, content)."
+        },
+        destination: {
+          type: "string",
+          description: "Optional ILP destination override (default: the apex/town)."
+        },
+        fee: {
+          type: "string",
+          description: "Optional fee override in base units (default: daemon config)."
+        },
+        btpUrl: {
+          type: "string",
+          description: "Which apex (BTP write target) to publish through (default: the config-seeded apex). Use toon_targets to list registered apexes. Writes always go through BTP \u2014 never a relay directly."
+        }
+      },
+      required: ["event"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_publish_unsigned",
+    description: "Pay-to-write WITHOUT holding a key: supply only the event shell (kind, content, tags) and the daemon signs it with the held Nostr key, signs the payment-channel claim, and forwards over BTP. For replaceable kinds (0 profile, 3 follow list) the daemon merges the latest known tags first. This is the path MCP-app UI actions use so the iframe never signs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: { type: "number", description: "Event kind (integer 0\u201365535)." },
+        content: { type: "string", description: "Event content (default empty)." },
+        tags: {
+          type: "array",
+          items: { type: "array", items: { type: "string" } },
+          description: "Event tags (array of string arrays)."
+        },
+        destination: { type: "string", description: "Optional ILP destination override." },
+        fee: { type: "string", description: "Optional fee override (base units)." },
+        btpUrl: { type: "string", description: "Which apex to publish through (default: config-seeded)." }
+      },
+      required: ["kind"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_upload_media",
+    description: "Pay-to-write media (SPENDY, two-step): upload base64 bytes to Arweave via the kind:5094 blob-storage DVM, then sign+publish a media event (default kind:1063 NIP-94; 20=picture, 21/22=video, 1=note w/ NIP-92 imeta) referencing the resulting Arweave URL. Single-packet only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dataBase64: { type: "string", description: "Base64-encoded media bytes." },
+        mime: { type: "string", description: "MIME type (default 'application/octet-stream')." },
+        kind: { type: "number", description: "Media event kind (default 1063)." },
+        caption: { type: "string", description: "Caption/content for the media event." },
+        tags: {
+          type: "array",
+          items: { type: "array", items: { type: "string" } },
+          description: "Extra tags merged into the published media event."
+        },
+        fee: { type: "string", description: "Optional fee override (base units)." },
+        btpUrl: { type: "string", description: "Which apex to publish through (default: config-seeded)." }
+      },
+      required: ["dataBase64"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_atoms",
+    description: "List the atom vocabulary (ids, kinds rendered, props, write actions) plus example ViewSpecs, for composing a view to pass to toon_render. This is how you build the user a generative UI for their journey.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "toon_render",
+    description: "Render an agent-authored ViewSpec (a tree of atoms with data binds and write actions) as the in-host UI. Call toon_atoms first to learn the vocabulary. The ViewSpec is validated; the host renders the app with it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spec: {
+          type: "object",
+          description: "A ViewSpec: { title?, root: ViewNode }. See toon_atoms examples."
+        }
+      },
+      required: ["spec"],
+      additionalProperties: false
+    },
+    _meta: { ui: { resourceUri: APP_RESOURCE_URI } }
+  },
+  {
+    name: "toon_query",
+    description: "Free read for the UI: resolve a NIP-01 filter to matching events (subscribes, waits briefly, returns matches). Used to fill ViewSpec binds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filter: { description: "A NIP-01 filter object." },
+        timeoutMs: { type: "number", description: "Bounded wait, ms (default 1200)." }
+      },
+      required: ["filter"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_subscribe",
+    description: "Free read: register a persistent town-relay subscription with NIP-01 filter(s). Returns a subscription id to drain with toon_read.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filters: {
+          description: "A NIP-01 filter object or an array of OR-ed filters."
+        },
+        subId: { type: "string", description: "Optional caller-supplied id." },
+        relayUrl: {
+          type: "string",
+          description: "Restrict to one relay. Omit to FAN OUT across every registered relay (reads merge into one ordered stream)."
+        }
+      },
+      required: ["filters"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_read",
+    description: "Free read: drain buffered events newer than a cursor. Pass back the returned cursor to fetch only events received since the last read.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        subId: { type: "string", description: "Restrict to one subscription." },
+        cursor: {
+          type: "number",
+          description: "Cursor from a prior toon_read."
+        },
+        limit: {
+          type: "number",
+          description: "Max events to return (default 200)."
+        },
+        relayUrl: {
+          type: "string",
+          description: "Restrict the drain to events from a single relay."
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_open_channel",
+    description: "Open (or return the existing) payment channel for a destination. Channels open lazily on first publish; use this to pre-open.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        destination: {
+          type: "string",
+          description: "ILP destination (default: apex)."
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_channels",
+    description: "List tracked payment channels with their nonce watermark and cumulative transferred amount.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_swap",
+    description: "Pay a mill peer (asset A) to receive asset B plus a signed target-chain claim. Builds the NIP-59 gift-wrapped kind:20032 swap rumor and streams it; the source-asset claim is signed against the open apex channel (the mill must be routed via apexChildPeers). Returns the accumulated, decrypted target-chain claim(s) and settlement metadata.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        destination: {
+          type: "string",
+          description: "Mill peer ILP destination (e.g. g.townhouse.mill)."
+        },
+        amount: {
+          type: "string",
+          description: "Total source-asset amount to swap, source micro-units."
+        },
+        millPubkey: {
+          type: "string",
+          description: "Mill's 64-char lowercase hex Nostr pubkey (gift-wrap recipient)."
+        },
+        pair: {
+          type: "object",
+          description: "The swap pair (from kind:10032 discovery or operator-supplied): { from:{assetCode,assetScale,chain}, to:{...}, rate, minAmount?, maxAmount? }."
+        },
+        chainRecipient: {
+          type: "string",
+          description: "Sender's payout address on pair.to.chain (EVM 0x-hex / Solana / Mina base58)."
+        },
+        packetCount: {
+          type: "number",
+          description: "Split the swap into N equal packets (default 1)."
+        }
+      },
+      required: [
+        "destination",
+        "amount",
+        "millPubkey",
+        "pair",
+        "chainRecipient"
+      ],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_http_fetch_paid",
+    description: "Fetch a paid HTTP resource: issues the request, and if the server returns 402 Payment Required, transparently pays over TOON and retries, returning the settled resource. Settlement happens inside the daemon against the open apex channel (the caller never holds chain keys). Returns { status, headers, body } (body decoded as text).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "Absolute URL of the resource to fetch."
+        },
+        method: {
+          type: "string",
+          description: "HTTP method (default GET)."
+        },
+        headers: {
+          type: "object",
+          description: "Request headers as a flat string\u2192string map."
+        },
+        body: {
+          type: "string",
+          description: "Request body (string, sent verbatim; e.g. with POST)."
+        },
+        timeout: {
+          type: "number",
+          description: "Per-request timeout, ms."
+        }
+      },
+      required: ["url"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_targets",
+    description: "List every registered target: relays (read sources, with connection + buffered-event status) and apexes (BTP write targets, with ready/channel status). The TOON client is 1-to-many \u2014 many apexes to write through, many relays to read from.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_add_relay",
+    description: "Add a relay READ target at runtime (persisted across restarts). It joins all fan-out reads immediately; `.anyone` hidden-service relays reuse the managed anon read proxy automatically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        relayUrl: {
+          type: "string",
+          description: "Relay WS URL (ws://host:7100 or a .anyone service)."
+        }
+      },
+      required: ["relayUrl"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_remove_relay",
+    description: "Remove a relay read target (persisted). The config-seeded default relay cannot be removed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        relayUrl: { type: "string", description: "Relay WS URL to remove." }
+      },
+      required: ["relayUrl"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_add_apex",
+    description: "Add an apex WRITE target at runtime (persisted across restarts). Settlement params are DISCOVERED by reading the apex\u2019s kind:10032 announcement off the given relay \u2014 you do not supply chain/settlement details. The relay is added as a read target first if unknown.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ilpAddress: {
+          type: "string",
+          description: "ILP address of the apex (e.g. g.townhouse.town)."
+        },
+        relayUrl: {
+          type: "string",
+          description: "Relay to discover the apex\u2019s kind:10032 on."
+        },
+        pubkey: {
+          type: "string",
+          description: "Optional apex Nostr pubkey (64-char hex) to narrow discovery."
+        },
+        chain: {
+          type: "string",
+          enum: ["evm", "solana", "mina"],
+          description: "Preferred settlement chain (default: apex\u2019s first)."
+        },
+        childPeers: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Child peers via this apex\u2019s channel (e.g. ["dvm","mill"]).'
+        },
+        feePerEvent: {
+          type: "string",
+          description: "Per-write fee override for this apex (base units)."
+        }
+      },
+      required: ["ilpAddress", "relayUrl"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "toon_remove_apex",
+    description: "Remove an apex write target by its BTP URL (persisted). The config-seeded default apex cannot be removed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        btpUrl: {
+          type: "string",
+          description: "BTP URL of the apex to remove (from toon_targets)."
+        }
+      },
+      required: ["btpUrl"],
+      additionalProperties: false
+    }
+  }
+];
+async function dispatchTool(client, name, args) {
+  try {
+    switch (name) {
+      case "toon_status":
+        return ok(await client.status());
+      case "toon_identity": {
+        const s = await client.status();
+        return ok({
+          identity: s.identity,
+          ready: s.ready,
+          bootstrapping: s.bootstrapping
+        });
+      }
+      case "toon_publish":
+        return ok(await client.publish(args));
+      case "toon_publish_unsigned":
+        return ok(
+          await client.publishUnsigned(args)
+        );
+      case "toon_upload_media":
+        return ok(
+          await client.uploadMedia(args)
+        );
+      case "toon_atoms":
+        return okStructured("Atom vocabulary + example ViewSpecs.", {
+          atoms: ATOM_CATALOG,
+          examples: EXAMPLE_VIEWSPECS
+        });
+      case "toon_render": {
+        const check = validateViewSpec(args["spec"], {
+          allowedAtoms: CATALOG_ATOM_IDS,
+          allowedTools: WRITE_TOOLS
+        });
+        if (!check.ok) {
+          return err(`Invalid ViewSpec:
+- ${check.errors.join("\n- ")}`);
+        }
+        return okStructured(
+          `Rendering view${check.spec.title ? `: ${check.spec.title}` : ""}.`,
+          { viewSpec: check.spec }
+        );
+      }
+      case "toon_query": {
+        const res = await client.query({
+          filters: args["filter"],
+          ...typeof args["timeoutMs"] === "number" ? { timeoutMs: args["timeoutMs"] } : {}
+        });
+        return okStructured(`${res.events.length} event(s).`, {
+          events: res.events
+        });
+      }
+      case "toon_subscribe":
+        return ok(
+          await client.subscribe({
+            filters: args["filters"],
+            ...typeof args["subId"] === "string" ? { subId: args["subId"] } : {},
+            ...typeof args["relayUrl"] === "string" ? { relayUrl: args["relayUrl"] } : {}
+          })
+        );
+      case "toon_read":
+        return ok(
+          await client.events({
+            ...typeof args["subId"] === "string" ? { subId: args["subId"] } : {},
+            ...typeof args["cursor"] === "number" ? { cursor: args["cursor"] } : {},
+            ...typeof args["limit"] === "number" ? { limit: args["limit"] } : {},
+            ...typeof args["relayUrl"] === "string" ? { relayUrl: args["relayUrl"] } : {}
+          })
+        );
+      case "toon_open_channel":
+        return ok(
+          await client.openChannel(
+            typeof args["destination"] === "string" ? { destination: args["destination"] } : {}
+          )
+        );
+      case "toon_channels":
+        return ok(await client.channels());
+      case "toon_swap":
+        return ok(
+          await client.swap({
+            destination: String(args["destination"]),
+            amount: String(args["amount"]),
+            millPubkey: String(args["millPubkey"]),
+            pair: args["pair"],
+            chainRecipient: String(args["chainRecipient"]),
+            ...typeof args["packetCount"] === "number" ? { packetCount: args["packetCount"] } : {}
+          })
+        );
+      case "toon_http_fetch_paid": {
+        const req = {
+          url: String(args["url"]),
+          ...typeof args["method"] === "string" ? { method: args["method"] } : {},
+          ...args["headers"] && typeof args["headers"] === "object" ? { headers: args["headers"] } : {},
+          ...typeof args["body"] === "string" ? { body: args["body"] } : {},
+          ...typeof args["timeout"] === "number" ? { timeout: args["timeout"] } : {}
+        };
+        return ok(await client.httpFetchPaid(req));
+      }
+      case "toon_targets":
+        return ok(await client.targets());
+      case "toon_add_relay":
+        return ok(
+          await client.addRelay({ relayUrl: String(args["relayUrl"]) })
+        );
+      case "toon_remove_relay":
+        return ok(
+          await client.removeRelay({ relayUrl: String(args["relayUrl"]) })
+        );
+      case "toon_add_apex": {
+        const req = {
+          ilpAddress: String(args["ilpAddress"]),
+          relayUrl: String(args["relayUrl"]),
+          ...typeof args["pubkey"] === "string" ? { pubkey: args["pubkey"] } : {},
+          ...typeof args["chain"] === "string" ? { chain: args["chain"] } : {},
+          ...Array.isArray(args["childPeers"]) ? { childPeers: args["childPeers"].map(String) } : {},
+          ...typeof args["feePerEvent"] === "string" ? { feePerEvent: args["feePerEvent"] } : {}
+        };
+        return ok(await client.addApex(req));
+      }
+      case "toon_remove_apex":
+        return ok(await client.removeApex({ btpUrl: String(args["btpUrl"]) }));
+      default:
+        return err(`Unknown tool: ${name}`);
+    }
+  } catch (e) {
+    if (e instanceof ControlApiError && e.status === 504) {
+      return err(
+        `${e.detail ?? e.message} \u2014 retry once the relay is reachable and the apex is online.`
+      );
+    }
+    if (e instanceof ControlApiError && e.retryable) {
+      return err(
+        `TOON client is still bootstrapping (the anon proxy / BTP session can take 30\u201390s) \u2014 retry shortly. (${e.message})`
+      );
+    }
+    if (e instanceof DaemonUnreachableError) {
+      return err(
+        `TOON client daemon is not reachable at ${e.baseUrl}. It may have failed to start \u2014 check ~/.toon-client/daemon.log.`
+      );
+    }
+    if (e instanceof ControlApiError) {
+      return err(`${e.message}${e.detail ? `: ${e.detail}` : ""}`);
+    }
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function okStructured(text, structuredContent) {
+  return { content: [{ type: "text", text }], structuredContent };
+}
+function err(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+
+export {
+  APP_RESOURCE_URI,
+  TOOL_DEFINITIONS,
+  dispatchTool
+};
+//# sourceMappingURL=chunk-KNQ2DKNN.js.map