@secondlayer/mcp 7.5.1 → 8.0.1

package/dist/index.js

@@ -241,7 +241,7 @@ async function buildContext(deps = { clientProvider: getClient }) {
     return field.error ? `unavailable: ${field.error.message}` : unavailable;
   };
   const snap = await deps.clientProvider().context().catch(() => null);
-  const instance2 = snap?.instance?.value ? snap.instance.value : orNull(snap?.instance);
+  const instance = snap?.instance?.value ? snap.instance.value : orNull(snap?.instance);
   return {
     authState: {
       apiKeySet: Boolean(readApiKey())
@@ -253,7 +253,7 @@ async function buildContext(deps = { clientProvider: getClient }) {
       subgraphs: snap?.subgraphs.value ? snap.subgraphs.value.map(formatSubgraphSummary) : orNull(snap?.subgraphs),
       webhooks: orNull(snap?.webhooks),
       activeOperations: orNull(snap?.activeOperations),
-      instance: instance2
+      instance
     },
     whatYouCanDo: buildCapabilities(),
     readAuthTiers: READ_AUTH_TIERS,
@@ -567,13 +567,13 @@ function registerScaffoldTools(server, clientProvider = getClient) {
   }, async ({ contractId, subgraphName }) => {
     const printSchema = await clientProvider().index.printSchema(contractId);
     if (printSchema && printSchema.topics.length > 0) {
-      const code2 = generatePrintSchemaSubgraph({
+      const code = generatePrintSchemaSubgraph({
         contractId,
         name: subgraphName,
         topics: printSchema.topics,
         sample: printSchema.sample
       });
-      return { content: [{ type: "text", text: code2 }] };
+      return { content: [{ type: "text", text: code }] };
     }
     const { functions, abi } = await fetchAbi(clientProvider, contractId);
     const token = generateTokenSubgraphFromAbi({
@@ -799,40 +799,9 @@ function registerSetupTools(server, exec = execSecondlayer) {
 }
 
 // src/tools/streams.ts
-import { STREAMS_EVENT_TYPES } from "@secondlayer/shared";
-import { z as z8 } from "zod";
-var filterValue = z8.union([z8.string(), z8.array(z8.string())]);
 function registerStreamsTools(server, clientProvider = getClient) {
   defineTool(server, "streams_tip", "Current canonical chain tip as Streams sees it: block height/hash, burn height, finalized_height, lag_seconds, and the oldest seekable height/cursor for this key's retention window. Call it before a cursor walk to know where the stream ends, and after an ingest to check lag.", {}, async () => jsonResponse(await clientProvider().streams.tip()));
-  defineTool(server, "streams_events", "List raw chain events from Streams — ONE page per call, newest filters applied server-side. Returns { events, next_cursor, tip, reorgs }. To follow the chain live, poll this tool with `cursor` set to the previous response's `next_cursor` (input is exclusive, so no duplicates); there is no open-stream tool because a tool call cannot hold a connection. ALWAYS narrow with types/contractId/sender/recipient — an unfiltered page is the full firehose.", {
-    cursor: z8.string().optional().describe("Resume strictly after this cursor (`<block_height>:<event_index>`, e.g. 951475:3) — pass a prior response's next_cursor"),
-    fromHeight: z8.number().int().nonnegative().optional().describe("Start block height (inclusive)"),
-    toHeight: z8.number().int().nonnegative().optional().describe("End block height (inclusive)"),
-    types: z8.array(z8.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to include"),
-    notTypes: z8.array(z8.enum(STREAMS_EVENT_TYPES)).optional().describe("Event types to exclude (applied after types)"),
-    contractId: filterValue.optional().describe("Contract id, or a list of contract ids to OR together"),
-    sender: filterValue.optional().describe("Sender principal, or a list to OR together"),
-    recipient: filterValue.optional().describe("Recipient principal, or a list to OR together"),
-    assetIdentifier: z8.string().optional().describe("Asset identifier (contract::asset), e.g. SP…sbtc-token::sbtc-token"),
-    limit: z8.number().int().min(1).max(1000).optional().describe("Page size, 1–1000 (default 100)")
-  }, async (params) => jsonResponse(await clientProvider().streams.events.list(params)));
-  defineTool(server, "streams_events_by_tx", "List every event emitted by a single transaction, in emission order. Use it to explain one transaction end to end after finding it in streams_events or the Index.", {
-    txId: z8.string().describe("Transaction id (0x-prefixed)")
-  }, async ({ txId }) => jsonResponse(await clientProvider().streams.events.byTxId(txId)));
-  defineTool(server, "streams_block_events", "List every event in one block, addressed by block height or block hash. Use it to audit a block a consumer flagged, or to diff what a reorg replaced.", {
-    heightOrHash: z8.union([z8.number().int().nonnegative(), z8.string()]).describe("Block height (number) or block hash (0x-prefixed string)")
-  }, async ({ heightOrHash }) => jsonResponse(await clientProvider().streams.blocks.events(heightOrHash)));
-  defineTool(server, "streams_canonical", "Get the canonical block at a height: hash, burn block hash, parent, and whether the height is still canonical. Use it to confirm a height you already consumed was not reorged away before you trust derived state.", {
-    height: z8.number().int().nonnegative().describe("Block height")
-  }, async ({ height }) => jsonResponse(await clientProvider().streams.canonical(height)));
-  defineTool(server, "streams_reorgs", "List reorgs detected since a point in time, newest last, with the new canonical tip for each. Returns { reorgs, next_since } — resume with next_since. Call it when a consumer's derived state disagrees with streams_canonical, or on a schedule to know which heights to reprocess.", {
-    since: z8.string().describe("Required. ISO 8601 timestamp, or a `next_since` resume token from a prior response"),
-    limit: z8.number().int().positive().optional().describe("Max reorgs to return")
-  }, async ({ since, limit }) => jsonResponse(await clientProvider().streams.reorgs.list({
-    since,
-    ...limit !== undefined ? { limit } : {}
-  })));
-  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). For live reads use streams_events (cursor-paginated) and streams_tip.", {}, 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). For live reads use REST GET /v1/streams/events; for tip/lag use streams_tip.", {}, async () => jsonResponse(await clientProvider().streams.dumps.list()));
 }
 
 // src/tools/subgraphs.ts
@@ -845,7 +814,7 @@ import { DECODED_EVENT_TYPES as DECODED_EVENT_TYPES2 } from "@secondlayer/shared
 import {
   runSubgraphTest
 } from "@secondlayer/subgraphs/testing";
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 function eventTypeFor(filter) {
   if (filter.type === "contract_deploy")
     return null;
@@ -871,13 +840,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: z9.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: z8.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: 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")
+    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")
   }, async ({ name, format }) => {
     const client = clientProvider();
     if (format === "openapi")
@@ -887,15 +856,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). 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 — when tailing with a `fields` list, include "_id" in it or the next poll filter cannot be formed. Fetch one row by id with {"_id": "<id>"}. The same rows are readable 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: 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)"),
-    offset: z9.number().optional().describe("Offset for pagination"),
-    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")
+    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")
   }, async ({
     name,
     table,
@@ -908,8 +877,8 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     count
   }) => {
     if (count) {
-      const result2 = await clientProvider().subgraphs.queryTableCount(name, table, { filters, sort, order });
-      return jsonResponse(result2);
+      const result = await clientProvider().subgraphs.queryTableCount(name, table, { filters, sort, order });
+      return jsonResponse(result);
     }
     const rows = await clientProvider().subgraphs.queryTable(name, table, {
       filters,
@@ -923,15 +892,15 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     return jsonResponse(result);
   });
   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: z9.string().describe("Subgraph name")
+    name: z8.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: z9.string().describe("Subgraph name"),
-    fromBlock: z9.number().int().nonnegative().describe("Start block (inclusive)"),
-    toBlock: z9.number().int().nonnegative().describe("End block (inclusive)")
+    name: z8.string().describe("Subgraph name"),
+    fromBlock: z8.number().int().nonnegative().describe("Start block (inclusive)"),
+    toBlock: z8.number().int().nonnegative().describe("End block (inclusive)")
   }, async ({ name, fromBlock, toBlock }) => {
     const result = await clientProvider().subgraphs.backfill(name, {
       fromBlock,
@@ -939,15 +908,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: z9.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: z8.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: 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)")
+    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)")
   }, async ({ name, limit, offset, resolved }) => {
     const result = await clientProvider().subgraphs.gaps(name, {
       limit,
@@ -957,25 +926,24 @@ 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: 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")
+    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")
   }, 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: z9.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z8.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: 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.")
+    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.")
   }, async ({ code, startBlock, dryRun }) => {
     const bundled = await bundleSubgraphCode(code);
     const result = await clientProvider().subgraphs.deploy({
       name: bundled.name,
-      version: bundled.version,
       description: bundled.description,
       sources: bundled.sources,
       schema: bundled.schema,
@@ -987,10 +955,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: 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)")
+    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)")
   }, async ({ code, fromHeight, toHeight, limit }) => {
     const bundled = await bundleSubgraphCode(code);
     const def = await loadBundledDefinition(bundled.handlerCode);
@@ -1014,7 +982,7 @@ function registerSubgraphTools(server, clientProvider = getClient) {
     for (const [name, filter] of Object.entries(sources)) {
       if (filter.type === "contract_call") {
         sourcesTested++;
-        const envelope2 = await index.contractCalls.list({
+        const envelope = await index.contractCalls.list({
           ...filter.contractId ? {
             contractId: Array.isArray(filter.contractId) ? filter.contractId : filter.contractId
           } : {},
@@ -1023,7 +991,7 @@ function registerSubgraphTools(server, clientProvider = getClient) {
           toHeight: to,
           limit: pageLimit
         });
-        events[name] = envelope2.contract_calls;
+        events[name] = envelope.contract_calls;
         continue;
       }
       const eventType = eventTypeFor(filter);
@@ -1071,38 +1039,38 @@ function registerSubgraphTools(server, clientProvider = getClient) {
 
 // src/tools/webhooks.ts
 import { CHAIN_TRIGGER_TYPES } from "@secondlayer/shared";
-import { z as z10 } from "zod";
+import { z as z9 } 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 (filter, auth, retry config, circuit state).", { id: z10.string().describe("Webhook id") }, async ({ id }) => {
+  defineTool(server, "webhooks_get", "Get full detail for a webhook (filter, auth, retry config, circuit state).", { id: z9.string().describe("Webhook id") }, async ({ id }) => {
     const detail = await clientProvider().webhooks.get(id);
     return jsonResponse(detail);
   });
   defineTool(server, "webhooks_create", "Create a webhook. Two kinds (mutually exclusive): a SUBGRAPH webhook fires on a subgraph table's rows (set subgraphName + tableName + optional filter); a CHAIN webhook 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: z10.string().describe("Human-readable name, unique per account"),
-    subgraphName: z10.string().optional().describe("Subgraph to subscribe to (subgraph webhook)"),
-    tableName: z10.string().optional().describe("Table within the subgraph (subgraph webhook)"),
-    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()
+    name: z9.string().describe("Human-readable name, unique per account"),
+    subgraphName: z9.string().optional().describe("Subgraph to subscribe to (subgraph webhook)"),
+    tableName: z9.string().optional().describe("Table within the subgraph (subgraph webhook)"),
+    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()
     })).optional().describe("Chain triggers (chain webhook) — 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: z10.string().describe("Webhook URL"),
-    format: z10.enum([
+    url: z9.string().describe("Webhook URL"),
+    format: z9.enum([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -1110,20 +1078,20 @@ function registerWebhookTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional().describe("Wire format (default standard-webhooks)"),
-    runtime: z10.enum(["inngest", "trigger", "cloudflare", "node"]).optional().describe("Receiver runtime label (display only)"),
-    filter: z10.record(z10.string(), z10.unknown()).optional().describe('Scalar filter DSL, e.g. {"amount": {"gte": 100}, "sender": "SP..."}'),
-    authConfig: z10.record(z10.string(), z10.unknown()).optional().describe('Receiver auth sent with each delivery, e.g. {"type": "bearer", "token": "..."}')
+    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": "..."}')
   }, async (input) => {
     const res = await clientProvider().webhooks.create(input);
     return jsonResponse(res);
   });
   defineTool(server, "webhooks_update", "Patch a webhook (name, url, filter, authConfig, format, runtime, retry, timeout, concurrency).", {
-    id: z10.string(),
-    name: z10.string().optional().describe("Rename the webhook"),
-    url: z10.string().optional(),
-    filter: z10.record(z10.string(), z10.unknown()).optional(),
-    authConfig: z10.record(z10.string(), z10.unknown()).optional().describe("Receiver auth sent with each delivery (bearer/etc.)"),
-    format: z10.enum([
+    id: z9.string(),
+    name: z9.string().optional().describe("Rename the webhook"),
+    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([
       "standard-webhooks",
       "inngest",
       "trigger",
@@ -1131,36 +1099,36 @@ function registerWebhookTools(server, clientProvider = getClient) {
       "cloudevents",
       "raw"
     ]).optional(),
-    runtime: z10.enum(["inngest", "trigger", "cloudflare", "node"]).nullable().optional(),
-    maxRetries: z10.number().int().min(0).optional(),
-    timeoutMs: z10.number().int().min(100).optional(),
-    concurrency: z10.number().int().min(1).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()
   }, 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: z10.string() }, async ({ id }) => {
+  defineTool(server, "webhooks_delete", "Delete a webhook. Pending outbox rows are cascade-deleted.", { id: z9.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: z10.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: z9.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: 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_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_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: z10.string().describe("Webhook id"),
-    outboxId: z10.string().describe("Outbox id of the dead delivery (from webhooks_dead)")
+    id: z9.string().describe("Webhook id"),
+    outboxId: z9.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: 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")
+    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")
   }, async ({ id, fromBlock, toBlock, force }) => {
     const res = await clientProvider().webhooks.replay(id, {
       fromBlock,
@@ -1200,5 +1168,5 @@ export {
   createServer
 };
 
-//# debugId=D0DFACF516B4301664756E2164756E21
+//# debugId=CEFB75160283ACFC64756E2164756E21
 //# sourceMappingURL=index.js.map