@secondlayer/mcp 11.3.0 → 11.5.0

package/README.md

@@ -85,7 +85,7 @@ bunx -p @secondlayer/mcp secondlayer-mcp-http
 | **Instance** (1) | `instance_status` |
 | **Archive** (5) | `archive_verify`, `archive_bootstrap`, `archive_repair`, `archive_latest`, `archive_quote` |
 | **Credits** (1) | `credits_balance` (needs `SECONDLAYER_API_KEY`) |
-| **Account** (2) | `account_whoami`, `account_create_key` (only when pointed at `https://api.secondlayer.tools`) |
+| **Account** (4) | `account_whoami`, `account_create_key`, `account_list_keys`, `account_rotate_key` (only when pointed at `https://api.secondlayer.tools`) |
 
 Verify after mutating: `subgraphs_operations` for deploy/reindex/backfill/stop,
 `webhooks_deliveries` for create/test/replay. Empty index:

package/dist/bin-http.js

@@ -24,6 +24,7 @@ function isHostedArchiveUrl(url) {
 }
 
 // src/lib/tool.ts
+import { z } from "zod";
 var registeredToolNames = new Set;
 var serverToolNames = new WeakMap;
 var serverToolFilters = new WeakMap;
@@ -77,7 +78,10 @@ function defineTool(server, name, description, schema, handler) {
   const names = serverToolNames.get(server) ?? new Set;
   names.add(name);
   serverToolNames.set(server, names);
-  server.tool(name, description, schema, wrappedHandler);
+  const registered = server.tool(name, description, schema, wrappedHandler);
+  if (registered) {
+    registered.inputSchema = z.strictObject(schema);
+  }
 }
 
 // src/resources.ts
@@ -457,19 +461,37 @@ async function buildSamplesResource(contractId, clientProvider = getClient) {
 }
 
 // src/tools/account.ts
-import { z } from "zod";
-function registerAccountTools(server, request = apiRequest) {
+import { z as z2 } from "zod";
+function registerAccountTools(server, request = apiRequest, currentKey = readApiKey) {
   defineTool(server, "account_whoami", "Show the archive account email at api.secondlayer.tools, not the self-host instance.", {}, async () => {
     const result = await request("GET", "/api/accounts/me");
     return jsonResponse(result);
   });
   defineTool(server, "account_create_key", "Mint an account key (sk-sl_*) for archive credits, quote, and fetch at api.secondlayer.tools. The returned `key` is shown ONCE.", {
-    name: z.string().optional().describe("Optional label for the key")
+    name: z2.string().optional().describe("Optional label for the key")
   }, async ({ name }) => jsonResponse(await request("POST", "/api/keys", { name })));
+  defineTool(server, "account_list_keys", "List this account's active account keys at api.secondlayer.tools: id, prefix, name, last read. Never returns a secret. Use an id with account_rotate_key.", {}, async () => {
+    const keys = await activeAccountKeys(request);
+    return jsonResponse({ keys });
+  });
+  defineTool(server, "account_rotate_key", "Replace an account key's secret at api.secondlayer.tools, keeping its name. The old secret gets 401 at once, with no grace period, so everything using it breaks until updated: get human confirmation first. The returned key is shown ONCE. Refuses the key this server runs on.", {
+    id: z2.string().uuid().describe("Key id from account_list_keys")
+  }, async ({ id }) => {
+    const { keys } = await request("GET", "/api/keys");
+    const row = keys.find((k) => k.id === id);
+    if (row && currentKey()?.startsWith(row.prefix)) {
+      throw new Error("This server runs on that key and can't update its own env. Rotate it with the secondlayer CLI or on /account/keys, then restart the server.");
+    }
+    return jsonResponse(await request("POST", `/api/keys/${id}/rotate`, {}));
+  });
+}
+async function activeAccountKeys(request) {
+  const { keys } = await request("GET", "/api/keys");
+  return keys.filter((k) => k.status === "active" && k.product === "account").map(({ rowsDaily: _rowsDaily, ...rest }) => rest);
 }
 
 // src/tools/archive-cli.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/lib/exec-cli.ts
 import {
@@ -613,9 +635,9 @@ function cliResponse(result) {
 }
 function registerArchiveCliTools(server, exec = execSecondlayer) {
   defineTool(server, "archive_bootstrap", "Restore verified history into this instance (secondlayer bootstrap --against … --yes --json). Metered against the official archive; quote happens inside the CLI. After bootstrap, poll instance_status until decoders ok, then archive_verify, then codegen_index_schema. Do not download parquet.", {
-    against: z2.string().describe("Archive manifest URL"),
-    fromBlock: z2.number().int().nonnegative().optional().describe("Restore from this height instead of genesis"),
-    toBlock: z2.number().int().nonnegative().optional().describe("Stop at this height instead of the archive tip")
+    against: z3.string().describe("Archive manifest URL"),
+    fromBlock: z3.number().int().nonnegative().optional().describe("Restore from this height instead of genesis"),
+    toBlock: z3.number().int().nonnegative().optional().describe("Stop at this height instead of the archive tip")
   }, async ({ against, fromBlock, toBlock }) => {
     const args = ["--against", against, "--yes", "--json"];
     if (fromBlock !== undefined)
@@ -625,10 +647,10 @@ function registerArchiveCliTools(server, exec = execSecondlayer) {
     return cliResponse(await exec("bootstrap", args));
   });
   defineTool(server, "archive_repair", "Plan (default) or apply a repair of local chain data against a signed archive. Metered when apply fetches from the official archive. After apply, poll instance_status until decoders ok, then archive_verify. Do not download parquet.", {
-    against: z2.string().describe("Archive manifest URL"),
-    apply: z2.boolean().optional().describe("Write the repair (default plan-only)"),
-    fromBlock: z2.number().int().nonnegative().optional().describe("First height to consider"),
-    toBlock: z2.number().int().nonnegative().optional().describe("Last height to consider")
+    against: z3.string().describe("Archive manifest URL"),
+    apply: z3.boolean().optional().describe("Write the repair (default plan-only)"),
+    fromBlock: z3.number().int().nonnegative().optional().describe("First height to consider"),
+    toBlock: z3.number().int().nonnegative().optional().describe("Last height to consider")
   }, async ({ against, apply, fromBlock, toBlock }) => {
     const args = ["--against", against, "--json"];
     if (apply)
@@ -642,14 +664,14 @@ function registerArchiveCliTools(server, exec = execSecondlayer) {
 }
 
 // src/tools/archive.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var FLOW = ["bootstrap", "repair"];
 function registerArchiveTools(server, clientProvider = getClient, archiveOpsClientProvider = getArchiveOpsClient) {
   defineTool(server, "archive_verify", "Read-only, free compare of this instance against a signed archive (POST /v1/archive/verify). unanchored means pin a key or check the URL — not that the instance is fine. After bootstrap, poll instance_status until decoders ok, then this, then codegen_index_schema. Do not download parquet.", {
-    against: z3.string().describe("Archive manifest URL"),
-    fromBlock: z3.number().int().nonnegative().optional().describe("First height (inclusive)"),
-    toBlock: z3.number().int().nonnegative().optional().describe("Last height (inclusive)"),
-    target: z3.string().optional().describe("Verify target (default raw)")
+    against: z4.string().describe("Archive manifest URL"),
+    fromBlock: z4.number().int().nonnegative().optional().describe("First height (inclusive)"),
+    toBlock: z4.number().int().nonnegative().optional().describe("Last height (inclusive)"),
+    target: z4.string().optional().describe("Verify target (default raw)")
   }, async ({ against, fromBlock, toBlock, target }) => jsonResponse(await clientProvider().archive.verify({
     against,
     fromBlock,
@@ -657,11 +679,11 @@ function registerArchiveTools(server, clientProvider = getClient, archiveOpsClie
     target
   })));
   defineTool(server, "archive_latest", "Signed pointer to the official archive tree (hosted). Needs SECONDLAYER_API_KEY (sk-sl_*), not INSTANCE_TOKEN. Use the returned origin as --against for archive_bootstrap. Do not download parquet.", {
-    against: z3.string().optional().describe("Override latest.json URL (default official tree)")
+    against: z4.string().optional().describe("Override latest.json URL (default official tree)")
   }, async ({ against }) => jsonResponse(await archiveOpsClientProvider().archive.latest(against)));
   defineTool(server, "archive_quote", "Price a hosted archive fetch (metered). Needs SECONDLAYER_API_KEY (sk-sl_*), not INSTANCE_TOKEN. Quote happens here; bootstrap/repair also quote inside the CLI. Do not download parquet.", {
-    paths: z3.array(z3.string()).describe("Partition paths to price"),
-    flow: z3.enum(FLOW).describe("bootstrap or repair")
+    paths: z4.array(z4.string()).describe("Partition paths to price"),
+    flow: z4.enum(FLOW).describe("bootstrap or repair")
   }, async ({ paths, flow }) => jsonResponse(await archiveOpsClientProvider().archive.quote({ paths, flow })));
   defineTool(server, "credits_balance", "Archive credits balance at api.secondlayer.tools. Needs SECONDLAYER_API_KEY (sk-sl_*); INSTANCE_TOKEN is the instance.", {}, async () => jsonResponse(await archiveOpsClientProvider().archive.credits.balance()));
 }
@@ -670,14 +692,14 @@ function registerArchiveTools(server, clientProvider = getClient, archiveOpsClie
 import {
   generateIndexSchema
 } from "@secondlayer/subgraphs";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var TARGETS = ["prisma", "kysely", "drizzle", "json-schema"];
 function registerCodegenTools(server) {
   defineTool(server, "codegen_index_schema", "Generate an ORM schema for the Index tables (blocks, transactions, decoded_events, …) — the same output as `sl codegen index`. Returns the file contents as text; write it wherever your project keeps its schema. Use `tables` to emit only what you read.", {
-    target: z4.enum(TARGETS).optional().describe("Output flavor (default kysely)"),
-    tables: z4.array(z4.string()).optional().describe("Restrict to these Index tables (default: all)"),
-    schemaName: z4.string().optional().describe("Postgres schema to qualify table names with"),
-    datasourceEnv: z4.string().optional().describe("Prisma only: datasource url env var (default DATABASE_URL)")
+    target: z5.enum(TARGETS).optional().describe("Output flavor (default kysely)"),
+    tables: z5.array(z5.string()).optional().describe("Restrict to these Index tables (default: all)"),
+    schemaName: z5.string().optional().describe("Postgres schema to qualify table names with"),
+    datasourceEnv: z5.string().optional().describe("Prisma only: datasource url env var (default DATABASE_URL)")
   }, ({ target, tables, schemaName, datasourceEnv }) => textResponse(generateIndexSchema(target ?? "kysely", {
     tables,
     schemaName,
@@ -686,17 +708,17 @@ function registerCodegenTools(server) {
 }
 
 // src/tools/contracts.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 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: z5.string().describe('Required. Trait to match (e.g. "sip-010").'),
-    conformance: z5.enum(["declared", "inferred", "any"]).optional().describe("declared = parsed from source, inferred = ABI shape-match, any = either (default)"),
-    include: z5.literal("abi").optional().describe(`Set to "abi" to include each contract's full ABI`),
-    limit: z5.number().optional().describe("Page size, 1–500 (default 100)"),
-    cursor: z5.string().optional().describe("Opaque cursor from a prior response's next_cursor")
+    trait: z6.string().describe('Required. Trait to match (e.g. "sip-010").'),
+    conformance: z6.enum(["declared", "inferred", "any"]).optional().describe("declared = parsed from source, inferred = ABI shape-match, any = either (default)"),
+    include: z6.literal("abi").optional().describe(`Set to "abi" to include each contract's full ABI`),
+    limit: z6.number().optional().describe("Page size, 1–500 (default 100)"),
+    cursor: z6.string().optional().describe("Opaque cursor from a prior response's next_cursor")
   }, async (params) => jsonResponse(await clientProvider().contracts.list(params)));
   defineTool(server, "contracts_get_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 subgraphs_scaffold.", {
-    contractId: z5.string().describe("Fully qualified contract id (e.g. SP….amm-pool-v2-01)")
+    contractId: z6.string().describe("Fully qualified contract id (e.g. SP….amm-pool-v2-01)")
   }, async ({ contractId }) => {
     const contract = await clientProvider().contracts.get(contractId, {
       includeAbi: true
@@ -713,17 +735,17 @@ function registerContractTools(server, clientProvider = getClient) {
 
 // src/tools/index.ts
 import { DECODED_EVENT_TYPES } from "@secondlayer/shared";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var INDEX_EVENT_TYPES = DECODED_EVENT_TYPES;
 var rangeFilters = {
-  contractId: z6.string().optional().describe("Filter by contract id"),
-  fromHeight: z6.number().optional().describe("Start block height (inclusive)"),
-  toHeight: z6.number().optional().describe("End block height (inclusive)"),
-  cursor: z6.string().optional().describe("Opaque cursor from a prior response's next_cursor"),
-  limit: z6.number().optional().describe("Max rows for this page")
+  contractId: z7.string().optional().describe("Filter by contract id"),
+  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's next_cursor"),
+  limit: z7.number().optional().describe("Max rows for this page")
 };
 var orderFilter = {
-  order: z6.enum(["asc", "desc"]).optional().describe("asc (default) reads oldest first; desc reads newest first. A cursor only resumes under the order that issued it.")
+  order: z7.enum(["asc", "desc"]).optional().describe("asc (default) reads oldest first; desc reads newest first. A cursor only resumes under the order that issued it.")
 };
 var heightFilters = {
   fromHeight: rangeFilters.fromHeight,
@@ -735,47 +757,47 @@ function registerIndexTools(server, clientProvider = getClient) {
   defineTool(server, "index_ft_transfers", "List decoded SIP-010 fungible-token transfers from Index. Reads are keyless.", {
     ...rangeFilters,
     ...orderFilter,
-    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 (contract::asset), e.g. SP…sbtc-token::sbtc-token")
+    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 (contract::asset), e.g. SP…sbtc-token::sbtc-token")
   }, async (params) => jsonResponse(await clientProvider().index.ftTransfers.list(params)));
   defineTool(server, "index_nft_transfers", "List decoded SIP-009 non-fungible-token transfers from Index. Reads are keyless.", {
     ...rangeFilters,
     ...orderFilter,
-    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 (contract::asset)")
+    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 (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: z6.enum(INDEX_EVENT_TYPES).describe("Required. Decoded event type to list."),
+    eventType: z7.enum(INDEX_EVENT_TYPES).describe("Required. Decoded event type to list."),
     ...rangeFilters,
     ...orderFilter,
-    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 where applicable"),
-    trait: z6.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId; contract-keyed event types only."),
-    txContext: z6.boolean().optional().describe("Join the submitting transaction into each event (tx_sender, tx_type, tx_status, tx_contract_id, tx_function_name). For print events it's the only source of the submitting sender.")
+    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 where applicable"),
+    trait: z7.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId; contract-keyed event types only."),
+    txContext: z7.boolean().optional().describe("Join the submitting transaction into each event (tx_sender, tx_type, tx_status, tx_contract_id, tx_function_name). For print events it's the only source of the submitting sender.")
   }, 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: z6.string().optional().describe("Filter by called function name"),
-    sender: z6.string().optional().describe("Filter by caller principal"),
-    trait: z6.string().optional().describe("Match contracts conforming to a trait/standard (e.g. sip-010). Mutually exclusive with contractId.")
+    functionName: z7.string().optional().describe("Filter by called function name"),
+    sender: z7.string().optional().describe("Filter by caller principal"),
+    trait: z7.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_blocks", "List decoded blocks from Index. Reads are keyless.", { ...heightFilters }, async (params) => jsonResponse(await clientProvider().index.blocks.list(params)));
   defineTool(server, "index_transactions", "List decoded transactions from Index. Filter by type, sender, or contract. Reads are keyless.", {
     ...rangeFilters,
-    type: z6.string().optional().describe("Filter by transaction type"),
-    sender: z6.string().optional().describe("Filter by sender principal")
+    type: z7.string().optional().describe("Filter by transaction type"),
+    sender: z7.string().optional().describe("Filter by sender principal")
   }, async (params) => jsonResponse(await clientProvider().index.transactions.list(params)));
   defineTool(server, "index_print_schema", "Empirical per-topic print payload schemas for a contract, inferred from sampled on-chain events: each topic's fields with observed Clarity types, decoded TS types, subgraph column types, and presence rates. Use before writing print_event subgraph handlers to learn what's on e.data. Anonymous read.", {
-    contractId: z6.string().describe("Contract id (SP….name) whose print events to profile")
+    contractId: z7.string().describe("Contract id (SP….name) whose print events to profile")
   }, async (params) => jsonResponse(await clientProvider().index.printSchema(params.contractId)));
   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, "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: z6.array(z6.object({
-      path: z6.string().describe("Public /v1 read path"),
-      params: z6.record(z6.string(), z6.string()).optional()
+    requests: z7.array(z7.object({
+      path: z7.string().describe("Public /v1 read path"),
+      params: z7.record(z7.string(), z7.string()).optional()
     })).min(1).max(10).describe("Read descriptors, executed concurrently")
   }, async (params) => jsonResponse(await clientProvider().batch(params.requests)));
 }
@@ -796,7 +818,7 @@ import {
   generateSubgraphCode,
   generateTokenSubgraphFromAbi
 } from "@secondlayer/scaffold";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 async function fetchAbi(clientProvider, contractId) {
   const contract = await clientProvider().contracts.get(contractId, {
     includeAbi: true
@@ -811,8 +833,8 @@ async function fetchAbi(clientProvider, contractId) {
 }
 function registerScaffoldTools(server, clientProvider = getClient) {
   defineTool(server, "subgraphs_scaffold", "Generate a subgraph from observed print events when available; ABI token transfers or public functions only when the contract has never printed. Review the TypeScript, run subgraphs_test until ok: true with written >= 1, read skipped, then subgraphs_deploy. dryRun is DDL only.", {
-    contractId: z7.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
-    subgraphName: z7.string().optional().describe("Override the subgraph name (defaults to contract name)")
+    contractId: z8.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
+    subgraphName: z8.string().optional().describe("Override the subgraph name (defaults to contract name)")
   }, async ({ contractId, subgraphName }) => {
     const printSchema = await clientProvider().index.printSchema(contractId);
     if (printSchema && printSchema.topics.length > 0) {
@@ -854,7 +876,7 @@ import { DECODED_EVENT_TYPES as DECODED_EVENT_TYPES2 } from "@secondlayer/shared
 import {
   runSubgraphTest
 } from "@secondlayer/subgraphs/testing";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function eventTypeFor(filter) {
   if (filter.type === "contract_deploy")
     return null;
@@ -880,13 +902,13 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     const { data } = await clientProvider().subgraphs.list();
     return jsonResponse(data.map(formatSubgraphSummary));
   });
-  defineTool(server, "subgraphs_status", "Get full details of a subgraph including schema, health (incl. health.emptyMapping when processed events wrote 0 rows), and table columns.", { name: z8.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_status", "Get full details of a subgraph including schema, health (incl. health.emptyMapping when processed events wrote 0 rows), and table columns.", { name: z9.string().describe("Subgraph name") }, async ({ name }) => {
     const detail = await clientProvider().subgraphs.status(name);
     return jsonResponse(detail);
   });
   defineTool(server, "subgraphs_spec", "Fetch a subgraph's self-describing spec — the tables, columns, filters, and read URLs a consumer needs, without guessing. `agent` (default) returns the compact JSON schema built for tool use, `openapi` the OpenAPI document for the subgraph's read routes, `markdown` human-readable docs. Read it before writing queries against an unfamiliar subgraph.", {
-    name: z8.string().describe("Subgraph name"),
-    format: z8.enum(["agent", "openapi", "markdown"]).optional().describe("agent = JSON schema for tool use (default), openapi = OpenAPI JSON, markdown = docs.md")
+    name: z9.string().describe("Subgraph name"),
+    format: z9.enum(["agent", "openapi", "markdown"]).optional().describe("agent = JSON schema for tool use (default), openapi = OpenAPI JSON, markdown = docs.md")
   }, async ({ name, format }) => {
     const client = clientProvider();
     if (format === "openapi")
@@ -896,15 +918,15 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     return jsonResponse(await client.subgraphs.schema(name));
   });
   defineTool(server, "subgraphs_query", 'Query rows from a subgraph table (max 200 rows), reading the open /v1 surface — { rows, next_cursor, tip } envelope, cursor-paginated (no offset). Filters support operators: "amount.gte": "1000", "sender.neq": "SP...", "name.like": "%token%". Available operators: eq, neq, gt, gte, lt, lte, like. Every page with rows returns next_cursor (null only when empty): pass it back as `cursor` to read the next page. To TAIL new rows (no streaming over MCP), poll with cursor = next_cursor ?? the cursor you sent. Fetch one row by id with {"_id": "<id>"}. The same rows are readable over HTTP at GET /v1/subgraphs/<name>/<table>; 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)"),
-    cursor: z8.string().optional().describe("Resume from a previous response's nextCursor"),
-    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: z9.string().describe("Subgraph name"),
+    table: z9.string().describe("Table name"),
+    filters: z9.record(z9.string(), z9.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
+    sort: z9.string().optional().describe("Column to sort by"),
+    order: z9.enum(["asc", "desc"]).optional().describe("Sort order"),
+    limit: z9.number().max(200).optional().describe("Max rows (default 50, max 200)"),
+    cursor: z9.string().optional().describe("Resume from a previous response's nextCursor"),
+    fields: z9.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
+    count: z9.boolean().optional().describe("If true, return row count instead of rows")
   }, async ({
     name,
     table,
@@ -934,15 +956,15 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     return jsonResponse({ ...capped, nextCursor: next_cursor, tip });
   });
   defineTool(server, "subgraphs_reindex", "Reindex a subgraph: drops and rebuilds the whole subgraph from its start block to chain tip. Takes no block range — use subgraphs_backfill to process a specific range. Returns an operationId — check subgraphs_status (health) or the REST operations endpoint to track progress to completion.", {
-    name: z8.string().describe("Subgraph name")
+    name: z9.string().describe("Subgraph name")
   }, async ({ name }) => {
     const result = await clientProvider().subgraphs.reindex(name);
     return jsonResponse(result);
   });
   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_status (health) or the REST operations endpoint 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)")
+    name: z9.string().describe("Subgraph name"),
+    fromBlock: z9.number().int().nonnegative().describe("Start block (inclusive)"),
+    toBlock: z9.number().int().nonnegative().describe("End block (inclusive)")
   }, async ({ name, fromBlock, toBlock }) => {
     const result = await clientProvider().subgraphs.backfill(name, {
       fromBlock,
@@ -950,15 +972,15 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     });
     return jsonResponse(result);
   });
-  defineTool(server, "subgraphs_stop", "Cancel an in-flight reindex or backfill operation for a subgraph. Returns the stop request status; check subgraphs_status (health) or the REST operations endpoint 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_status (health) or the REST operations endpoint to confirm it reaches a terminal state.", { name: z9.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await clientProvider().subgraphs.stop(name);
     return jsonResponse(result);
   });
   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: z9.string().describe("Subgraph name"),
+    limit: z9.number().int().positive().optional().describe("Max gaps to return"),
+    offset: z9.number().int().nonnegative().optional().describe("Pagination offset"),
+    resolved: z9.boolean().optional().describe("Filter by resolved state (omit for unresolved only)")
   }, async ({ name, limit, offset, resolved }) => {
     const result = await clientProvider().subgraphs.gaps(name, {
       limit,
@@ -968,20 +990,20 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     return jsonResponse(result);
   });
   defineTool(server, "subgraphs_operations", "Operation history for a subgraph (deploy/reindex/backfill/stop), newest first — status, block range, progress, and error. THIS IS THE VERIFY CALL: after subgraphs_deploy, subgraphs_reindex, subgraphs_backfill, or subgraphs_stop, poll it with the returned operationId until `status` is terminal (completed/failed/cancelled) before reporting success. Omit operationId for the recent history.", {
-    name: z8.string().describe("Subgraph name"),
-    operationId: z8.string().optional().describe("Fetch one operation by id (the operationId returned by reindex/backfill/stop); omit for recent history")
+    name: z9.string().describe("Subgraph name"),
+    operationId: z9.string().optional().describe("Fetch one operation by id (the operationId returned by reindex/backfill/stop); omit for recent history")
   }, async ({ name, operationId }) => {
     const client = clientProvider();
     return jsonResponse(operationId ? await client.subgraphs.getOperation(name, operationId) : await client.subgraphs.operations(name));
   });
-  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: z9.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await clientProvider().subgraphs.delete(name);
     return textResponse(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. dryRun validates schema/DDL only and does not run handlers — call subgraphs_test first and deploy only when it returns ok: true with written >= 1. 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"),
-    dryRun: z8.boolean().optional().describe("Validate schema/DDL only — does not run handlers. Use subgraphs_test to prove a mapping writes rows.")
+    code: z9.string().describe("TypeScript source code containing a defineSubgraph() call"),
+    startBlock: z9.number().int().nonnegative().optional().describe("Override the definition startBlock for this deploy"),
+    dryRun: z9.boolean().optional().describe("Validate schema/DDL only — does not run handlers. Use subgraphs_test to prove a mapping writes rows.")
   }, async ({ code, startBlock, dryRun }) => {
     const bundled = await bundleSubgraphCode(code);
     const result = await clientProvider().subgraphs.deploy({
@@ -997,10 +1019,10 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     return jsonResponse(result);
   });
   defineTool(server, "subgraphs_test", "Prove a subgraph mapping writes rows against Index data before deploy. Pass full defineSubgraph() source plus a height range. Returns ok/written/tables; EMPTY_MAPPING means events matched but 0 rows were written — read hint for observed event.data keys and do not invent fields. subgraphs_deploy dryRun is DDL only; do not deploy until ok: true with written >= 1.", {
-    code: z8.string().describe("TypeScript source containing a defineSubgraph() call"),
-    fromHeight: z8.number().int().nonnegative().describe("Start block height (inclusive)"),
-    toHeight: z8.number().int().nonnegative().optional().describe("End block height (inclusive); default fromHeight+100"),
-    limit: z8.number().int().positive().max(200).optional().describe("Max Index rows per source (default 50, max 200)")
+    code: z9.string().describe("TypeScript source containing a defineSubgraph() call"),
+    fromHeight: z9.number().int().nonnegative().describe("Start block height (inclusive)"),
+    toHeight: z9.number().int().nonnegative().optional().describe("End block height (inclusive); default fromHeight+100"),
+    limit: z9.number().int().positive().max(200).optional().describe("Max Index rows per source (default 50, max 200)")
   }, async ({ code, fromHeight, toHeight, limit }) => {
     const bundled = await bundleSubgraphCode(code);
     const def = await loadBundledDefinition(bundled.handlerCode);
@@ -1081,36 +1103,36 @@ function registerSubgraphTools(server, clientProvider = getClient) {
 
 // src/tools/webhooks.ts
 import { CHAIN_TRIGGER_TYPES } from "@secondlayer/shared";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function registerWebhookTools(server, clientProvider = getClient) {
   defineTool(server, "webhooks_list", "List all webhooks for the current account. Returns summary fields (no secrets).", {}, async () => {
     const { data } = await clientProvider().webhooks.list();
     return jsonResponse(data);
   });
-  defineTool(server, "webhooks_get", "Get full detail for a webhook (triggers, auth, retry config, circuit state).", { id: z9.string().describe("Webhook id") }, async ({ id }) => {
+  defineTool(server, "webhooks_get", "Get full detail for a webhook (triggers, auth, retry config, circuit state).", { id: z10.string().describe("Webhook id") }, async ({ id }) => {
     const detail = await clientProvider().webhooks.get(id);
     return jsonResponse(detail);
   });
   defineTool(server, "webhooks_create", "Create a webhook that fires on raw chain events (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"),
-    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: z10.string().describe("Human-readable name, unique per account"),
+    triggers: z10.array(z10.object({
+      type: z10.enum(CHAIN_TRIGGER_TYPES),
+      contractId: z10.string().optional(),
+      functionName: z10.string().optional(),
+      caller: z10.string().optional(),
+      sender: z10.string().optional(),
+      recipient: z10.string().optional(),
+      assetIdentifier: z10.string().optional(),
+      deployer: z10.string().optional(),
+      contractName: z10.string().optional(),
+      topic: z10.string().optional(),
+      lockedAddress: z10.string().optional(),
+      trait: z10.string().optional(),
+      minAmount: z10.union([z10.string(), z10.number()]).optional(),
+      maxAmount: z10.union([z10.string(), z10.number()]).optional()
     })).describe("Chain triggers. 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: z10.string().describe("Webhook URL"),
+    format: z10.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -1118,17 +1140,17 @@ function registerWebhookTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional().describe("Wire format (default standard-webhooks)"),
-    authConfig: z9.record(z9.string(), z9.unknown()).optional().describe('Receiver auth sent with each delivery, e.g. {"type": "bearer", "token": "..."}')
+    authConfig: z10.record(z10.string(), z10.unknown()).optional().describe('Receiver auth sent with each delivery, e.g. {"type": "bearer", "token": "..."}')
   }, async (input) => {
     const res = await clientProvider().webhooks.create(input);
     return jsonResponse(res);
   });
   defineTool(server, "webhooks_update", "Patch a webhook (name, url, authConfig, format, retry, timeout, concurrency).", {
-    id: z9.string(),
-    name: z9.string().optional().describe("Rename the webhook"),
-    url: z9.string().optional(),
-    authConfig: z9.record(z9.string(), z9.unknown()).optional().describe("Receiver auth sent with each delivery (bearer/etc.)"),
-    format: z9.enum([
+    id: z10.string(),
+    name: z10.string().optional().describe("Rename the webhook"),
+    url: z10.string().optional(),
+    authConfig: z10.record(z10.string(), z10.unknown()).optional().describe("Receiver auth sent with each delivery (bearer/etc.)"),
+    format: z10.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -1136,35 +1158,35 @@ function registerWebhookTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional(),
-    maxRetries: z9.number().int().min(0).optional(),
-    timeoutMs: z9.number().int().min(100).optional(),
-    concurrency: z9.number().int().min(1).optional()
+    maxRetries: z10.number().int().min(0).optional(),
+    timeoutMs: z10.number().int().min(100).optional(),
+    concurrency: z10.number().int().min(1).optional()
   }, async ({ id, ...patch }) => {
     const res = await clientProvider().webhooks.update(id, patch);
     return jsonResponse(res);
   });
-  defineTool(server, "webhooks_delete", "Delete a webhook. Pending outbox rows are cascade-deleted.", { id: z9.string() }, async ({ id }) => {
+  defineTool(server, "webhooks_delete", "Delete a webhook. Pending outbox rows are cascade-deleted.", { id: z10.string() }, async ({ id }) => {
     const res = await clientProvider().webhooks.delete(id);
     return jsonResponse(res);
   });
-  defineTool(server, "webhooks_test", "Send a one-off test webhook to a webhook's URL (built for its format, SSRF-guarded). Logged as a delivery row. Returns {ok, statusCode, error, durationMs, deliveryId}.", { id: z9.string().describe("Webhook id") }, async ({ id }) => {
+  defineTool(server, "webhooks_test", "Send a one-off test webhook to a webhook's URL (built for its format, SSRF-guarded). Logged as a delivery row. Returns {ok, statusCode, error, durationMs, deliveryId}.", { id: z10.string().describe("Webhook id") }, async ({ id }) => {
     const res = await clientProvider().webhooks.test(id);
     return jsonResponse(res);
   });
-  defineTool(server, "webhooks_pause", "Pause a webhook: stops delivery attempts and stops queueing new ones. Nothing is deleted — resume picks the webhook back up from the tip. Verify with webhooks_get (status).", { id: z9.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.pause(id)));
-  defineTool(server, "webhooks_resume", "Resume a paused webhook (also clears a tripped circuit breaker). Deliveries restart from the current tip — use webhooks_replay for the blocks missed while paused. Verify with webhooks_get (status).", { id: z9.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.resume(id)));
-  defineTool(server, "webhooks_rotate_secret", "Rotate a webhook's signing secret. Returns the NEW `signingSecret` ONCE — forward it to the user; deliveries signed with the old secret stop verifying as soon as this returns, so the receiver must be updated.", { id: z9.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.rotateSecret(id)));
-  defineTool(server, "webhooks_deliveries", "List recent delivery attempts for a webhook — status code, attempt count, error, duration, timestamps. THIS IS THE VERIFY CALL: after webhooks_create, webhooks_test, or webhooks_replay, read it to confirm the webhook actually landed (and to see the receiver's response when it didn't) instead of trusting the enqueue result.", { id: z9.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.deliveries(id)));
-  defineTool(server, "webhooks_dead", "List a webhook's dead-letter queue — deliveries that exhausted their retries, with the outbox id, payload, and last error. Diagnose the receiver first (webhooks_get for the URL/auth, webhooks_test for a live probe), then requeue rows with webhooks_requeue.", { id: z9.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.dead(id)));
+  defineTool(server, "webhooks_pause", "Pause a webhook: stops delivery attempts and stops queueing new ones. Nothing is deleted — resume picks the webhook back up from the tip. Verify with webhooks_get (status).", { id: z10.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.pause(id)));
+  defineTool(server, "webhooks_resume", "Resume a paused webhook (also clears a tripped circuit breaker). Deliveries restart from the current tip — use webhooks_replay for the blocks missed while paused. Verify with webhooks_get (status).", { id: z10.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.resume(id)));
+  defineTool(server, "webhooks_rotate_secret", "Rotate a webhook's signing secret. Returns the NEW `signingSecret` ONCE — forward it to the user; deliveries signed with the old secret stop verifying as soon as this returns, so the receiver must be updated.", { id: z10.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.rotateSecret(id)));
+  defineTool(server, "webhooks_deliveries", "List recent delivery attempts for a webhook — status code, attempt count, error, duration, timestamps. THIS IS THE VERIFY CALL: after webhooks_create, webhooks_test, or webhooks_replay, read it to confirm the webhook actually landed (and to see the receiver's response when it didn't) instead of trusting the enqueue result.", { id: z10.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.deliveries(id)));
+  defineTool(server, "webhooks_dead", "List a webhook's dead-letter queue — deliveries that exhausted their retries, with the outbox id, payload, and last error. Diagnose the receiver first (webhooks_get for the URL/auth, webhooks_test for a live probe), then requeue rows with webhooks_requeue.", { id: z10.string().describe("Webhook id") }, async ({ id }) => jsonResponse(await clientProvider().webhooks.dead(id)));
   defineTool(server, "webhooks_requeue", "Requeue ONE dead-lettered delivery for another attempt, by its outbox id from webhooks_dead. Fix the receiver first — a requeue against a still-broken endpoint just dies again. Verify with webhooks_deliveries.", {
-    id: z9.string().describe("Webhook id"),
-    outboxId: z9.string().describe("Outbox id of the dead delivery (from webhooks_dead)")
+    id: z10.string().describe("Webhook id"),
+    outboxId: z10.string().describe("Outbox id of the dead delivery (from webhooks_dead)")
   }, async ({ id, outboxId }) => jsonResponse(await clientProvider().webhooks.requeue(id, outboxId)));
   defineTool(server, "webhooks_replay", "Replay a block range for a webhook. 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: z10.string(),
+    fromBlock: z10.number().int().nonnegative(),
+    toBlock: z10.number().int().nonnegative(),
+    force: z10.string().optional().describe("Idempotency suffix to force a duplicate replay of the range")
   }, async ({ id, fromBlock, toBlock, force }) => {
     const res = await clientProvider().webhooks.replay(id, {
       fromBlock,
@@ -1362,5 +1384,5 @@ httpServer.listen(port, () => {
     console.error("Warning: SECONDLAYER_MCP_SECRET not set, authentication disabled");
 });
 
-//# debugId=B13309F0AE81C1B264756E2164756E21
+//# debugId=2D47CECF2113416564756E2164756E21
 //# sourceMappingURL=bin-http.js.map