@secondlayer/mcp 3.0.1 → 3.1.1

package/dist/bin.js

@@ -9,6 +9,69 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
+// src/lib/client.ts
+import { SecondLayer } from "@secondlayer/sdk";
+var instance = null;
+function readApiKey() {
+  return process.env.SL_API_KEY;
+}
+function getClient() {
+  if (!instance) {
+    const apiKey = readApiKey();
+    const baseUrl = process.env.SECONDLAYER_API_URL;
+    instance = new SecondLayer({
+      ...apiKey ? { apiKey } : {},
+      origin: "mcp",
+      ...baseUrl ? { baseUrl } : {}
+    });
+  }
+  return instance;
+}
+var keyHint = " — set SL_API_KEY to an sk-sl_ API key from " + "https://secondlayer.tools/platform/api-keys for write and account operations";
+async function apiRequest(method, path, body) {
+  const apiKey = readApiKey();
+  const baseUrl = process.env.SECONDLAYER_API_URL || "https://api.secondlayer.tools";
+  const res = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+    },
+    body: body ? JSON.stringify(body) : undefined
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    const needsKey = !apiKey && (res.status === 401 || res.status === 403);
+    throw Object.assign(new Error((text || `HTTP ${res.status}`) + (needsKey ? keyHint : "")), { status: res.status });
+  }
+  if (res.status === 204)
+    return;
+  return res.json();
+}
+
+// src/lib/format.ts
+function formatSubgraphSummary(s) {
+  return {
+    name: s.name,
+    status: s.status,
+    tables: Array.isArray(s.tables) ? s.tables : Object.keys(s.tables),
+    lastProcessedBlock: s.lastProcessedBlock
+  };
+}
+function withCap(items, cap) {
+  return {
+    items: items.slice(0, cap),
+    truncated: items.length > cap,
+    total: items.length
+  };
+}
+function jsonResponse(data, isError) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    ...isError && { isError: true }
+  };
+}
+
 // src/resources.ts
 var FILTERS_REFERENCE = [
   {
@@ -64,7 +127,54 @@ var COLUMN_TYPES = [
     description: "Column options: nullable allows NULL, indexed creates a B-tree index, search enables full-text search"
   }
 ];
+var CAPABILITIES = {
+  products: [
+    "datasets — public foundation datasets (datasets_list, datasets_query)",
+    "index — decoded L2 events + contract calls (index_ft_transfers, index_nft_transfers, index_events, index_contract_calls)",
+    "streams — raw chain event firehose (streams_tip, streams_events)",
+    "contracts — trait-based contract discovery (contracts_find)",
+    "subgraphs — author/deploy/query custom indexes (subgraphs_deploy, subgraphs_query, subgraphs_list, subgraphs_get, subgraphs_reindex, subgraphs_delete)",
+    "subscriptions — webhook delivery of subgraph rows (subscriptions_create, subscriptions_list, subscriptions_update, …)",
+    "account — identity + plan (account_whoami)"
+  ],
+  discoverFirst: "Call datasets_list / contracts_find to learn what exists before querying."
+};
+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: "reads public during open beta; writes require an API key"
+};
+async function buildContext(deps = {
+  clientProvider: getClient,
+  accountRequest: () => apiRequest("GET", "/api/accounts/me")
+}) {
+  const unavailable = "unavailable: set SL_API_KEY";
+  const subgraphs = await deps.clientProvider().subgraphs.list().then((r) => r.data.map(formatSubgraphSummary)).catch(() => unavailable);
+  const subscriptions = await deps.clientProvider().subscriptions.list().then((r) => ({
+    count: r.data.length,
+    statuses: r.data.map((s) => s.status)
+  })).catch(() => unavailable);
+  const account = await deps.accountRequest().catch(() => unavailable);
+  return {
+    authState: { apiKeySet: Boolean(process.env.SL_API_KEY) },
+    whatExists: { subgraphs, subscriptions, account },
+    whatYouCanDo: CAPABILITIES,
+    readAuthTiers: READ_AUTH_TIERS
+  };
+}
 function registerResources(server) {
+  server.resource("context", "secondlayer://context", {
+    description: "Live agent context — what exists (your subgraphs, subscriptions, account), what you can do, and read-auth tiers. Read this first."
+  }, async () => ({
+    contents: [
+      {
+        uri: "secondlayer://context",
+        mimeType: "application/json",
+        text: JSON.stringify(await buildContext(), null, 2)
+      }
+    ]
+  }));
   server.resource("filters", "secondlayer://filters", { description: "Event filter types and their available fields" }, async () => ({
     contents: [
       {
@@ -85,68 +195,8 @@ function registerResources(server) {
   }));
 }
 
-// src/lib/client.ts
-import { SecondLayer } from "@secondlayer/sdk";
-var instance = null;
-function readApiKey() {
-  return process.env.SL_API_KEY;
-}
-function getClient() {
-  if (!instance) {
-    const apiKey = readApiKey();
-    const baseUrl = process.env.SECONDLAYER_API_URL;
-    instance = new SecondLayer({
-      ...apiKey ? { apiKey } : {},
-      origin: "mcp",
-      ...baseUrl ? { baseUrl } : {}
-    });
-  }
-  return instance;
-}
-var keyHint = " — set SL_API_KEY to an sk-sl_ API key from " + "https://secondlayer.tools/platform/api-keys for write and account operations";
-async function apiRequest(method, path, body) {
-  const apiKey = readApiKey();
-  const baseUrl = process.env.SECONDLAYER_API_URL || "https://api.secondlayer.tools";
-  const res = await fetch(`${baseUrl}${path}`, {
-    method,
-    headers: {
-      "Content-Type": "application/json",
-      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
-    },
-    body: body ? JSON.stringify(body) : undefined
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    const needsKey = !apiKey && (res.status === 401 || res.status === 403);
-    throw Object.assign(new Error((text || `HTTP ${res.status}`) + (needsKey ? keyHint : "")), { status: res.status });
-  }
-  if (res.status === 204)
-    return;
-  return res.json();
-}
-
-// src/lib/format.ts
-function formatSubgraphSummary(s) {
-  return {
-    name: s.name,
-    status: s.status,
-    tables: Array.isArray(s.tables) ? s.tables : Object.keys(s.tables),
-    lastProcessedBlock: s.lastProcessedBlock
-  };
-}
-function withCap(items, cap) {
-  return {
-    items: items.slice(0, cap),
-    truncated: items.length > cap,
-    total: items.length
-  };
-}
-function jsonResponse(data, isError) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-    ...isError && { isError: true }
-  };
-}
+// src/tools/account.ts
+import { z } from "zod/v4";
 
 // src/lib/tool.ts
 function defineTool(server, name, description, schema, handler) {
@@ -177,11 +227,113 @@ 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.", {}, async () => {
+    const result = await apiRequest("GET", "/api/billing/status");
+    return jsonResponse(result);
+  });
+}
+
+// src/tools/contracts.ts
+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.', {
+    trait: z2.string().describe('Required. Trait to match (e.g. "sip-010").'),
+    conformance: z2.enum(["declared", "inferred", "any"]).optional().describe("declared = parsed from source, inferred = ABI shape-match, any = either (default)"),
+    include: z2.literal("abi").optional().describe(`Set to "abi" to include each contract's full ABI`),
+    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)));
+}
+
+// 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 a cursor-paginated Foundation Dataset by slug (e.g. "stx-transfers", "sbtc/events", "pox-4/calls", "bns/events"). Filters are passed through as documented query params (e.g. {"sender": "SP...", "from_block": "150000"}). Returns { rows, next_cursor, tip }. Call datasets_list first to discover slugs.', {
+    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.query(slug, params);
+    return jsonResponse(result);
+  });
+}
+
+// src/tools/index.ts
+import { z as z4 } from "zod/v4";
+var INDEX_EVENT_TYPES = [
+  "ft_transfer",
+  "nft_transfer",
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_mint",
+  "ft_burn",
+  "nft_mint",
+  "nft_burn",
+  "print"
+];
+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")
+};
+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")
+  }, 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)")
+  }, 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). For ft/nft transfers prefer index_ft_transfers / index_nft_transfers.", {
+    eventType: z4.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")
+  }, 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). 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")
+  }, async (params) => jsonResponse(await clientProvider().index.contractCalls.list(params)));
 }
 
 // src/tools/scaffold.ts
 import { generateSubgraphCode } from "@secondlayer/scaffold";
-import { z } from "zod/v4";
+import { z as z5 } from "zod/v4";
 var API_BASE = process.env.SECONDLAYER_API_URL || "https://api.secondlayer.tools";
 async function fetchAbi(contractId) {
   const res = await fetch(`${API_BASE}/api/node/contracts/${contractId}/abi`, {
@@ -200,17 +352,17 @@ async function fetchAbi(contractId) {
 }
 function registerScaffoldTools(server) {
   defineTool(server, "scaffold_from_contract", "Generate a subgraph scaffold from a deployed Stacks contract. Fetches the ABI automatically.", {
-    contractId: z.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
-    subgraphName: z.string().optional().describe("Override the subgraph name (defaults to contract name)")
+    contractId: z5.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
+    subgraphName: z5.string().optional().describe("Override the subgraph name (defaults to contract name)")
   }, async ({ contractId, subgraphName }) => {
     const { functions, maps } = await fetchAbi(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: z.string().describe("ABI JSON string (the full contract ABI object)"),
-    contractId: z.string().describe("Fully qualified contract ID"),
-    subgraphName: z.string().optional().describe("Override the subgraph name")
+    abi: z5.string().describe("ABI JSON string (the full contract ABI object)"),
+    contractId: z5.string().describe("Fully qualified contract ID"),
+    subgraphName: z5.string().optional().describe("Override the subgraph name")
   }, async ({ abi, contractId, subgraphName }) => {
     let parsed;
     try {
@@ -226,9 +378,51 @@ function registerScaffoldTools(server) {
   });
 }
 
+// src/tools/streams.ts
+import { AuthError } from "@secondlayer/sdk";
+import { z as z6 } from "zod/v4";
+var STREAMS_EVENT_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "print"
+];
+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: z6.array(z6.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to include"),
+    notTypes: z6.array(z6.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to exclude (applied after types)"),
+    contractId: z6.string().optional().describe("Filter by contract id"),
+    sender: z6.string().optional().describe("Filter by sender principal"),
+    recipient: z6.string().optional().describe("Filter by recipient principal"),
+    assetIdentifier: z6.string().optional().describe("Filter by asset identifier"),
+    fromBlock: z6.number().optional().describe("Start block (inclusive)"),
+    toBlock: z6.number().optional().describe("End block (inclusive)"),
+    cursor: z6.string().optional().describe("Opaque cursor from a prior response"),
+    limit: z6.number().optional().describe("Max events for this page")
+  }, async (params) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.events.list(params))));
+}
+
 // src/tools/subgraphs.ts
 import { bundleSubgraphCode } from "@secondlayer/bundler";
-import { z as z2 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 function registerSubgraphTools(server, clientProvider = getClient) {
   defineTool(server, "subgraphs_list", "List all deployed subgraphs. Returns summary fields only.", {}, async () => {
     const { data } = await clientProvider().subgraphs.list();
@@ -241,16 +435,16 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       ]
     };
   });
-  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z2.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z7.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: z2.string().describe("Subgraph name"),
-    format: z2.enum(["agent", "openapi", "markdown"]).optional().describe("Spec format to return. Defaults to agent."),
-    serverUrl: z2.string().optional().describe("Override the server URL embedded in generated docs.")
+    name: z7.string().describe("Subgraph name"),
+    format: z7.enum(["agent", "openapi", "markdown"]).optional().describe("Spec format to return. Defaults to agent."),
+    serverUrl: z7.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);
@@ -264,15 +458,15 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     };
   });
   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.', {
-    name: z2.string().describe("Subgraph name"),
-    table: z2.string().describe("Table name"),
-    filters: z2.record(z2.string(), z2.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
-    sort: z2.string().optional().describe("Column to sort by"),
-    order: z2.enum(["asc", "desc"]).optional().describe("Sort order"),
-    limit: z2.number().max(200).optional().describe("Max rows (default 50, max 200)"),
-    offset: z2.number().optional().describe("Offset for pagination"),
-    fields: z2.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
-    count: z2.boolean().optional().describe("If true, return row count instead of rows")
+    name: z7.string().describe("Subgraph name"),
+    table: z7.string().describe("Table name"),
+    filters: z7.record(z7.string(), z7.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
+    sort: z7.string().optional().describe("Column to sort by"),
+    order: z7.enum(["asc", "desc"]).optional().describe("Sort order"),
+    limit: z7.number().max(200).optional().describe("Max rows (default 50, max 200)"),
+    offset: z7.number().optional().describe("Offset for pagination"),
+    fields: z7.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
+    count: z7.boolean().optional().describe("If true, return row count instead of rows")
   }, async ({
     name,
     table,
@@ -305,9 +499,9 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     };
   });
   defineTool(server, "subgraphs_reindex", "Reindex a subgraph from a specific block range.", {
-    name: z2.string().describe("Subgraph name"),
-    fromBlock: z2.number().optional().describe("Start block (defaults to beginning)"),
-    toBlock: z2.number().optional().describe("End block (defaults to latest)")
+    name: z7.string().describe("Subgraph name"),
+    fromBlock: z7.number().optional().describe("Start block (defaults to beginning)"),
+    toBlock: z7.number().optional().describe("End block (defaults to latest)")
   }, async ({ name, fromBlock, toBlock }) => {
     const result = await clientProvider().subgraphs.reindex(name, {
       fromBlock,
@@ -317,13 +511,13 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z2.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z7.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. Call `subgraphs_reindex` separately if you need a forced reindex.", {
-    code: z2.string().describe("TypeScript source code containing a defineSubgraph() call"),
-    startBlock: z2.number().int().nonnegative().optional().describe("Override the definition startBlock for this deploy")
+    code: z7.string().describe("TypeScript source code containing a defineSubgraph() call"),
+    startBlock: z7.number().int().nonnegative().optional().describe("Override the definition startBlock for this deploy")
   }, async ({ code, startBlock }) => {
     const bundled = await bundleSubgraphCode(code);
     const result = await clientProvider().subgraphs.deploy({
@@ -340,7 +534,7 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       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: z2.string().describe("Subgraph name") }, async ({ name }) => {
+  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: z7.string().describe("Subgraph name") }, async ({ name }) => {
     const source = await clientProvider().subgraphs.getSource(name);
     return {
       content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
@@ -349,7 +543,7 @@ function registerSubgraphTools(server, clientProvider = getClient) {
 }
 
 // src/tools/subscriptions.ts
-import { z as z3 } from "zod/v4";
+import { z as z8 } 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();
@@ -357,18 +551,18 @@ 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: z3.string().describe("Subscription id") }, async ({ id }) => {
+  defineTool(server, "subscriptions_get", "Get full detail for a subscription (filter, auth, retry config, circuit state).", { id: z8.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. Returns `signingSecret` ONCE — forward it to the user so they can wire it into their receiver.", {
-    name: z3.string().describe("Human-readable name, unique per account"),
-    subgraphName: z3.string().describe("Subgraph to subscribe to"),
-    tableName: z3.string().describe("Table within the subgraph"),
-    url: z3.string().describe("Webhook URL"),
-    format: z3.enum([
+    name: z8.string().describe("Human-readable name, unique per account"),
+    subgraphName: z8.string().describe("Subgraph to subscribe to"),
+    tableName: z8.string().describe("Table within the subgraph"),
+    url: z8.string().describe("Webhook URL"),
+    format: z8.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -376,8 +570,8 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional().describe("Wire format (default standard-webhooks)"),
-    runtime: z3.enum(["inngest", "trigger", "cloudflare", "node"]).optional().describe("Receiver runtime label (display only)"),
-    filter: z3.record(z3.string(), z3.unknown()).optional().describe('Scalar filter DSL, e.g. {"amount": {"gte": 100}, "sender": "SP..."}')
+    runtime: z8.enum(["inngest", "trigger", "cloudflare", "node"]).optional().describe("Receiver runtime label (display only)"),
+    filter: z8.record(z8.string(), z8.unknown()).optional().describe('Scalar filter DSL, e.g. {"amount": {"gte": 100}, "sender": "SP..."}')
   }, async (input) => {
     const res = await clientProvider().subscriptions.create(input);
     return {
@@ -385,10 +579,10 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
     };
   });
   defineTool(server, "subscriptions_update", "Patch a subscription (url, filter, format, runtime, retry, timeout, concurrency).", {
-    id: z3.string(),
-    url: z3.string().optional(),
-    filter: z3.record(z3.string(), z3.unknown()).optional(),
-    format: z3.enum([
+    id: z8.string(),
+    url: z8.string().optional(),
+    filter: z8.record(z8.string(), z8.unknown()).optional(),
+    format: z8.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -396,44 +590,44 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional(),
-    runtime: z3.enum(["inngest", "trigger", "cloudflare", "node"]).nullable().optional(),
-    maxRetries: z3.number().int().min(0).optional(),
-    timeoutMs: z3.number().int().min(100).optional(),
-    concurrency: z3.number().int().min(1).optional()
+    runtime: z8.enum(["inngest", "trigger", "cloudflare", "node"]).nullable().optional(),
+    maxRetries: z8.number().int().min(0).optional(),
+    timeoutMs: z8.number().int().min(100).optional(),
+    concurrency: z8.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: z3.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_pause", "Pause a subscription. Pending rows remain queued until resumed.", { id: z8.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: z3.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_resume", "Resume a paused or circuit-open subscription and reset circuit failures.", { id: z8.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: z3.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_delete", "Delete a subscription. Pending outbox rows are cascade-deleted.", { id: z8.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: z3.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_rotate_secret", "Rotate a subscription signing secret. Returns the new plaintext secret once.", { id: z8.string() }, async ({ id }) => {
     const res = await clientProvider().subscriptions.rotateSecret(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.", {
-    id: z3.string(),
-    fromBlock: z3.number().int().nonnegative(),
-    toBlock: z3.number().int().nonnegative()
+    id: z8.string(),
+    fromBlock: z8.number().int().nonnegative(),
+    toBlock: z8.number().int().nonnegative()
   }, async ({ id, fromBlock, toBlock }) => {
     const res = await clientProvider().subscriptions.replay(id, {
       fromBlock,
@@ -443,22 +637,22 @@ 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: z3.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_dead", "Return the last 100 dead-letter outbox rows for a subscription.", { id: z8.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: z3.string(),
-    outboxId: z3.string()
+    id: z8.string(),
+    outboxId: z8.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: z3.string() }, async ({ id }) => {
+  defineTool(server, "subscriptions_recent_deliveries", "Return the last 100 delivery attempts (attempt #, status code, duration, truncated response).", { id: z8.string() }, async ({ id }) => {
     const { data } = await clientProvider().subscriptions.recentDeliveries(id);
     return {
       content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
@@ -478,6 +672,10 @@ function createServer() {
   registerSubgraphTools(server);
   registerSubscriptionTools(server);
   registerAccountTools(server);
+  registerDatasetTools(server);
+  registerIndexTools(server);
+  registerStreamsTools(server);
+  registerContractTools(server);
   registerResources(server);
   return server;
 }
@@ -487,5 +685,5 @@ var server = createServer();
 var transport = new StdioServerTransport;
 await server.connect(transport);
 
-//# debugId=288FE5410327CFDB64756E2164756E21
+//# debugId=911BD1E066921C1164756E2164756E21
 //# sourceMappingURL=bin.js.map