@secondlayer/mcp 3.9.0 → 4.0.0

package/dist/bin.js

@@ -10,26 +10,54 @@ import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/resources.ts
-import { CHAIN_TRIGGER_FIELDS, DECODED_EVENT_TYPES } from "@secondlayer/shared";
+import { CHAIN_TRIGGER_FIELDS } from "@secondlayer/shared";
 import { TRAIT_STANDARDS } from "@secondlayer/stacks/clarity";
 import { TYPE_MAP } from "@secondlayer/subgraphs/schema";
 
 // src/lib/client.ts
-import { SecondLayer } from "@secondlayer/sdk";
+import { SecondLayer, readX402Receipt, withX402 } from "@secondlayer/sdk";
+import { privateKeyToAccount } from "@secondlayer/stacks/accounts";
 var instance = null;
 function readApiKey() {
   return process.env.SL_API_KEY;
 }
+function buildFetchImpl() {
+  const key = process.env.X402_PRIVATE_KEY;
+  if (!key)
+    return;
+  const account = privateKeyToAccount(key);
+  const topUpUsd = Number(process.env.X402_TOPUP_USD ?? "");
+  const paid = withX402(fetch, {
+    account,
+    ...Number.isFinite(topUpUsd) && topUpUsd > 0 ? {
+      topUp: {
+        usd: topUpUsd,
+        whenBelow: Number(process.env.X402_TOPUP_WHEN_BELOW ?? "0.5")
+      }
+    } : {}
+  });
+  const wrapped = async (input, init) => {
+    const res = await paid(input, init);
+    const receipt = readX402Receipt(res);
+    if (receipt) {
+      console.error(`[x402] paid call settled tier=${receipt.state ?? "confirmed"} txid=${receipt.txid}`);
+    }
+    return res;
+  };
+  return wrapped;
+}
 function getClient() {
   if (!instance) {
     const apiKey = readApiKey();
     const baseUrl = process.env.SECONDLAYER_API_URL;
     const dumpsBaseUrl = process.env.SL_STREAMS_DUMPS_URL;
+    const fetchImpl = buildFetchImpl();
     instance = new SecondLayer({
       ...apiKey ? { apiKey } : {},
       origin: "mcp",
       ...baseUrl ? { baseUrl } : {},
-      ...dumpsBaseUrl ? { dumpsBaseUrl } : {}
+      ...dumpsBaseUrl ? { dumpsBaseUrl } : {},
+      ...fetchImpl ? { fetchImpl } : {}
     });
   }
   return instance;
@@ -170,25 +198,21 @@ var COLUMN_TYPES = [
   }
 ];
 var PRODUCT_BLURBS = {
-  datasets: "public foundation datasets",
-  index: "decoded L2 events, contract calls, blocks, transactions, stacking, mempool",
-  streams: "raw canonical chain event firehose",
-  contracts: "trait-based contract discovery",
+  index: "decoded L2 events, transfers, contract calls, blocks, transactions",
+  streams: "bulk parquet dumps of the raw chain event firehose",
+  contracts: "trait-based contract discovery and ABIs",
   subgraphs: "author/deploy/query custom indexes",
   subscriptions: "webhook delivery on subgraph rows or raw chain events",
-  account: "identity, plan, billing, usage, spend caps, and API keys",
-  project: "create/manage projects and view their team",
-  scaffold: "generate typed contract clients from a deployment or ABI"
+  account: "identity and self-provisioned API keys",
+  scaffold: "generate deploy-ready subgraph code from a deployed contract"
 };
 var PRODUCT_ORDER = [
-  "datasets",
   "index",
   "streams",
   "contracts",
   "subgraphs",
   "subscriptions",
   "account",
-  "project",
   "scaffold"
 ];
 function buildCapabilities() {
@@ -210,11 +234,17 @@ function buildCapabilities() {
   });
   return {
     products,
-    discoverFirst: "Call datasets_list / index_discover / contracts_find to learn what exists (and which filters each surface accepts) before querying."
+    discoverFirst: "Call index_discover / contracts_find to learn what exists (and which filters each surface accepts) before querying."
   };
 }
+var X402_CAPABILITY = {
+  what: "Index and Streams reads (/v1/index/*, /v1/streams/*) accept x402 v2 pay-per-call (network stacks:1, sponsored transfers — the payer holds sBTC/STX/USDCx, never gas). Index grants 1,000 free reads/day/IP before any 402; a paid Streams call opens a 500-call/1h PAYMENT-SESSION.",
+  paidWrites: "POST /v1/subgraphs (x402 $2) deploys a subgraph owned by the paying wallet — live from deploy, 7-day TTL, renewable via POST /v1/subgraphs/{name}/renew ($0.50/wk); claiming the account clears the expiry.",
+  prepaid: "POST /v1/x402/deposit?usd=N loads a prepaid tab (PAYMENT-BALANCE token, $0.25 min) — calls debit it instantly, no per-call on-chain settle. GET /v1/x402/balance reads it.",
+  discovery: "GET /v1/x402/supported on the API host for scheme, assets, prices, quotas, sessions, and prepaid metadata.",
+  autopay: "Set X402_PRIVATE_KEY (a Stacks private key holding an accepted token) and this MCP server pays 402 challenges automatically (sessions replayed). Add X402_TOPUP_USD (and optionally X402_TOPUP_WHEN_BELOW) for an autonomous prepaid tab that refills itself. Receipts are logged per paid call."
+};
 var READ_AUTH_TIERS = {
-  datasets: "open — no API key required",
   index: "anonymous reads allowed; free-tier API keys are rejected (Build+ required)",
   streams: "API key required (SL_API_KEY) — keyless calls return 401",
   subgraphs: "public subgraphs anon-readable at /v1/subgraphs/<name>/<table> ({ rows, next_cursor, tip } cursor envelope); private subgraphs need the owning account's API key (anon → 404); writes require an API key"
@@ -224,7 +254,10 @@ async function buildContext(deps = { clientProvider: getClient }) {
   const orNull = (v) => v == null ? unavailable : v;
   const snap = await deps.clientProvider().context().catch(() => null);
   return {
-    authState: { apiKeySet: Boolean(process.env.SL_API_KEY) },
+    authState: {
+      apiKeySet: Boolean(process.env.SL_API_KEY),
+      x402WalletSet: Boolean(process.env.X402_PRIVATE_KEY)
+    },
     whatExists: {
       account: orNull(snap?.account),
       streamsTip: orNull(snap?.streamsTip),
@@ -236,7 +269,8 @@ async function buildContext(deps = { clientProvider: getClient }) {
       activeOperations: orNull(snap?.activeOperations)
     },
     whatYouCanDo: buildCapabilities(),
-    readAuthTiers: READ_AUTH_TIERS
+    readAuthTiers: READ_AUTH_TIERS,
+    payPerCall: X402_CAPABILITY
   };
 }
 function registerResources(server) {
@@ -285,29 +319,6 @@ function registerResources(server) {
       }
     ]
   }));
-  server.resource("streams-filters", "secondlayer://streams-filters", {
-    description: "Streams firehose vocabulary — the decoded event types and the filter fields accepted by streams_events / streams_consume."
-  }, async () => ({
-    contents: [
-      {
-        uri: "secondlayer://streams-filters",
-        mimeType: "application/json",
-        text: JSON.stringify({
-          eventTypes: [...DECODED_EVENT_TYPES],
-          filters: {
-            types: "include only these event types (array)",
-            notTypes: "exclude these event types (array)",
-            contractId: "match a contract id",
-            sender: "match the sender principal",
-            recipient: "match the recipient principal",
-            assetIdentifier: "match the asset identifier (contract::asset)",
-            fromHeight: "start block height (inclusive)",
-            toHeight: "end block height (inclusive)"
-          }
-        }, null, 2)
-      }
-    ]
-  }));
   server.resource("chain-triggers", "secondlayer://chain-triggers", {
     description: "Chain-subscription trigger types and the filter fields each accepts (for subscriptions_create triggers)."
   }, async () => ({
@@ -328,50 +339,13 @@ function registerAccountTools(server) {
     const result = await apiRequest("GET", "/api/accounts/me");
     return jsonResponse(result);
   });
-  defineTool(server, "account_update", "Update the authenticated account's profile. Requires an API key.", {
-    displayName: z.string().optional().describe("Display name"),
-    bio: z.string().optional().describe("Profile bio"),
-    slug: z.string().optional().describe("Account URL slug")
-  }, async ({ displayName, bio, slug }) => {
-    const body = {};
-    if (displayName !== undefined)
-      body.display_name = displayName;
-    if (bio !== undefined)
-      body.bio = bio;
-    if (slug !== undefined)
-      body.slug = slug;
-    const result = await apiRequest("PATCH", "/api/accounts/me", body);
-    return jsonResponse(result);
-  });
-  defineTool(server, "account_billing", "Show the account's plan and subscription/billing status. Requires an API key. (Plan upgrade / Stripe portal / checkout are deliberately not agent tools — they are session-only human-payment flows; use account_set_caps to bound spend.)", {}, async () => {
-    const result = await apiRequest("GET", "/api/billing/status");
-    return jsonResponse(result);
-  });
   defineTool(server, "account_create_key", "Mint a scoped streams/index read API key so the agent can self-provision access. Requires an account-level (owner) API key. The returned `key` is shown ONCE — forward it to the user to set as SL_API_KEY.", {
     product: z.enum(["streams", "index"]).optional().describe("Key scope (default streams)"),
     name: z.string().optional().describe("Optional label for the key")
   }, async ({ product, name }) => jsonResponse(await getClient().apiKeys.create({ product, name })));
-  defineTool(server, "account_list_keys", "List the account's API keys (metadata only — prefix, name, status, product, tier, last used; never the plaintext). Requires an account-level (owner) API key.", {}, async () => jsonResponse(await getClient().apiKeys.list()));
-  defineTool(server, "account_revoke_key", "Revoke an API key by id. Requests using that key stop working immediately. Requires an account-level (owner) API key.", { id: z.string().describe("Key id from account_list_keys") }, async ({ id }) => jsonResponse(await getClient().apiKeys.revoke(id)));
-  defineTool(server, "account_usage", "Show the current billing period's usage snapshot: spend (with cap/projection), compute, storage, and per-project breakdown. Requires an API key.", {}, async () => jsonResponse(await apiRequest("GET", "/api/accounts/usage")));
-  defineTool(server, "account_get_caps", "Show the account's spend caps and alert threshold. Requires an account-level (owner) API key.", {}, async () => jsonResponse(await apiRequest("GET", "/api/billing/caps")));
-  defineTool(server, "account_set_caps", "Set the account's spend caps and alert threshold (no payment — just bounds spend). Requires an account-level (owner) API key.", {
-    monthlyCapCents: z.number().int().nonnegative().optional().describe("Total monthly spend cap in cents"),
-    computeCapCents: z.number().int().nonnegative().optional().describe("Compute spend cap in cents"),
-    storageCapCents: z.number().int().nonnegative().optional().describe("Storage spend cap in cents"),
-    alertThresholdPct: z.number().int().min(1).max(100).optional().describe("Percent of cap that triggers an alert (1-100)")
-  }, async (caps) => {
-    const body = {};
-    for (const [k, v] of Object.entries(caps)) {
-      if (v !== undefined)
-        body[k] = v;
-    }
-    return jsonResponse(await apiRequest("PATCH", "/api/billing/caps", body));
-  });
 }
 
 // src/tools/contracts.ts
-import { generateContractInterface } from "@secondlayer/scaffold";
 import { z as z2 } from "zod/v4";
 function registerContractTools(server, clientProvider = getClient) {
   defineTool(server, "contracts_find", 'Discover deployed Stacks contracts conforming to a trait (e.g. "sip-010", "sip-009", "sip-013"). The discovery endpoint for "which contracts implement X". Reads are public.', {
@@ -381,7 +355,7 @@ function registerContractTools(server, clientProvider = getClient) {
     limit: z2.number().optional().describe("Page size, 1–500 (default 100)"),
     cursor: z2.string().optional().describe("Opaque cursor from a prior response's next_cursor")
   }, async (params) => jsonResponse(await clientProvider().contracts.list(params)));
-  defineTool(server, "get_contract_abi", "Fetch a single deployed contract's ABI from the registry (prod-safe). Returns the contract's metadata + full ABI (functions, maps, variables, fungible/non-fungible tokens). Returns not_found if the contract isn't in the registry. Feed the ABI into scaffold_from_abi or generate a typed client.", {
+  defineTool(server, "get_contract_abi", "Fetch a single deployed contract's ABI from the registry (prod-safe). Returns the contract's metadata + full ABI (functions, maps, variables, fungible/non-fungible tokens). Returns not_found if the contract isn't in the registry. Use it to inspect a contract before scaffold_from_contract.", {
     contractId: z2.string().describe("Fully qualified contract id (e.g. SP….amm-pool-v2-01)")
   }, async ({ contractId }) => {
     const contract = await clientProvider().contracts.get(contractId, {
@@ -395,72 +369,18 @@ function registerContractTools(server, clientProvider = getClient) {
       }
     }, true);
   });
-  defineTool(server, "generate_contract_interface", "Generate a typed TypeScript contract-client interface (typed methods + map/var/constant readers) from a deployed contract's ABI (fetched from the registry). Returns not_found if the contract isn't in the registry.", {
-    contractId: z2.string().describe("Fully qualified contract id (e.g. SP….amm-pool-v2-01)")
-  }, async ({ contractId }) => {
-    const c = await clientProvider().contracts.get(contractId, {
-      includeAbi: true
-    });
-    if (!c || !c.abi) {
-      return jsonResponse({
-        error: {
-          type: "not_found",
-          status: 404,
-          message: `Contract not in registry: ${contractId}`
-        }
-      }, true);
-    }
-    const [address, contractName] = contractId.split(".");
-    const name = (contractName ?? contractId).replace(/[^a-zA-Z0-9]/g, "_");
-    const code = generateContractInterface([
-      {
-        name,
-        address,
-        contractName: contractName ?? "",
-        abi: c.abi
-      }
-    ]);
-    return { content: [{ type: "text", text: code }] };
-  });
-}
-
-// src/tools/datasets.ts
-import { z as z3 } from "zod/v4";
-function registerDatasetTools(server, clientProvider = getClient) {
-  defineTool(server, "datasets_list", "List the Foundation Datasets catalog with freshness — the discovery endpoint for what dataset slugs exist and how current each is. Reads are public.", {}, async () => {
-    const catalog = await clientProvider().datasets.listDatasets();
-    return jsonResponse(catalog);
-  });
-  defineTool(server, "datasets_query", 'Query ANY Foundation Dataset by slug — every family returned by datasets_list is queryable, including bespoke ones (bns/resolve with {"fqn":"alice.btc"}, bns/names, bns/namespaces, network-health/summary) and any dataset added later. Accepts family ("sbtc-events") or path ("sbtc/events") slug forms. Filters are passed through as documented query params (e.g. {"sender": "SP...", "from_block": "150000"}). Returns { rows, next_cursor, tip }; single-record datasets like bns/resolve return 0-or-1 rows (empty = not found). Call datasets_list first to discover slugs and their filters.', {
-    slug: z3.string().describe("Dataset slug from datasets_list (e.g. stx-transfers)"),
-    filters: z3.record(z3.string(), z3.string()).optional().describe("Documented per-dataset query params (snake_case values)"),
-    limit: z3.number().optional().describe("Max rows for this page"),
-    cursor: z3.string().optional().describe("Opaque cursor from a prior response's next_cursor")
-  }, async ({ slug, filters, limit, cursor }) => {
-    const params = { ...filters ?? {} };
-    if (limit !== undefined)
-      params.limit = limit;
-    if (cursor !== undefined)
-      params.cursor = cursor;
-    const result = await clientProvider().datasets.get(slug, params);
-    return jsonResponse(result);
-  });
 }
 
 // src/tools/index.ts
-import { DECODED_EVENT_TYPES as DECODED_EVENT_TYPES2 } from "@secondlayer/shared";
-import {
-  INDEX_CODEGEN_TABLES,
-  generateIndexSchema
-} from "@secondlayer/subgraphs";
-import { z as z4 } from "zod/v4";
-var INDEX_EVENT_TYPES = DECODED_EVENT_TYPES2;
+import { DECODED_EVENT_TYPES } from "@secondlayer/shared";
+import { z as z3 } from "zod/v4";
+var INDEX_EVENT_TYPES = DECODED_EVENT_TYPES;
 var rangeFilters = {
-  contractId: z4.string().optional().describe("Filter by contract id"),
-  fromHeight: z4.number().optional().describe("Start block height (inclusive)"),
-  toHeight: z4.number().optional().describe("End block height (inclusive)"),
-  cursor: z4.string().optional().describe("Opaque cursor from a prior response's next_cursor"),
-  limit: z4.number().optional().describe("Max rows for this page")
+  contractId: z3.string().optional().describe("Filter by contract id"),
+  fromHeight: z3.number().optional().describe("Start block height (inclusive)"),
+  toHeight: z3.number().optional().describe("End block height (inclusive)"),
+  cursor: z3.string().optional().describe("Opaque cursor from a prior response's next_cursor"),
+  limit: z3.number().optional().describe("Max rows for this page")
 };
 var heightFilters = {
   fromHeight: rangeFilters.fromHeight,
@@ -468,126 +388,52 @@ var heightFilters = {
   cursor: rangeFilters.cursor,
   limit: rangeFilters.limit
 };
-var notFound = (message) => jsonResponse({ error: { type: "not_found", status: 404, message } }, true);
 function registerIndexTools(server, clientProvider = getClient) {
   defineTool(server, "index_ft_transfers", "List decoded SIP-010 fungible-token transfers from the Index (L2 decoded layer). Anonymous reads allowed (free-tier API keys are rejected — Build+ required).", {
     ...rangeFilters,
-    sender: z4.string().optional().describe("Filter by sender principal"),
-    recipient: z4.string().optional().describe("Filter by recipient principal")
+    sender: z3.string().optional().describe("Filter by sender principal"),
+    recipient: z3.string().optional().describe("Filter by recipient principal")
   }, async (params) => jsonResponse(await clientProvider().index.ftTransfers.list(params)));
   defineTool(server, "index_nft_transfers", "List decoded SIP-009 non-fungible-token transfers from the Index. Anonymous reads allowed (free-tier keys rejected).", {
     ...rangeFilters,
-    sender: z4.string().optional().describe("Filter by sender principal"),
-    recipient: z4.string().optional().describe("Filter by recipient principal"),
-    assetIdentifier: z4.string().optional().describe("Filter by asset identifier (contract::asset)")
+    sender: z3.string().optional().describe("Filter by sender principal"),
+    recipient: z3.string().optional().describe("Filter by recipient principal"),
+    assetIdentifier: z3.string().optional().describe("Filter by asset identifier (contract::asset)")
   }, async (params) => jsonResponse(await clientProvider().index.nftTransfers.list(params)));
   defineTool(server, "index_events", "List decoded chain events from the Index by event type. Use this for event types without a dedicated tool (stx_*, ft_mint/burn, nft_mint/burn, print), and for trait-scoped queries: set `trait` (e.g. sip-010) to match all contracts conforming to a standard — pair with contracts_find to discover traits. For ft/nft transfers without a trait prefer index_ft_transfers / index_nft_transfers.", {
-    eventType: z4.enum(INDEX_EVENT_TYPES).describe("Required. Decoded event type to list."),
+    eventType: z3.enum(INDEX_EVENT_TYPES).describe("Required. Decoded event type to list."),
     ...rangeFilters,
-    sender: z4.string().optional().describe("Filter by sender principal"),
-    recipient: z4.string().optional().describe("Filter by recipient principal"),
-    assetIdentifier: z4.string().optional().describe("Filter by asset identifier where applicable"),
-    trait: z4.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId; contract-keyed event types only.")
+    sender: z3.string().optional().describe("Filter by sender principal"),
+    recipient: z3.string().optional().describe("Filter by recipient principal"),
+    assetIdentifier: z3.string().optional().describe("Filter by asset identifier where applicable"),
+    trait: z3.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId; contract-keyed event types only.")
   }, async (params) => jsonResponse(await clientProvider().index.events.list(params)));
   defineTool(server, "index_contract_calls", "List decoded contract calls from the Index (function name, args, result). Set `trait` (e.g. sip-010) to match calls to all contracts conforming to a standard. Note: contract-call cursors are a SEPARATE keyspace from event cursors — they are not interchangeable.", {
     ...rangeFilters,
-    functionName: z4.string().optional().describe("Filter by called function name"),
-    sender: z4.string().optional().describe("Filter by caller principal"),
-    trait: z4.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId.")
+    functionName: z3.string().optional().describe("Filter by called function name"),
+    sender: z3.string().optional().describe("Filter by caller principal"),
+    trait: z3.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId.")
   }, async (params) => jsonResponse(await clientProvider().index.contractCalls.list(params)));
-  defineTool(server, "index_canonical", "List the canonical Stacks block sequence from the Index (height + hash). Anonymous reads allowed (free-tier keys rejected).", { ...heightFilters }, async (params) => jsonResponse(await clientProvider().index.canonical.list(params)));
   defineTool(server, "index_blocks", "List decoded blocks from the Index. Anonymous reads allowed (free-tier keys rejected).", { ...heightFilters }, async (params) => jsonResponse(await clientProvider().index.blocks.list(params)));
-  defineTool(server, "index_block", "Get a single block from the Index by height or block hash. Returns not_found if unknown.", {
-    ref: z4.string().describe("Block height (digits) or block hash (0x… string)")
-  }, async ({ ref }) => {
-    const block = await clientProvider().index.blocks.get(/^\d+$/.test(ref) ? Number(ref) : ref);
-    return block ? jsonResponse(block) : notFound(`No block for ref ${ref}`);
-  });
   defineTool(server, "index_transactions", "List decoded transactions from the Index. Filter by type, sender, or contract. Anonymous reads allowed (free-tier keys rejected).", {
     ...rangeFilters,
-    type: z4.string().optional().describe("Filter by transaction type"),
-    sender: z4.string().optional().describe("Filter by sender principal")
+    type: z3.string().optional().describe("Filter by transaction type"),
+    sender: z3.string().optional().describe("Filter by sender principal")
   }, async (params) => jsonResponse(await clientProvider().index.transactions.list(params)));
-  defineTool(server, "index_transaction", "Get a single transaction from the Index by tx_id. Returns not_found if unknown.", { txId: z4.string().describe("Transaction id (0x… hash)") }, async ({ txId }) => {
-    const tx = await clientProvider().index.transactions.get(txId);
-    return tx ? jsonResponse(tx) : notFound(`No transaction for ${txId}`);
-  });
-  defineTool(server, "index_transaction_proof", "Fetch a transaction's inclusion proof (raw tx + signed Nakamoto block header + merkle path) so it can be verified trustlessly client-side with the SDK's verifyTransactionProof. Returns not_found if the tx/block is unknown; a 503 means the proof can't be assembled on this deployment right now (PROOF_TX_SET_INCOMPLETE, or PROOF_NODE_UNAVAILABLE when the stacks-node header source isn't configured).", { txId: z4.string().describe("Transaction id (0x… hash)") }, async ({ txId }) => {
-    const proof = await clientProvider().index.transactions.getProof(txId);
-    return proof ? jsonResponse(proof) : notFound(`No proof available for ${txId}`);
-  });
-  defineTool(server, "index_stacking", "List decoded PoX-4 stacking actions from the Index (stack-stx, delegate-stx, etc.). Anonymous reads allowed (free-tier keys rejected).", {
-    ...heightFilters,
-    functionName: z4.string().optional().describe("Filter by PoX function name"),
-    stacker: z4.string().optional().describe("Filter by stacker principal"),
-    caller: z4.string().optional().describe("Filter by caller principal")
-  }, async (params) => jsonResponse(await clientProvider().index.stacking.list(params)));
-  defineTool(server, "index_mempool", "List pending (unconfirmed) transactions from the Index mempool. Sequence-cursor paginated (no height range). Anonymous reads allowed (free-tier keys rejected).", {
-    sender: z4.string().optional().describe("Filter by sender principal"),
-    type: z4.string().optional().describe("Filter by transaction type"),
-    contractId: z4.string().optional().describe("Filter to pending calls to a single contract"),
-    cursor: z4.string().optional().describe("Opaque cursor from a prior response's next_cursor"),
-    limit: z4.number().optional().describe("Max rows for this page")
-  }, async (params) => jsonResponse(await clientProvider().index.mempool.list(params)));
-  defineTool(server, "index_mempool_tx", "Get a single pending transaction from the Index mempool by tx_id. Returns not_found once it is mined or dropped.", { txId: z4.string().describe("Transaction id (0x… hash)") }, async ({ txId }) => {
-    const tx = await clientProvider().index.mempool.get(txId);
-    return tx ? jsonResponse(tx) : notFound(`No pending tx for ${txId}`);
-  });
   defineTool(server, "index_discover", "Discover the Index vocabulary: every event type and its columns, allowed/equality filters, and required-non-null fields (and which types accept `trait`). Read this before building Index queries instead of guessing filters. Anonymous read.", {}, async () => jsonResponse(await clientProvider().index.discover()));
-  defineTool(server, "index_usage", "Your own Index consumption (decoded events today + this month) and tier limits. Requires a Build+ API key (anonymous reads can't report usage).", {}, async () => jsonResponse(await clientProvider().index.usage()));
-  defineTool(server, "index_codegen", `Generate a typed schema (Prisma, Kysely, Drizzle, or JSON-Schema) for the public Index domain tables so they can be mirrored into a BYO database with full types. Returns the schema as text. Tables: ${INDEX_CODEGEN_TABLES.join(", ")}.`, {
-    target: z4.enum(["prisma", "kysely", "drizzle", "json-schema"]).optional().describe("Output target (default kysely)"),
-    tables: z4.array(z4.string()).optional().describe("Subset of Index tables (default: all)"),
-    schemaName: z4.string().optional().describe("Postgres schema to qualify table names with")
-  }, async ({ target = "kysely", tables, schemaName }) => {
-    const out = generateIndexSchema(target, { tables, schemaName });
-    return { content: [{ type: "text", text: out }] };
-  });
-}
-
-// src/tools/projects.ts
-import { z as z5 } from "zod/v4";
-function registerProjectTools(server, clientProvider = getClient) {
-  defineTool(server, "project_list", "List the account's projects. Requires an account-level (owner) API key.", {}, async () => jsonResponse(await clientProvider().projects.list()));
-  defineTool(server, "project_get", "Get a single project by slug.", { slug: z5.string().describe("Project slug") }, async ({ slug }) => jsonResponse(await clientProvider().projects.get(slug)));
-  defineTool(server, "project_create", "Create a project. The slug is derived from the name when omitted. Requires an account-level (owner) API key.", {
-    name: z5.string().describe("Project name"),
-    slug: z5.string().optional().describe("URL slug (auto-derived from name if omitted)"),
-    network: z5.string().optional().describe("Network (e.g. mainnet, testnet)"),
-    nodeRpc: z5.string().optional().describe("Custom node RPC URL")
-  }, async ({ name, slug, network, nodeRpc }) => jsonResponse(await clientProvider().projects.create({
-    name,
-    slug,
-    network,
-    nodeRpc
-  })));
-  defineTool(server, "project_update", "Update a project. `slug` selects the project; `newSlug` renames it. Requires an account-level (owner) API key.", {
-    slug: z5.string().describe("Slug of the project to update"),
-    newSlug: z5.string().optional().describe("New slug (renames the project)"),
-    name: z5.string().optional().describe("New display name"),
-    network: z5.string().optional().describe("Network (e.g. mainnet, testnet)"),
-    nodeRpc: z5.string().optional().describe("Custom node RPC URL"),
-    settings: z5.record(z5.string(), z5.unknown()).optional().describe("Arbitrary project settings to merge")
-  }, async ({ slug, newSlug, name, network, nodeRpc, settings }) => jsonResponse(await clientProvider().projects.update(slug, {
-    ...newSlug !== undefined ? { slug: newSlug } : {},
-    ...name !== undefined ? { name } : {},
-    ...network !== undefined ? { network } : {},
-    ...nodeRpc !== undefined ? { nodeRpc } : {},
-    ...settings !== undefined ? { settings } : {}
-  })));
-  defineTool(server, "project_delete", "Delete a project permanently. The account's last remaining project cannot be deleted.", { slug: z5.string().describe("Project slug") }, async ({ slug }) => jsonResponse(await clientProvider().projects.delete(slug)));
-  defineTool(server, "project_team_list", "List a project's team members and pending invitations.", { slug: z5.string().describe("Project slug") }, async ({ slug }) => jsonResponse(await clientProvider().projects.team(slug)));
+  defineTool(server, "batch_query", "Run up to 10 public /v1 reads in one round trip (POST /v1/batch). Each item keeps its own auth/quota/pay-per-call semantics; results return in order with per-item status. Paths must start with /v1/index, /v1/subgraphs, /v1/streams, or /v1/contracts.", {
+    requests: z3.array(z3.object({
+      path: z3.string().describe("Public /v1 read path"),
+      params: z3.record(z3.string(), z3.string()).optional()
+    })).min(1).max(10).describe("Read descriptors, executed concurrently")
+  }, async (params) => jsonResponse(await clientProvider().batch(params.requests)));
 }
 
 // src/tools/scaffold.ts
-import {
-  generateSubgraphCode,
-  generateTraitSubgraph
-} from "@secondlayer/scaffold";
-import { TRAIT_STANDARDS as TRAIT_STANDARDS2 } from "@secondlayer/stacks/clarity";
-import { z as z6 } from "zod/v4";
-async function fetchAbi(contractId) {
-  const contract = await getClient().contracts.get(contractId, {
+import { generateSubgraphCode } from "@secondlayer/scaffold";
+import { z as z4 } from "zod/v4";
+async function fetchAbi(clientProvider, contractId) {
+  const contract = await clientProvider().contracts.get(contractId, {
     includeAbi: true
   });
   if (!contract)
@@ -598,134 +444,26 @@ async function fetchAbi(contractId) {
   }
   return { functions: abi.functions ?? [], maps: abi.maps ?? [] };
 }
-function registerScaffoldTools(server) {
-  defineTool(server, "scaffold_from_trait", "Generate a deploy-ready subgraph scaffold that indexes EVERY contract conforming to a SIP trait (no specific contract needed) — sip-009 → an nft_transfer source, sip-010/sip-013 → ft_transfer. Use scaffold_from_contract/abi instead when targeting one contract. See the secondlayer://traits resource for valid trait ids.", {
-    trait: z6.enum(TRAIT_STANDARDS2).describe("SIP standard to index (sip-009 | sip-010 | sip-013)"),
-    subgraphName: z6.string().optional().describe("Override the subgraph name (defaults to <trait>-transfers)")
-  }, async ({ trait, subgraphName }) => {
-    const code = generateTraitSubgraph({ trait, name: subgraphName });
-    return { content: [{ type: "text", text: code }] };
-  });
+function registerScaffoldTools(server, clientProvider = getClient) {
   defineTool(server, "scaffold_from_contract", "Generate a subgraph scaffold from a deployed Stacks contract. Fetches the ABI automatically.", {
-    contractId: z6.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
-    subgraphName: z6.string().optional().describe("Override the subgraph name (defaults to contract name)")
+    contractId: z4.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
+    subgraphName: z4.string().optional().describe("Override the subgraph name (defaults to contract name)")
   }, async ({ contractId, subgraphName }) => {
-    const { functions, maps } = await fetchAbi(contractId);
+    const { functions, maps } = await fetchAbi(clientProvider, contractId);
     const code = generateSubgraphCode(contractId, functions, subgraphName, maps);
     return { content: [{ type: "text", text: code }] };
   });
-  defineTool(server, "scaffold_from_abi", "Generate a subgraph scaffold from a provided ABI JSON. Use when you already have the ABI.", {
-    abi: z6.string().describe("ABI JSON string (the full contract ABI object)"),
-    contractId: z6.string().describe("Fully qualified contract ID"),
-    subgraphName: z6.string().optional().describe("Override the subgraph name")
-  }, async ({ abi, contractId, subgraphName }) => {
-    let parsed;
-    try {
-      parsed = JSON.parse(abi);
-    } catch {
-      return {
-        content: [{ type: "text", text: "Invalid ABI JSON" }],
-        isError: true
-      };
-    }
-    const code = generateSubgraphCode(contractId, parsed.functions ?? [], subgraphName, parsed.maps ?? []);
-    return { content: [{ type: "text", text: code }] };
-  });
 }
 
 // src/tools/streams.ts
-import { AuthError } from "@secondlayer/sdk";
-import { DECODED_EVENT_TYPES as DECODED_EVENT_TYPES3 } from "@secondlayer/shared";
-import { z as z7 } from "zod/v4";
-var STREAMS_EVENT_TYPES = DECODED_EVENT_TYPES3;
-async function withStreamsAuthHint(fn) {
-  try {
-    return await fn();
-  } catch (err) {
-    if (err instanceof AuthError) {
-      throw Object.assign(new Error(err.message + keyHint), { status: 401 });
-    }
-    throw err;
-  }
-}
 function registerStreamsTools(server, clientProvider = getClient) {
-  defineTool(server, "streams_tip", "Get the current Streams chain tip (latest processed block + lag). Streams requires an API key (SL_API_KEY).", {}, async () => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.tip())));
-  defineTool(server, "streams_events", "List raw chain events from the Streams firehose. Streams requires an API key (SL_API_KEY). Filter by event types, principals, contract, asset, or block range; page with cursor.", {
-    types: z7.array(z7.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to include"),
-    notTypes: z7.array(z7.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to exclude (applied after types)"),
-    contractId: z7.string().optional().describe("Filter by contract id"),
-    sender: z7.string().optional().describe("Filter by sender principal"),
-    recipient: z7.string().optional().describe("Filter by recipient principal"),
-    assetIdentifier: z7.string().optional().describe("Filter by asset identifier"),
-    fromHeight: z7.number().optional().describe("Start block height (inclusive)"),
-    toHeight: z7.number().optional().describe("End block height (inclusive)"),
-    cursor: z7.string().optional().describe("Opaque cursor from a prior response"),
-    limit: z7.number().optional().describe("Max events for this page")
-  }, async (params) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.events.list(params))));
-  defineTool(server, "streams_consume", "Consume a bounded, reorg-aware run of Streams events from a cursor. Walks up to maxPages pages and returns the events, any reorgs observed, and a resume `cursor` to pass back as fromCursor next call — the agent-native consume/resume primitive. Streams requires an API key (SL_API_KEY).", {
-    fromCursor: z7.string().optional().describe("Resume cursor from a prior consume (omit to start at genesis)"),
-    types: z7.array(z7.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to include"),
-    notTypes: z7.array(z7.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to exclude"),
-    contractId: z7.string().optional().describe("Filter by contract id"),
-    sender: z7.string().optional().describe("Filter by sender principal"),
-    recipient: z7.string().optional().describe("Filter by recipient principal"),
-    assetIdentifier: z7.string().optional().describe("Filter by asset identifier"),
-    batchSize: z7.number().optional().describe("Events per page (1–1000, default 100)"),
-    maxPages: z7.number().optional().describe("Max pages to walk this call (1–20, default 5)"),
-    finalizedOnly: z7.boolean().optional().describe("Only emit finalized events; skip reorg handling")
-  }, async (params) => withStreamsAuthHint(async () => {
-    const maxPages = Math.min(Math.max(params.maxPages ?? 5, 1), 20);
-    const batchSize = Math.min(Math.max(params.batchSize ?? 100, 1), 1000);
-    const events = [];
-    const reorgs = [];
-    const result = await clientProvider().streams.events.consume({
-      fromCursor: params.fromCursor ?? null,
-      mode: "bounded",
-      finalizedOnly: params.finalizedOnly,
-      types: params.types,
-      notTypes: params.notTypes,
-      contractId: params.contractId,
-      sender: params.sender,
-      recipient: params.recipient,
-      assetIdentifier: params.assetIdentifier,
-      batchSize,
-      maxPages,
-      onBatch: (batch) => {
-        events.push(...batch);
-      },
-      onReorg: (reorg) => {
-        reorgs.push(reorg);
-      }
-    });
-    return jsonResponse({
-      events,
-      reorgs,
-      cursor: result.cursor,
-      pages: result.pages
-    });
-  }));
-  defineTool(server, "streams_event_by_txid", "List all Streams events emitted by a single transaction. Streams requires an API key (SL_API_KEY).", { txId: z7.string().describe("Transaction id (0x… hash)") }, async ({ txId }) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.events.byTxId(txId))));
-  defineTool(server, "streams_block_events", "List all Streams events in a single block, by height or block hash. Streams requires an API key (SL_API_KEY).", {
-    heightOrHash: z7.string().describe("Block height (digits) or block hash (0x… string)")
-  }, async ({ heightOrHash }) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.blocks.events(/^\d+$/.test(heightOrHash) ? Number(heightOrHash) : heightOrHash))));
-  defineTool(server, "streams_reorgs", "List chain reorgs observed by Streams since a cursor. Streams requires an API key (SL_API_KEY).", {
-    since: z7.string().describe("Cursor to list reorgs since (block:index or ISO timestamp)"),
-    limit: z7.number().optional().describe("Max reorgs to return")
-  }, async (params) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.reorgs.list(params))));
-  defineTool(server, "streams_canonical", "Get the canonical block at a given height from Streams (height + hashes + is_canonical). Streams requires an API key (SL_API_KEY).", { height: z7.number().describe("Block height") }, async ({ height }) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.canonical(height))));
-  defineTool(server, "streams_usage", "Your own Streams consumption (events today + this month) and tier limits (rate limit, retention). Streams requires an API key (SL_API_KEY).", {}, async () => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.usage())));
-  defineTool(server, "streams_dumps", "List the Streams bulk parquet dumps manifest — coverage range, latest_finalized_cursor, and per-file metadata (block range, row count, size, sha256, signed URL). This is the cold backfill path for downloading all raw data; fetch the file URLs directly (e.g. with DuckDB). Requires the dumps base URL to be configured (SL_STREAMS_DUMPS_URL).", {}, async () => jsonResponse(await clientProvider().streams.dumps.list()));
+  defineTool(server, "streams_dumps", "List the Streams bulk parquet dumps manifest — coverage range, latest_finalized_cursor, and per-file metadata (block range, row count, size, sha256, signed URL). This is the cold backfill path for downloading all raw data; fetch the file URLs directly (e.g. with DuckDB). Requires the dumps base URL to be configured (SL_STREAMS_DUMPS_URL). Live Streams reads (tip, events, consume) are REST-only: see /v1/streams/* in the OpenAPI spec.", {}, async () => jsonResponse(await clientProvider().streams.dumps.list()));
 }
 
 // src/tools/subgraphs.ts
 import { bundleSubgraphCode } from "@secondlayer/bundler";
 import { ByoBreakingChangeError } from "@secondlayer/sdk";
-import {
-  generateDrizzleSchema,
-  generateKyselySchema,
-  generatePrismaSchema
-} from "@secondlayer/subgraphs";
-import { z as z8 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 function registerSubgraphTools(server, clientProvider = getClient) {
   defineTool(server, "subgraphs_list", "List all deployed subgraphs. Returns summary fields only, including visibility — public subgraphs are anon-readable at /v1/subgraphs/<name>.", {}, async () => {
     const { data } = await clientProvider().subgraphs.list();
@@ -738,38 +476,22 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       ]
     };
   });
-  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z5.string().describe("Subgraph name") }, async ({ name }) => {
     const detail = await clientProvider().subgraphs.get(name);
     return {
       content: [{ type: "text", text: JSON.stringify(detail, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_spec", "Get generated API documentation for a subgraph. Defaults to compact agent schema; supports OpenAPI JSON and Markdown.", {
-    name: z8.string().describe("Subgraph name"),
-    format: z8.enum(["agent", "openapi", "markdown"]).optional().describe("Spec format to return. Defaults to agent."),
-    serverUrl: z8.string().optional().describe("Override the server URL embedded in generated docs.")
-  }, async ({ name, format = "agent", serverUrl }) => {
-    const options = serverUrl ? { serverUrl } : undefined;
-    const spec = format === "openapi" ? await clientProvider().subgraphs.openapi(name, options) : format === "markdown" ? await clientProvider().subgraphs.markdown(name, options) : await clientProvider().subgraphs.schema(name, options);
-    return {
-      content: [
-        {
-          type: "text",
-          text: typeof spec === "string" ? spec : JSON.stringify(spec, null, 2)
-        }
-      ]
-    };
-  });
   defineTool(server, "subgraphs_query", 'Query rows from a subgraph table (max 200 rows). Filters support operators: "amount.gte": "1000", "sender.neq": "SP...", "name.like": "%token%". Available operators: eq, neq, gt, gte, lt, lte, like. To TAIL new rows (no streaming over MCP): sort=_id, order=desc for the latest, then poll forward with the filter {"_id.gt": "<last _id seen>"}, order=asc. Fetch one row by id with {"_id": "<id>"}. Public subgraphs are also keyless over HTTP at GET /v1/subgraphs/<name>/<table> — { rows, next_cursor, tip } envelope, resume with ?cursor=<next_cursor> + _order=asc|desc (no _offset/_sort on /v1); hand that URL to third parties.', {
-    name: z8.string().describe("Subgraph name"),
-    table: z8.string().describe("Table name"),
-    filters: z8.record(z8.string(), z8.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
-    sort: z8.string().optional().describe("Column to sort by"),
-    order: z8.enum(["asc", "desc"]).optional().describe("Sort order"),
-    limit: z8.number().max(200).optional().describe("Max rows (default 50, max 200)"),
-    offset: z8.number().optional().describe("Offset for pagination"),
-    fields: z8.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
-    count: z8.boolean().optional().describe("If true, return row count instead of rows")
+    name: z5.string().describe("Subgraph name"),
+    table: z5.string().describe("Table name"),
+    filters: z5.record(z5.string(), z5.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
+    sort: z5.string().optional().describe("Column to sort by"),
+    order: z5.enum(["asc", "desc"]).optional().describe("Sort order"),
+    limit: z5.number().max(200).optional().describe("Max rows (default 50, max 200)"),
+    offset: z5.number().optional().describe("Offset for pagination"),
+    fields: z5.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
+    count: z5.boolean().optional().describe("If true, return row count instead of rows")
   }, async ({
     name,
     table,
@@ -801,25 +523,10 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_aggregate", `Compute scalar aggregates over a subgraph table's filtered rows. Supports count, countDistinct, and sum/min/max (numeric columns only — uint/int plus the system _block_height). Filters use the same grammar as subgraphs_query (e.g. {"amount.gte": "1000"}). sum/min/max come back as lossless strings; counts as numbers. With no aggregate requested, returns the row count.`, {
-    name: z8.string().describe("Subgraph name"),
-    table: z8.string().describe("Table name"),
-    filters: z8.record(z8.string(), z8.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
-    count: z8.boolean().optional().describe("Include COUNT(*) of matching rows"),
-    countDistinct: z8.array(z8.string()).optional().describe("Columns to count distinct values of"),
-    sum: z8.array(z8.string()).optional().describe("Numeric columns to sum (lossless string result)"),
-    min: z8.array(z8.string()).optional().describe("Numeric columns to take the minimum of"),
-    max: z8.array(z8.string()).optional().describe("Numeric columns to take the maximum of")
-  }, async ({ name, table, filters, count, countDistinct, sum, min, max }) => {
-    const result = await clientProvider().subgraphs.queryTableAggregate(name, table, { filters, count, countDistinct, sum, min, max });
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "subgraphs_reindex", "Reindex a subgraph from a specific block range. Returns an operationId — poll subgraphs_operation to track progress to completion.", {
-    name: z8.string().describe("Subgraph name"),
-    fromBlock: z8.number().optional().describe("Start block (defaults to beginning)"),
-    toBlock: z8.number().optional().describe("End block (defaults to latest)")
+  defineTool(server, "subgraphs_reindex", "Reindex a subgraph from a specific block range. Returns an operationId — check subgraphs_get (health) or the REST operations endpoint to track progress to completion.", {
+    name: z5.string().describe("Subgraph name"),
+    fromBlock: z5.number().optional().describe("Start block (defaults to beginning)"),
+    toBlock: z5.number().optional().describe("End block (defaults to latest)")
   }, async ({ name, fromBlock, toBlock }) => {
     const result = await clientProvider().subgraphs.reindex(name, {
       fromBlock,
@@ -829,19 +536,10 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_operation", "Check reindex/backfill progress. With operationId, returns that operation's status (poll until status is completed/failed/cancelled); without it, lists recent operations for the subgraph.", {
-    name: z8.string().describe("Subgraph name"),
-    operationId: z8.string().optional().describe("Operation id from reindex/backfill/stop; omit to list recent operations")
-  }, async ({ name, operationId }) => {
-    const result = operationId ? await clientProvider().subgraphs.getOperation(name, operationId) : await clientProvider().subgraphs.operations(name);
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "subgraphs_backfill", "Backfill a subgraph over a block range. Non-destructive forward fill (does not drop existing data) — unlike subgraphs_reindex, and the only data-fill path for BYO subgraphs (reindex is blocked there). Both blocks required. Returns an operationId — poll subgraphs_operation to track progress.", {
-    name: z8.string().describe("Subgraph name"),
-    fromBlock: z8.number().int().nonnegative().describe("Start block (inclusive)"),
-    toBlock: z8.number().int().nonnegative().describe("End block (inclusive)")
+  defineTool(server, "subgraphs_backfill", "Backfill a subgraph over a block range. Non-destructive forward fill (does not drop existing data) — unlike subgraphs_reindex, and the only data-fill path for BYO subgraphs (reindex is blocked there). Both blocks required. Returns an operationId — check subgraphs_get (health) or the REST operations endpoint to track progress.", {
+    name: z5.string().describe("Subgraph name"),
+    fromBlock: z5.number().int().nonnegative().describe("Start block (inclusive)"),
+    toBlock: z5.number().int().nonnegative().describe("End block (inclusive)")
   }, async ({ name, fromBlock, toBlock }) => {
     const result = await clientProvider().subgraphs.backfill(name, {
       fromBlock,
@@ -851,17 +549,17 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_stop", "Cancel an in-flight reindex or backfill operation for a subgraph. Returns the stop request status; poll subgraphs_operation to confirm it reaches a terminal state.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_stop", "Cancel an in-flight reindex or backfill operation for a subgraph. Returns the stop request status; check subgraphs_get (health) or the REST operations endpoint to confirm it reaches a terminal state.", { name: z5.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await clientProvider().subgraphs.stop(name);
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
   defineTool(server, "subgraphs_gaps", "List indexing gaps (missing block ranges) for a subgraph. Each gap reports start/end/size, reason, and detected/resolved timestamps. Feed an unresolved gap's range into subgraphs_backfill to fill it. Defaults to unresolved gaps.", {
-    name: z8.string().describe("Subgraph name"),
-    limit: z8.number().int().positive().optional().describe("Max gaps to return"),
-    offset: z8.number().int().nonnegative().optional().describe("Pagination offset"),
-    resolved: z8.boolean().optional().describe("Filter by resolved state (omit for unresolved only)")
+    name: z5.string().describe("Subgraph name"),
+    limit: z5.number().int().positive().optional().describe("Max gaps to return"),
+    offset: z5.number().int().nonnegative().optional().describe("Pagination offset"),
+    resolved: z5.boolean().optional().describe("Filter by resolved state (omit for unresolved only)")
   }, async ({ name, limit, offset, resolved }) => {
     const result = await clientProvider().subgraphs.gaps(name, {
       limit,
@@ -872,16 +570,16 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z5.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await clientProvider().subgraphs.delete(name);
     return { content: [{ type: "text", text: result.message }] };
   });
   defineTool(server, "subgraphs_deploy", "Deploy a subgraph from TypeScript code. Pass the full defineSubgraph() source — it will be bundled, validated, and deployed. Optional startBlock overrides the source definition for this deploy. Set dryRun to validate and preview the schema/DDL without writing anything. Set databaseUrl to deploy to your own Postgres (BYO data plane) — the server verifies the connection first; with dryRun it returns the DDL + grant script. A breaking BYO schema change is refused and returns a migration plan (drop + rebuild DDL) instead of deploying. Visibility defaults: managed deploys are public (anon-readable at /v1/subgraphs/<name>, name claimed in the global public namespace), BYO deploys are private. Call `subgraphs_reindex` separately if you need a forced reindex.", {
-    code: z8.string().describe("TypeScript source code containing a defineSubgraph() call"),
-    startBlock: z8.number().int().nonnegative().optional().describe("Override the definition startBlock for this deploy"),
-    databaseUrl: z8.string().optional().describe("BYO data plane: Postgres connection string to host the subgraph's schema and rows in your own database"),
-    dryRun: z8.boolean().optional().describe("Validate and preview the deploy (schema/DDL, BYO connection) without writing changes"),
-    visibility: z8.enum(["public", "private"]).optional().describe("Read visibility: public = anon /v1 reads + global name claim; private = owning account's key only. Defaults: managed → public, BYO → private.")
+    code: z5.string().describe("TypeScript source code containing a defineSubgraph() call"),
+    startBlock: z5.number().int().nonnegative().optional().describe("Override the definition startBlock for this deploy"),
+    databaseUrl: z5.string().optional().describe("BYO data plane: Postgres connection string to host the subgraph's schema and rows in your own database"),
+    dryRun: z5.boolean().optional().describe("Validate and preview the deploy (schema/DDL, BYO connection) without writing changes"),
+    visibility: z5.enum(["public", "private"]).optional().describe("Read visibility: public = anon /v1 reads + global name claim; private = owning account's key only. Defaults: managed → public, BYO → private.")
   }, async ({ code, startBlock, databaseUrl, dryRun, visibility }) => {
     const bundled = await bundleSubgraphCode(code);
     try {
@@ -915,58 +613,23 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       throw err;
     }
   });
-  defineTool(server, "subgraphs_publish", "Make a subgraph publicly readable at /v1/subgraphs/<name> — anyone (or any agent) can read it without a key. Claims the name in the global public namespace; fails with PUBLIC_NAME_TAKEN if another account holds it.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_publish", "Make a subgraph publicly readable at /v1/subgraphs/<name> — anyone (or any agent) can read it without a key. Claims the name in the global public namespace; fails with PUBLIC_NAME_TAKEN if another account holds it.", { name: z5.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await clientProvider().subgraphs.publish(name);
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_unpublish", "Make a subgraph private again — /v1 reads then require the owning account's bearer key, and the global public name claim is released.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_unpublish", "Make a subgraph private again — /v1 reads then require the owning account's bearer key, and the global public name claim is released.", { name: z5.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await clientProvider().subgraphs.unpublish(name);
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_read_source", "Fetch the deployed TypeScript source of a subgraph (plus its stored version). Returns a readOnly payload for subgraphs deployed before source capture — in that case the caller should redeploy via CLI before editing.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
-    const source = await clientProvider().subgraphs.getSource(name);
-    return {
-      content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
-    };
-  });
-  defineTool(server, "subgraphs_codegen", "Generate a typed ORM schema (Prisma, Drizzle, or Kysely) for a subgraph's tables so they can be queried from a BYO database. Pass either `code` (defineSubgraph source) or `name` (a deployed subgraph — its captured source is used). Returns the schema as text.", {
-    code: z8.string().optional().describe("defineSubgraph() source (mutually exclusive with name)"),
-    name: z8.string().optional().describe("Deployed subgraph name (mutually exclusive with code)"),
-    target: z8.enum(["prisma", "drizzle", "kysely"]).optional().describe("ORM target (default prisma)"),
-    schemaName: z8.string().optional().describe("Postgres schema name (defaults to subgraph_<name>)")
-  }, async ({ code, name, target = "prisma", schemaName }) => {
-    if (code && name || !code && !name) {
-      throw new Error("Provide exactly one of `code` or `name`.");
-    }
-    let source = code;
-    if (name) {
-      const stored = await clientProvider().subgraphs.getSource(name);
-      if (!stored.sourceCode) {
-        throw new Error(`Subgraph "${name}" has no captured source (deployed before source capture). Redeploy it, or pass its source as \`code\`.`);
-      }
-      source = stored.sourceCode;
-    }
-    const bundled = await bundleSubgraphCode(source);
-    const def = {
-      name: bundled.name,
-      version: bundled.version,
-      description: bundled.description,
-      sources: bundled.sources,
-      schema: bundled.schema,
-      handlers: {}
-    };
-    const out = target === "drizzle" ? generateDrizzleSchema(def, { schemaName }) : target === "kysely" ? generateKyselySchema(def, { schemaName }) : generatePrismaSchema(def, { schemaName });
-    return { content: [{ type: "text", text: out }] };
-  });
 }
 
 // src/tools/subscriptions.ts
 import { CHAIN_TRIGGER_TYPES } from "@secondlayer/shared";
-import { z as z9 } from "zod/v4";
+import { z as z6 } from "zod/v4";
 function registerSubscriptionTools(server, clientProvider = getClient) {
   defineTool(server, "subscriptions_list", "List all subscriptions for the current account. Returns summary fields (no secrets).", {}, async () => {
     const { data } = await clientProvider().subscriptions.list();
@@ -974,34 +637,34 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
     };
   });
-  defineTool(server, "subscriptions_get", "Get full detail for a subscription (filter, auth, retry config, circuit state).", { id: z9.string().describe("Subscription id") }, async ({ id }) => {
+  defineTool(server, "subscriptions_get", "Get full detail for a subscription (filter, auth, retry config, circuit state).", { id: z6.string().describe("Subscription id") }, async ({ id }) => {
     const detail = await clientProvider().subscriptions.get(id);
     return {
       content: [{ type: "text", text: JSON.stringify(detail, null, 2) }]
     };
   });
   defineTool(server, "subscriptions_create", "Create a subscription. Two kinds (mutually exclusive): a SUBGRAPH subscription fires on a subgraph table's rows (set subgraphName + tableName + optional filter); a CHAIN subscription fires on raw chain events with no subgraph (set triggers). Returns `signingSecret` ONCE — forward it to the user so they can wire it into their receiver.", {
-    name: z9.string().describe("Human-readable name, unique per account"),
-    subgraphName: z9.string().optional().describe("Subgraph to subscribe to (subgraph subscription)"),
-    tableName: z9.string().optional().describe("Table within the subgraph (subgraph subscription)"),
-    triggers: z9.array(z9.object({
-      type: z9.enum(CHAIN_TRIGGER_TYPES),
-      contractId: z9.string().optional(),
-      functionName: z9.string().optional(),
-      caller: z9.string().optional(),
-      sender: z9.string().optional(),
-      recipient: z9.string().optional(),
-      assetIdentifier: z9.string().optional(),
-      deployer: z9.string().optional(),
-      contractName: z9.string().optional(),
-      topic: z9.string().optional(),
-      lockedAddress: z9.string().optional(),
-      trait: z9.string().optional(),
-      minAmount: z9.union([z9.string(), z9.number()]).optional(),
-      maxAmount: z9.union([z9.string(), z9.number()]).optional()
+    name: z6.string().describe("Human-readable name, unique per account"),
+    subgraphName: z6.string().optional().describe("Subgraph to subscribe to (subgraph subscription)"),
+    tableName: z6.string().optional().describe("Table within the subgraph (subgraph subscription)"),
+    triggers: z6.array(z6.object({
+      type: z6.enum(CHAIN_TRIGGER_TYPES),
+      contractId: z6.string().optional(),
+      functionName: z6.string().optional(),
+      caller: z6.string().optional(),
+      sender: z6.string().optional(),
+      recipient: z6.string().optional(),
+      assetIdentifier: z6.string().optional(),
+      deployer: z6.string().optional(),
+      contractName: z6.string().optional(),
+      topic: z6.string().optional(),
+      lockedAddress: z6.string().optional(),
+      trait: z6.string().optional(),
+      minAmount: z6.union([z6.string(), z6.number()]).optional(),
+      maxAmount: z6.union([z6.string(), z6.number()]).optional()
     })).optional().describe("Chain triggers (chain subscription) — provide INSTEAD of subgraphName/tableName. Each targets a raw chain event/tx; string fields accept `*` wildcards, `trait` scopes to a SIP/trait. Per-type accepted fields: see the secondlayer://chain-triggers resource. Forward-looking: starts at chain tip, no backfill."),
-    url: z9.string().describe("Webhook URL"),
-    format: z9.enum([
+    url: z6.string().describe("Webhook URL"),
+    format: z6.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -1009,9 +672,9 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional().describe("Wire format (default standard-webhooks)"),
-    runtime: z9.enum(["inngest", "trigger", "cloudflare", "node"]).optional().describe("Receiver runtime label (display only)"),
-    filter: z9.record(z9.string(), z9.unknown()).optional().describe('Scalar filter DSL, e.g. {"amount": {"gte": 100}, "sender": "SP..."}'),
-    authConfig: z9.record(z9.string(), z9.unknown()).optional().describe('Receiver auth sent with each delivery, e.g. {"type": "bearer", "token": "..."}')
+    runtime: z6.enum(["inngest", "trigger", "cloudflare", "node"]).optional().describe("Receiver runtime label (display only)"),
+    filter: z6.record(z6.string(), z6.unknown()).optional().describe('Scalar filter DSL, e.g. {"amount": {"gte": 100}, "sender": "SP..."}'),
+    authConfig: z6.record(z6.string(), z6.unknown()).optional().describe('Receiver auth sent with each delivery, e.g. {"type": "bearer", "token": "..."}')
   }, async (input) => {
     const res = await clientProvider().subscriptions.create(input);
     return {
@@ -1019,12 +682,12 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
     };
   });
   defineTool(server, "subscriptions_update", "Patch a subscription (name, url, filter, authConfig, format, runtime, retry, timeout, concurrency).", {
-    id: z9.string(),
-    name: z9.string().optional().describe("Rename the subscription"),
-    url: z9.string().optional(),
-    filter: z9.record(z9.string(), z9.unknown()).optional(),
-    authConfig: z9.record(z9.string(), z9.unknown()).optional().describe("Receiver auth sent with each delivery (bearer/etc.)"),
-    format: z9.enum([
+    id: z6.string(),
+    name: z6.string().optional().describe("Rename the subscription"),
+    url: z6.string().optional(),
+    filter: z6.record(z6.string(), z6.unknown()).optional(),
+    authConfig: z6.record(z6.string(), z6.unknown()).optional().describe("Receiver auth sent with each delivery (bearer/etc.)"),
+    format: z6.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -1032,51 +695,33 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional(),
-    runtime: z9.enum(["inngest", "trigger", "cloudflare", "node"]).nullable().optional(),
-    maxRetries: z9.number().int().min(0).optional(),
-    timeoutMs: z9.number().int().min(100).optional(),
-    concurrency: z9.number().int().min(1).optional()
+    runtime: z6.enum(["inngest", "trigger", "cloudflare", "node"]).nullable().optional(),
+    maxRetries: z6.number().int().min(0).optional(),
+    timeoutMs: z6.number().int().min(100).optional(),
+    concurrency: z6.number().int().min(1).optional()
   }, async ({ id, ...patch }) => {
     const res = await clientProvider().subscriptions.update(id, patch);
     return {
       content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
     };
   });
-  defineTool(server, "subscriptions_pause", "Pause a subscription. Pending rows remain queued until resumed.", { id: z9.string() }, async ({ id }) => {
-    const res = await clientProvider().subscriptions.pause(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
-    };
-  });
-  defineTool(server, "subscriptions_resume", "Resume a paused or circuit-open subscription and reset circuit failures.", { id: z9.string() }, async ({ id }) => {
-    const res = await clientProvider().subscriptions.resume(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
-    };
-  });
-  defineTool(server, "subscriptions_delete", "Delete a subscription. Pending outbox rows are cascade-deleted.", { id: z9.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_delete", "Delete a subscription. Pending outbox rows are cascade-deleted.", { id: z6.string() }, async ({ id }) => {
     const res = await clientProvider().subscriptions.delete(id);
     return {
       content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
     };
   });
-  defineTool(server, "subscriptions_rotate_secret", "Rotate a subscription signing secret. Returns the new plaintext secret once.", { id: z9.string() }, async ({ id }) => {
-    const res = await clientProvider().subscriptions.rotateSecret(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
-    };
-  });
-  defineTool(server, "subscriptions_test", "Send a one-off test webhook to a subscription's URL (built for its format, SSRF-guarded). Logged as a delivery row — check subscriptions_recent_deliveries. Returns {ok, statusCode, error, durationMs, deliveryId}.", { id: z9.string().describe("Subscription id") }, async ({ id }) => {
+  defineTool(server, "subscriptions_test", "Send a one-off test webhook to a subscription's URL (built for its format, SSRF-guarded). Logged as a delivery row. Returns {ok, statusCode, error, durationMs, deliveryId}.", { id: z6.string().describe("Subscription id") }, async ({ id }) => {
     const res = await clientProvider().subscriptions.test(id);
     return {
       content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
     };
   });
   defineTool(server, "subscriptions_replay", "Replay a block range for a subscription. Replays run at 10% of batch capacity — use sparingly. Pass `force` (a short idempotency suffix) to re-run a range that was already replayed.", {
-    id: z9.string(),
-    fromBlock: z9.number().int().nonnegative(),
-    toBlock: z9.number().int().nonnegative(),
-    force: z9.string().optional().describe("Idempotency suffix to force a duplicate replay of the range")
+    id: z6.string(),
+    fromBlock: z6.number().int().nonnegative(),
+    toBlock: z6.number().int().nonnegative(),
+    force: z6.string().optional().describe("Idempotency suffix to force a duplicate replay of the range")
   }, async ({ id, fromBlock, toBlock, force }) => {
     const res = await clientProvider().subscriptions.replay(id, {
       fromBlock,
@@ -1087,27 +732,6 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
     };
   });
-  defineTool(server, "subscriptions_dead", "Return the last 100 dead-letter outbox rows for a subscription.", { id: z9.string() }, async ({ id }) => {
-    const { data } = await clientProvider().subscriptions.dead(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  });
-  defineTool(server, "subscriptions_requeue_dead", "Requeue one dead-letter outbox row for delivery retry.", {
-    id: z9.string(),
-    outboxId: z9.string()
-  }, async ({ id, outboxId }) => {
-    const res = await clientProvider().subscriptions.requeueDead(id, outboxId);
-    return {
-      content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
-    };
-  });
-  defineTool(server, "subscriptions_recent_deliveries", "Return the last 100 delivery attempts (attempt #, status code, duration, truncated response).", { id: z9.string() }, async ({ id }) => {
-    const { data } = await clientProvider().subscriptions.recentDeliveries(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-    };
-  });
 }
 
 // src/server.ts
@@ -1122,8 +746,6 @@ function createServer() {
   registerSubgraphTools(server);
   registerSubscriptionTools(server);
   registerAccountTools(server);
-  registerProjectTools(server);
-  registerDatasetTools(server);
   registerIndexTools(server);
   registerStreamsTools(server);
   registerContractTools(server);
@@ -1136,5 +758,5 @@ var server = createServer();
 var transport = new StdioServerTransport;
 await server.connect(transport);
 
-//# debugId=9CFDE0E3EC20CFB264756E2164756E21
+//# debugId=63BF73C1A0B18EDD64756E2164756E21
 //# sourceMappingURL=bin.js.map