@secondlayer/mcp 3.3.1 → 3.5.0

package/dist/bin.js

@@ -9,6 +9,9 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
+// src/resources.ts
+import { TYPE_MAP } from "@secondlayer/subgraphs/schema";
+
 // src/lib/client.ts
 import { SecondLayer } from "@secondlayer/sdk";
 var instance = null;
@@ -111,45 +114,44 @@ var FILTERS_REFERENCE = [
   { type: "stx_lock", fields: ["lockedAddress", "minAmount"] },
   {
     type: "ft_transfer",
-    fields: [
-      "sender",
-      "recipient",
-      "assetIdentifier",
-      "minAmount",
-      "maxAmount"
-    ]
+    fields: ["sender", "recipient", "assetIdentifier", "minAmount", "trait"]
   },
-  { type: "ft_mint", fields: ["recipient", "assetIdentifier", "minAmount"] },
-  { type: "ft_burn", fields: ["sender", "assetIdentifier", "minAmount"] },
   {
-    type: "nft_transfer",
-    fields: ["sender", "recipient", "assetIdentifier", "tokenId"]
+    type: "ft_mint",
+    fields: ["recipient", "assetIdentifier", "minAmount", "trait"]
   },
-  { type: "nft_mint", fields: ["recipient", "assetIdentifier", "tokenId"] },
-  { type: "nft_burn", fields: ["sender", "assetIdentifier", "tokenId"] },
-  { type: "contract_call", fields: ["contract", "function"] },
-  { type: "contract_deploy", fields: ["contract"] },
-  { type: "print_event", fields: ["contract", "event", "contains"] }
-];
-var COLUMN_TYPES = [
   {
-    type: "uint",
-    sqlType: "bigint",
-    description: "Unsigned integer (Clarity uint)"
+    type: "ft_burn",
+    fields: ["sender", "assetIdentifier", "minAmount", "trait"]
   },
   {
-    type: "int",
-    sqlType: "bigint",
-    description: "Signed integer (Clarity int)"
+    type: "nft_transfer",
+    fields: ["sender", "recipient", "assetIdentifier", "trait"]
   },
-  { type: "text", sqlType: "text", description: "UTF-8 string" },
+  { type: "nft_mint", fields: ["recipient", "assetIdentifier", "trait"] },
+  { type: "nft_burn", fields: ["sender", "assetIdentifier", "trait"] },
   {
-    type: "principal",
-    sqlType: "text",
-    description: "Stacks address (standard or contract)"
+    type: "contract_call",
+    fields: ["contractId", "functionName", "caller", "trait", "abi"]
   },
-  { type: "bool", sqlType: "boolean", description: "Boolean value" },
-  { type: "json", sqlType: "jsonb", description: "Arbitrary JSON data" },
+  { type: "contract_deploy", fields: ["deployer", "contractName"] },
+  { type: "print_event", fields: ["contractId", "topic", "trait"] }
+];
+var COLUMN_TYPE_DESCRIPTIONS = {
+  text: "UTF-8 string",
+  uint: "Unsigned integer (Clarity uint) — NUMERIC for lossless 128-bit range",
+  int: "Signed integer (Clarity int) — NUMERIC for lossless 128-bit range",
+  principal: "Stacks address (standard or contract)",
+  boolean: "Boolean value",
+  timestamp: "Timestamp with time zone",
+  jsonb: "Arbitrary JSON data"
+};
+var COLUMN_TYPES = [
+  ...Object.keys(TYPE_MAP).map((type) => ({
+    type,
+    sqlType: TYPE_MAP[type],
+    description: COLUMN_TYPE_DESCRIPTIONS[type]
+  })),
   {
     options: ["nullable", "indexed", "search"],
     description: "Column options: nullable allows NULL, indexed creates a B-tree index, search enables full-text search"
@@ -322,6 +324,10 @@ function registerDatasetTools(server, clientProvider = getClient) {
 
 // src/tools/index.ts
 import { DECODED_EVENT_TYPES } from "@secondlayer/shared";
+import {
+  generateIndexSchema,
+  INDEX_CODEGEN_TABLES
+} from "@secondlayer/subgraphs";
 import { z as z4 } from "zod/v4";
 var INDEX_EVENT_TYPES = DECODED_EVENT_TYPES;
 var rangeFilters = {
@@ -397,6 +403,14 @@ function registerIndexTools(server, clientProvider = getClient) {
     return tx ? jsonResponse(tx) : notFound(`No pending tx for ${txId}`);
   });
   defineTool(server, "index_usage", "Your own Index consumption (decoded events today + this month) and tier limits. Requires a Build+ API key (anonymous reads can't report usage).", {}, async () => jsonResponse(await clientProvider().index.usage()));
+  defineTool(server, "index_codegen", `Generate a typed schema (Prisma, Kysely, Drizzle, or JSON-Schema) for the public Index domain tables so they can be mirrored into a BYO database with full types. Returns the schema as text. Tables: ${INDEX_CODEGEN_TABLES.join(", ")}.`, {
+    target: z4.enum(["prisma", "kysely", "drizzle", "json-schema"]).optional().describe("Output target (default kysely)"),
+    tables: z4.array(z4.string()).optional().describe("Subset of Index tables (default: all)"),
+    schemaName: z4.string().optional().describe("Postgres schema to qualify table names with")
+  }, async ({ target = "kysely", tables, schemaName }) => {
+    const out = generateIndexSchema(target, { tables, schemaName });
+    return { content: [{ type: "text", text: out }] };
+  });
 }
 
 // src/tools/scaffold.ts
@@ -475,6 +489,48 @@ function registerStreamsTools(server, clientProvider = getClient) {
     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))));
+  defineTool(server, "streams_consume", "Consume a bounded, reorg-aware run of Streams events from a cursor. Walks up to maxPages pages and returns the events, any reorgs observed, and a resume `cursor` to pass back as fromCursor next call — the agent-native consume/resume primitive. Streams requires an API key (SL_API_KEY).", {
+    fromCursor: z6.string().optional().describe("Resume cursor from a prior consume (omit to start at genesis)"),
+    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"),
+    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"),
+    batchSize: z6.number().optional().describe("Events per page (1–1000, default 100)"),
+    maxPages: z6.number().optional().describe("Max pages to walk this call (1–20, default 5)"),
+    finalizedOnly: z6.boolean().optional().describe("Only emit finalized events; skip reorg handling")
+  }, async (params) => withStreamsAuthHint(async () => {
+    const maxPages = Math.min(Math.max(params.maxPages ?? 5, 1), 20);
+    const batchSize = Math.min(Math.max(params.batchSize ?? 100, 1), 1000);
+    const events = [];
+    const reorgs = [];
+    const result = await clientProvider().streams.events.consume({
+      fromCursor: params.fromCursor ?? null,
+      mode: "bounded",
+      finalizedOnly: params.finalizedOnly,
+      types: params.types,
+      notTypes: params.notTypes,
+      contractId: params.contractId,
+      sender: params.sender,
+      recipient: params.recipient,
+      assetIdentifier: params.assetIdentifier,
+      batchSize,
+      maxPages,
+      onBatch: (batch) => {
+        events.push(...batch);
+      },
+      onReorg: (reorg) => {
+        reorgs.push(reorg);
+      }
+    });
+    return jsonResponse({
+      events,
+      reorgs,
+      cursor: result.cursor,
+      pages: result.pages
+    });
+  }));
   defineTool(server, "streams_event_by_txid", "List all Streams events emitted by a single transaction. Streams requires an API key (SL_API_KEY).", { txId: z6.string().describe("Transaction id (0x… hash)") }, async ({ txId }) => withStreamsAuthHint(async () => jsonResponse(await clientProvider().streams.events.byTxId(txId))));
   defineTool(server, "streams_block_events", "List all Streams events in a single block, by height or block hash. Streams requires an API key (SL_API_KEY).", {
     heightOrHash: z6.string().describe("Block height (digits) or block hash (0x… string)")
@@ -489,6 +545,11 @@ function registerStreamsTools(server, clientProvider = getClient) {
 
 // src/tools/subgraphs.ts
 import { bundleSubgraphCode } from "@secondlayer/bundler";
+import {
+  generateDrizzleSchema,
+  generateKyselySchema,
+  generatePrismaSchema
+} from "@secondlayer/subgraphs";
 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 () => {
@@ -565,6 +626,21 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
+  defineTool(server, "subgraphs_aggregate", `Compute scalar aggregates over a subgraph table's filtered rows. Supports count, countDistinct, and sum/min/max (numeric columns only — uint/int plus the system _block_height). Filters use the same grammar as subgraphs_query (e.g. {"amount.gte": "1000"}). sum/min/max come back as lossless strings; counts as numbers. With no aggregate requested, returns the row count.`, {
+    name: 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..."})'),
+    count: z7.boolean().optional().describe("Include COUNT(*) of matching rows"),
+    countDistinct: z7.array(z7.string()).optional().describe("Columns to count distinct values of"),
+    sum: z7.array(z7.string()).optional().describe("Numeric columns to sum (lossless string result)"),
+    min: z7.array(z7.string()).optional().describe("Numeric columns to take the minimum of"),
+    max: z7.array(z7.string()).optional().describe("Numeric columns to take the maximum of")
+  }, async ({ name, table, filters, count, countDistinct, sum, min, max }) => {
+    const result = await clientProvider().subgraphs.queryTableAggregate(name, table, { filters, count, countDistinct, sum, min, max });
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  });
   defineTool(server, "subgraphs_reindex", "Reindex a subgraph from a specific block range. Returns an operationId — poll subgraphs_operation to track progress to completion.", {
     name: z7.string().describe("Subgraph name"),
     fromBlock: z7.number().optional().describe("Start block (defaults to beginning)"),
@@ -616,6 +692,35 @@ function registerSubgraphTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
     };
   });
+  defineTool(server, "subgraphs_codegen", "Generate a typed ORM schema (Prisma, Drizzle, or Kysely) for a subgraph's tables so they can be queried from a BYO database. Pass either `code` (defineSubgraph source) or `name` (a deployed subgraph — its captured source is used). Returns the schema as text.", {
+    code: z7.string().optional().describe("defineSubgraph() source (mutually exclusive with name)"),
+    name: z7.string().optional().describe("Deployed subgraph name (mutually exclusive with code)"),
+    target: z7.enum(["prisma", "drizzle", "kysely"]).optional().describe("ORM target (default prisma)"),
+    schemaName: z7.string().optional().describe("Postgres schema name (defaults to subgraph_<name>)")
+  }, async ({ code, name, target = "prisma", schemaName }) => {
+    if (code && name || !code && !name) {
+      throw new Error("Provide exactly one of `code` or `name`.");
+    }
+    let source = code;
+    if (name) {
+      const stored = await clientProvider().subgraphs.getSource(name);
+      if (!stored.sourceCode) {
+        throw new Error(`Subgraph "${name}" has no captured source (deployed before source capture). Redeploy it, or pass its source as \`code\`.`);
+      }
+      source = stored.sourceCode;
+    }
+    const bundled = await bundleSubgraphCode(source);
+    const def = {
+      name: bundled.name,
+      version: bundled.version,
+      description: bundled.description,
+      sources: bundled.sources,
+      schema: bundled.schema,
+      handlers: {}
+    };
+    const out = target === "drizzle" ? generateDrizzleSchema(def, { schemaName }) : target === "kysely" ? generateKyselySchema(def, { schemaName }) : generatePrismaSchema(def, { schemaName });
+    return { content: [{ type: "text", text: out }] };
+  });
 }
 
 // src/tools/subscriptions.ts
@@ -717,6 +822,12 @@ function registerSubscriptionTools(server, clientProvider = getClient) {
       content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
     };
   });
+  defineTool(server, "subscriptions_test", "Send a one-off test webhook to a subscription's URL (built for its format, SSRF-guarded). Logged as a delivery row — check subscriptions_recent_deliveries. Returns {ok, statusCode, error, durationMs, deliveryId}.", { id: z8.string().describe("Subscription id") }, async ({ id }) => {
+    const res = await clientProvider().subscriptions.test(id);
+    return {
+      content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+    };
+  });
   defineTool(server, "subscriptions_replay", "Replay a block range for a subscription. Replays run at 10% of batch capacity — use sparingly.", {
     id: z8.string(),
     fromBlock: z8.number().int().nonnegative(),
@@ -778,5 +889,5 @@ var server = createServer();
 var transport = new StdioServerTransport;
 await server.connect(transport);
 
-//# debugId=6CC81A386AFC65E864756E2164756E21
+//# debugId=43FD93326BB3318D64756E2164756E21
 //# sourceMappingURL=bin.js.map