@secondlayer/mcp 0.4.2 → 1.0.1

package/dist/bin.js

@@ -10,10 +10,80 @@ import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/resources.ts
-import { templates } from "@secondlayer/subgraphs/templates";
-
-// src/tools/streams.ts
-import { z } from "zod/v4";
+var FILTERS_REFERENCE = [
+  {
+    type: "stx_transfer",
+    fields: ["sender", "recipient", "minAmount", "maxAmount"]
+  },
+  { type: "stx_mint", fields: ["recipient", "minAmount"] },
+  { type: "stx_burn", fields: ["sender", "minAmount"] },
+  { type: "stx_lock", fields: ["lockedAddress", "minAmount"] },
+  {
+    type: "ft_transfer",
+    fields: [
+      "sender",
+      "recipient",
+      "assetIdentifier",
+      "minAmount",
+      "maxAmount"
+    ]
+  },
+  { type: "ft_mint", fields: ["recipient", "assetIdentifier", "minAmount"] },
+  { type: "ft_burn", fields: ["sender", "assetIdentifier", "minAmount"] },
+  {
+    type: "nft_transfer",
+    fields: ["sender", "recipient", "assetIdentifier", "tokenId"]
+  },
+  { 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: "int",
+    sqlType: "bigint",
+    description: "Signed integer (Clarity int)"
+  },
+  { type: "text", sqlType: "text", description: "UTF-8 string" },
+  {
+    type: "principal",
+    sqlType: "text",
+    description: "Stacks address (standard or contract)"
+  },
+  { type: "bool", sqlType: "boolean", description: "Boolean value" },
+  { type: "json", sqlType: "jsonb", description: "Arbitrary JSON data" },
+  {
+    options: ["nullable", "indexed", "search"],
+    description: "Column options: nullable allows NULL, indexed creates a B-tree index, search enables full-text search"
+  }
+];
+function registerResources(server) {
+  server.resource("filters", "secondlayer://filters", { description: "Event filter types and their available fields" }, async () => ({
+    contents: [
+      {
+        uri: "secondlayer://filters",
+        mimeType: "application/json",
+        text: JSON.stringify(FILTERS_REFERENCE, null, 2)
+      }
+    ]
+  }));
+  server.resource("column-types", "secondlayer://column-types", { description: "Subgraph column types, SQL mappings, and options" }, async () => ({
+    contents: [
+      {
+        uri: "secondlayer://column-types",
+        mimeType: "application/json",
+        text: JSON.stringify(COLUMN_TYPES, null, 2)
+      }
+    ]
+  }));
+}
 
 // src/lib/client.ts
 import { SecondLayer } from "@secondlayer/sdk";
@@ -24,7 +94,12 @@ function getClient() {
     if (!apiKey) {
       throw new Error("SECONDLAYER_API_KEY environment variable is required. " + "Get your key at https://app.secondlayer.tools/settings/api-keys");
     }
-    instance = new SecondLayer({ apiKey });
+    const baseUrl = process.env.SECONDLAYER_API_URL;
+    instance = new SecondLayer({
+      apiKey,
+      origin: "mcp",
+      ...baseUrl ? { baseUrl } : {}
+    });
   }
   return instance;
 }
@@ -53,16 +128,6 @@ async function apiRequest(method, path, body) {
 }
 
 // src/lib/format.ts
-function formatStreamSummary(s) {
-  return {
-    id: s.id,
-    name: s.name,
-    status: s.status,
-    endpointUrl: s.endpointUrl,
-    totalDeliveries: s.totalDeliveries,
-    failedDeliveries: s.failedDeliveries
-  };
-}
 function formatSubgraphSummary(s) {
   return {
     name: s.name,
@@ -71,16 +136,6 @@ function formatSubgraphSummary(s) {
     lastProcessedBlock: s.lastProcessedBlock
   };
 }
-function formatDeliverySummary(d) {
-  return {
-    id: d.id,
-    blockHeight: d.blockHeight,
-    status: d.status,
-    statusCode: d.statusCode,
-    attempts: d.attempts,
-    createdAt: d.createdAt
-  };
-}
 function withCap(items, cap) {
   return {
     items: items.slice(0, cap),
@@ -88,6 +143,12 @@ function withCap(items, cap) {
     total: items.length
   };
 }
+function jsonResponse(data, isError) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    ...isError && { isError: true }
+  };
+}
 
 // src/lib/tool.ts
 function defineTool(server, name, description, schema, handler) {
@@ -112,514 +173,17 @@ function defineTool(server, name, description, schema, handler) {
   server.tool(name, description, schema, wrappedHandler);
 }
 
-// src/tools/streams.ts
-var FilterSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("stx_transfer"),
-    sender: z.string().optional(),
-    recipient: z.string().optional(),
-    minAmount: z.number().optional(),
-    maxAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("stx_mint"),
-    recipient: z.string().optional(),
-    minAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("stx_burn"),
-    sender: z.string().optional(),
-    minAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("stx_lock"),
-    lockedAddress: z.string().optional(),
-    minAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("ft_transfer"),
-    sender: z.string().optional(),
-    recipient: z.string().optional(),
-    assetIdentifier: z.string().optional(),
-    minAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("ft_mint"),
-    recipient: z.string().optional(),
-    assetIdentifier: z.string().optional(),
-    minAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("ft_burn"),
-    sender: z.string().optional(),
-    assetIdentifier: z.string().optional(),
-    minAmount: z.number().optional()
-  }),
-  z.object({
-    type: z.literal("nft_transfer"),
-    sender: z.string().optional(),
-    recipient: z.string().optional(),
-    assetIdentifier: z.string().optional(),
-    tokenId: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("nft_mint"),
-    recipient: z.string().optional(),
-    assetIdentifier: z.string().optional(),
-    tokenId: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("nft_burn"),
-    sender: z.string().optional(),
-    assetIdentifier: z.string().optional(),
-    tokenId: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("contract_call"),
-    contractId: z.string().optional(),
-    functionName: z.string().optional(),
-    caller: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("contract_deploy"),
-    deployer: z.string().optional(),
-    contractName: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("print_event"),
-    contractId: z.string().optional(),
-    topic: z.string().optional(),
-    contains: z.string().optional()
-  })
-]);
-function registerStreamTools(server) {
-  defineTool(server, "streams_list", "List all webhook streams. Returns summary fields only.", {
-    status: z.enum(["active", "inactive", "paused", "failed"]).optional().describe("Filter by status")
-  }, async ({ status }) => {
-    const { streams } = await getClient().streams.list(status ? { status } : undefined);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(streams.map(formatStreamSummary), null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "streams_get", "Get full details of a stream by ID (accepts UUID prefix).", { id: z.string().describe("Stream UUID or prefix") }, async ({ id }) => {
-    const stream = await getClient().streams.get(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(stream, null, 2) }]
-    };
-  });
-  defineTool(server, "streams_create", "Create a new webhook stream with filters.", {
-    name: z.string().describe("Stream name"),
-    endpointUrl: z.string().describe("Webhook endpoint URL"),
-    filters: z.array(FilterSchema).min(1).describe("Event filters (at least one required)")
-  }, async ({ name, endpointUrl, filters }) => {
-    const result = await getClient().streams.create({
-      name,
-      endpointUrl,
-      filters
-    });
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ id: result.stream.id, signingSecret: result.signingSecret }, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "streams_update", "Update a stream's name, endpoint, or filters.", {
-    id: z.string().describe("Stream UUID or prefix"),
-    name: z.string().optional().describe("New name"),
-    endpointUrl: z.string().optional().describe("New endpoint URL"),
-    filters: z.array(FilterSchema).min(1).optional().describe("New filters")
-  }, async ({ id, name, endpointUrl, filters }) => {
-    const data = {};
-    if (name !== undefined)
-      data.name = name;
-    if (endpointUrl !== undefined)
-      data.endpointUrl = endpointUrl;
-    if (filters !== undefined)
-      data.filters = filters;
-    const stream = await getClient().streams.update(id, data);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(formatStreamSummary(stream), null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "streams_delete", "Delete a stream permanently.", { id: z.string().describe("Stream UUID or prefix") }, async ({ id }) => {
-    await getClient().streams.delete(id);
-    return { content: [{ type: "text", text: `Stream ${id} deleted.` }] };
-  });
-  defineTool(server, "streams_toggle", "Enable or disable a stream.", {
-    id: z.string().describe("Stream UUID or prefix"),
-    enabled: z.boolean().describe("true to enable, false to disable")
-  }, async ({ id, enabled }) => {
-    const stream = enabled ? await getClient().streams.enable(id) : await getClient().streams.disable(id);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ id: stream.id, status: stream.status }, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "streams_deliveries", "List recent deliveries for a stream (max 25).", {
-    id: z.string().describe("Stream UUID or prefix"),
-    limit: z.number().max(25).optional().describe("Max results (default 25)"),
-    status: z.string().optional().describe("Filter by delivery status")
-  }, async ({ id, limit, status }) => {
-    const { deliveries } = await getClient().streams.listDeliveries(id, {
-      limit: limit ?? 25,
-      status
-    });
-    const result = withCap(deliveries.map(formatDeliverySummary), 25);
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "streams_pause_all", "Pause all active streams. Without confirm: true, returns a preview of streams that would be paused.", {
-    confirm: z.boolean().optional().describe("Set to true to execute. Omit or false for preview only.")
-  }, async ({ confirm }) => {
-    if (!confirm) {
-      const { streams } = await getClient().streams.list({
-        status: "active"
-      });
-      const names = streams.map((s) => s.name);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ preview: true, count: names.length, streams: names }, null, 2)
-          }
-        ]
-      };
-    }
-    const result = await getClient().streams.pauseAll();
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            paused: result.paused,
-            streams: result.streams.map(formatStreamSummary)
-          }, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "streams_resume_all", "Resume all paused streams. Without confirm: true, returns a preview of streams that would be resumed.", {
-    confirm: z.boolean().optional().describe("Set to true to execute. Omit or false for preview only.")
-  }, async ({ confirm }) => {
-    if (!confirm) {
-      const { streams } = await getClient().streams.list({
-        status: "paused"
-      });
-      const names = streams.map((s) => s.name);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ preview: true, count: names.length, streams: names }, null, 2)
-          }
-        ]
-      };
-    }
-    const result = await getClient().streams.resumeAll();
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            resumed: result.resumed,
-            streams: result.streams.map(formatStreamSummary)
-          }, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "streams_replay", "Replay blocks through a stream, re-delivering events for a block range.", {
-    id: z.string().describe("Stream UUID or prefix"),
-    fromBlock: z.number().describe("Start block height (inclusive)"),
-    toBlock: z.number().describe("End block height (inclusive)")
-  }, async ({ id, fromBlock, toBlock }) => {
-    const result = await apiRequest("POST", `/api/streams/${id}/replay`, { fromBlock, toBlock });
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "streams_rotate_secret", "Rotate the signing secret for a stream. Returns the new secret.", { id: z.string().describe("Stream UUID or prefix") }, async ({ id }) => {
-    const result = await getClient().streams.rotateSecret(id);
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-}
-
-// src/resources.ts
-var FILTERS_REFERENCE = FilterSchema.options.map((opt) => ({
-  type: opt.shape.type.def.values[0],
-  fields: Object.keys(opt.shape).filter((k) => k !== "type")
-}));
-var COLUMN_TYPES = [
-  {
-    type: "uint",
-    sqlType: "bigint",
-    description: "Unsigned integer (Clarity uint)"
-  },
-  {
-    type: "int",
-    sqlType: "bigint",
-    description: "Signed integer (Clarity int)"
-  },
-  { type: "text", sqlType: "text", description: "UTF-8 string" },
-  {
-    type: "principal",
-    sqlType: "text",
-    description: "Stacks address (standard or contract)"
-  },
-  { type: "bool", sqlType: "boolean", description: "Boolean value" },
-  { type: "json", sqlType: "jsonb", description: "Arbitrary JSON data" },
-  {
-    options: ["nullable", "indexed", "search"],
-    description: "Column options: nullable allows NULL, indexed creates a B-tree index, search enables full-text search"
-  }
-];
-function registerResources(server) {
-  server.resource("filters", "secondlayer://filters", { description: "Stream filter types and their available fields" }, async () => ({
-    contents: [
-      {
-        uri: "secondlayer://filters",
-        mimeType: "application/json",
-        text: JSON.stringify(FILTERS_REFERENCE, null, 2)
-      }
-    ]
-  }));
-  server.resource("column-types", "secondlayer://column-types", { description: "Subgraph column types, SQL mappings, and options" }, async () => ({
-    contents: [
-      {
-        uri: "secondlayer://column-types",
-        mimeType: "application/json",
-        text: JSON.stringify(COLUMN_TYPES, null, 2)
-      }
-    ]
-  }));
-  server.resource("templates", "secondlayer://templates", {
-    description: "Available subgraph templates with descriptions and categories"
-  }, async () => ({
-    contents: [
-      {
-        uri: "secondlayer://templates",
-        mimeType: "application/json",
-        text: JSON.stringify(templates.map(({ id, name, description, category }) => ({
-          id,
-          name,
-          description,
-          category
-        })), null, 2)
-      }
-    ]
-  }));
-}
-
 // src/tools/account.ts
 function registerAccountTools(server) {
   defineTool(server, "account_whoami", "Show the authenticated account's email and plan.", {}, async () => {
     const result = await apiRequest("GET", "/api/accounts/me");
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
+    return jsonResponse(result);
   });
 }
 
 // src/tools/scaffold.ts
-import { z as z2 } from "zod/v4";
-
-// src/lib/scaffold-generate.ts
-function isAbiBuffer(t) {
-  return typeof t === "object" && t !== null && "buff" in t;
-}
-function isAbiStringAscii(t) {
-  return typeof t === "object" && t !== null && "string-ascii" in t;
-}
-function isAbiStringUtf8(t) {
-  return typeof t === "object" && t !== null && "string-utf8" in t;
-}
-function isAbiOptional(t) {
-  return typeof t === "object" && t !== null && "optional" in t;
-}
-function isAbiTuple(t) {
-  return typeof t === "object" && t !== null && "tuple" in t;
-}
-function isAbiList(t) {
-  return typeof t === "object" && t !== null && "list" in t;
-}
-function isAbiResponse(t) {
-  return typeof t === "object" && t !== null && "response" in t;
-}
-function mapType(abiType, nullable) {
-  if (typeof abiType === "string") {
-    switch (abiType) {
-      case "uint128":
-        return { type: "uint", nullable };
-      case "int128":
-        return { type: "int", nullable };
-      case "principal":
-      case "trait_reference":
-        return { type: "principal", nullable };
-      case "bool":
-        return { type: "boolean", nullable };
-      default: {
-        const s = abiType;
-        if (s.includes("uint"))
-          return { type: "uint", nullable };
-        if (s.includes("int"))
-          return { type: "int", nullable };
-        if (s.includes("string") || s.includes("ascii") || s.includes("utf8")) {
-          return { type: "text", nullable };
-        }
-        if (s.includes("buff"))
-          return { type: "text", nullable };
-        return { type: "jsonb", nullable };
-      }
-    }
-  }
-  if (isAbiBuffer(abiType))
-    return { type: "text", nullable };
-  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
-    return { type: "text", nullable };
-  }
-  if (isAbiOptional(abiType))
-    return mapType(abiType.optional, true);
-  if (isAbiList(abiType) || isAbiTuple(abiType))
-    return { type: "jsonb", nullable };
-  if (isAbiResponse(abiType)) {
-    return mapType(abiType.response.ok, nullable);
-  }
-  return { type: "jsonb", nullable };
-}
-function clarityTypeToSubgraphColumn(abiType) {
-  return mapType(abiType, false);
-}
-function toSnake(name) {
-  return name.replace(/-/g, "_");
-}
-function toCamel(name) {
-  return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-function buildColumns(args) {
-  if (args.length === 0)
-    return "        _placeholder: { type: 'text' }";
-  return args.map((arg) => {
-    const mapped = clarityTypeToSubgraphColumn(arg.type);
-    const nullable = mapped.nullable ? ", nullable: true" : "";
-    return `        ${toSnake(arg.name)}: { type: '${mapped.type}'${nullable} }`;
-  }).join(`,
-`);
-}
-function buildInsertCall(tableName, args) {
-  if (args.length === 0) {
-    return `      ctx.insert('${tableName}', {
-        sender: ctx.tx.sender,
-      });`;
-  }
-  const mappings = args.map((arg) => {
-    return `        ${toSnake(arg.name)}: event.${toCamel(arg.name)}`;
-  });
-  return `      ctx.insert('${tableName}', {
-${mappings.join(`,
-`)},
-      });`;
-}
-function generateSubgraphCode(contractId, functions, subgraphName, events) {
-  const contractParts = contractId.split(".");
-  const contractName = contractParts[contractParts.length - 1] ?? contractId;
-  const name = subgraphName ?? contractName;
-  const publicFunctions = functions.filter((f) => f.access === "public");
-  const hasEvents = events && events.length > 0;
-  if (publicFunctions.length === 0 && !hasEvents) {
-    return `// No public functions or events selected for ${contractId}`;
-  }
-  const tableDefs = [];
-  if (hasEvents) {
-    for (const ev of events) {
-      const tableName = toSnake(ev.name);
-      let columns;
-      if (isAbiTuple(ev.value)) {
-        columns = buildColumns(ev.value.tuple);
-      } else {
-        columns = `        value: { type: '${clarityTypeToSubgraphColumn(ev.value).type}' }`;
-      }
-      tableDefs.push(`    ${tableName}: {
-      columns: {
-${columns}
-      }
-    }`);
-    }
-  }
-  for (const fn of publicFunctions) {
-    const tableName = toSnake(fn.name);
-    const columns = buildColumns(fn.args);
-    tableDefs.push(`    ${tableName}: {
-      columns: {
-${columns}
-      }
-    }`);
-  }
-  const schemaBlock = tableDefs.join(`,
-`);
-  const sourceEntries = [`{ contract: '${contractId}' }`];
-  const handlerEntries = [];
-  if (hasEvents) {
-    for (const ev of events) {
-      const tableName = toSnake(ev.name);
-      let insertCall;
-      if (isAbiTuple(ev.value)) {
-        insertCall = buildInsertCall(tableName, ev.value.tuple);
-      } else {
-        insertCall = `      ctx.insert('${tableName}', {
-        value: event.value,
-      });`;
-      }
-      handlerEntries.push(`    '${contractId}::${ev.name}': async (event, ctx) => {
-${insertCall}
-    }`);
-    }
-  }
-  for (const fn of publicFunctions) {
-    const tableName = toSnake(fn.name);
-    const insertCall = buildInsertCall(tableName, fn.args);
-    handlerEntries.push(`    '${contractId}::${fn.name}': async (event, ctx) => {
-${insertCall}
-    }`);
-  }
-  const handlersBlock = handlerEntries.join(`,
-
-`);
-  return `import { defineSubgraph } from '@secondlayer/subgraphs';
-
-export default defineSubgraph({
-  name: '${name}',
-  sources: [${sourceEntries.join(", ")}],
-  schema: {
-${schemaBlock}
-  },
-  handlers: {
-${handlersBlock}
-  }
-});
-`;
-}
-
-// src/tools/scaffold.ts
+import { generateSubgraphCode } from "@secondlayer/scaffold";
+import { z } from "zod/v4";
 var API_BASE = process.env.SECONDLAYER_API_URL || "https://api.secondlayer.tools";
 async function fetchAbi(contractId) {
   const res = await fetch(`${API_BASE}/api/node/contracts/${contractId}/abi`, {
@@ -638,17 +202,17 @@ async function fetchAbi(contractId) {
 }
 function registerScaffoldTools(server) {
   defineTool(server, "scaffold_from_contract", "Generate a subgraph scaffold from a deployed Stacks contract. Fetches the ABI automatically.", {
-    contractId: z2.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
-    subgraphName: z2.string().optional().describe("Override the subgraph name (defaults to contract name)")
+    contractId: z.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
+    subgraphName: z.string().optional().describe("Override the subgraph name (defaults to contract name)")
   }, async ({ contractId, subgraphName }) => {
     const { functions, maps } = await fetchAbi(contractId);
     const code = generateSubgraphCode(contractId, functions, subgraphName, maps);
     return { content: [{ type: "text", text: code }] };
   });
   defineTool(server, "scaffold_from_abi", "Generate a subgraph scaffold from a provided ABI JSON. Use when you already have the ABI.", {
-    abi: z2.string().describe("ABI JSON string (the full contract ABI object)"),
-    contractId: z2.string().describe("Fully qualified contract ID"),
-    subgraphName: z2.string().optional().describe("Override the subgraph name")
+    abi: z.string().describe("ABI JSON string (the full contract ABI object)"),
+    contractId: z.string().describe("Fully qualified contract ID"),
+    subgraphName: z.string().optional().describe("Override the subgraph name")
   }, async ({ abi, contractId, subgraphName }) => {
     let parsed;
     try {
@@ -665,51 +229,8 @@ function registerScaffoldTools(server) {
 }
 
 // src/tools/subgraphs.ts
-import { z as z3 } from "zod/v4";
-
-// src/lib/bundle.ts
-import { validateSubgraphDefinition } from "@secondlayer/subgraphs/validate";
-import esbuild from "esbuild";
-async function bundleSubgraphCode(code) {
-  let result;
-  try {
-    result = await esbuild.build({
-      stdin: { contents: code, loader: "ts", resolveDir: process.cwd() },
-      bundle: true,
-      platform: "node",
-      format: "esm",
-      external: ["@secondlayer/subgraphs"],
-      write: false
-    });
-  } catch (err) {
-    throw new Error(`Bundle failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const handlerCode = new TextDecoder().decode(result.outputFiles[0].contents);
-  let mod;
-  try {
-    const dataUri = `data:text/javascript;base64,${Buffer.from(handlerCode).toString("base64")}`;
-    mod = await import(dataUri);
-  } catch (err) {
-    throw new Error(`Module evaluation failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const def = mod.default ?? mod;
-  let validated;
-  try {
-    validated = validateSubgraphDefinition(def);
-  } catch (err) {
-    throw new Error(`Validation failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  return {
-    name: validated.name,
-    version: validated.version,
-    description: validated.description,
-    sources: validated.sources,
-    schema: validated.schema,
-    handlerCode
-  };
-}
-
-// src/tools/subgraphs.ts
+import { bundleSubgraphCode } from "@secondlayer/bundler";
+import { z as z2 } from "zod/v4";
 function registerSubgraphTools(server) {
   defineTool(server, "subgraphs_list", "List all deployed subgraphs. Returns summary fields only.", {}, async () => {
     const { data } = await getClient().subgraphs.list();
@@ -722,22 +243,22 @@ function registerSubgraphTools(server) {
       ]
     };
   });
-  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z3.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z2.string().describe("Subgraph name") }, async ({ name }) => {
     const detail = await getClient().subgraphs.get(name);
     return {
       content: [{ type: "text", text: JSON.stringify(detail, null, 2) }]
     };
   });
   defineTool(server, "subgraphs_query", 'Query rows from a subgraph table (max 200 rows). Filters support operators: "amount.gte": "1000", "sender.neq": "SP...", "name.like": "%token%". Available operators: eq, neq, gt, gte, lt, lte, like.', {
-    name: z3.string().describe("Subgraph name"),
-    table: z3.string().describe("Table name"),
-    filters: z3.record(z3.string(), z3.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
-    sort: z3.string().optional().describe("Column to sort by"),
-    order: z3.enum(["asc", "desc"]).optional().describe("Sort order"),
-    limit: z3.number().max(200).optional().describe("Max rows (default 50, max 200)"),
-    offset: z3.number().optional().describe("Offset for pagination"),
-    fields: z3.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
-    count: z3.boolean().optional().describe("If true, return row count instead of rows")
+    name: z2.string().describe("Subgraph name"),
+    table: z2.string().describe("Table name"),
+    filters: z2.record(z2.string(), z2.string()).optional().describe('Column filters — plain values or with operators (e.g. {"amount.gte": "1000", "sender": "SP..."})'),
+    sort: z2.string().optional().describe("Column to sort by"),
+    order: z2.enum(["asc", "desc"]).optional().describe("Sort order"),
+    limit: z2.number().max(200).optional().describe("Max rows (default 50, max 200)"),
+    offset: z2.number().optional().describe("Offset for pagination"),
+    fields: z2.string().optional().describe('Comma-separated column list to return (e.g. "sender,amount")'),
+    count: z2.boolean().optional().describe("If true, return row count instead of rows")
   }, async ({
     name,
     table,
@@ -770,9 +291,9 @@ function registerSubgraphTools(server) {
     };
   });
   defineTool(server, "subgraphs_reindex", "Reindex a subgraph from a specific block range.", {
-    name: z3.string().describe("Subgraph name"),
-    fromBlock: z3.number().optional().describe("Start block (defaults to beginning)"),
-    toBlock: z3.number().optional().describe("End block (defaults to latest)")
+    name: z2.string().describe("Subgraph name"),
+    fromBlock: z2.number().optional().describe("Start block (defaults to beginning)"),
+    toBlock: z2.number().optional().describe("End block (defaults to latest)")
   }, async ({ name, fromBlock, toBlock }) => {
     const result = await getClient().subgraphs.reindex(name, {
       fromBlock,
@@ -782,13 +303,13 @@ function registerSubgraphTools(server) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z3.string().describe("Subgraph name") }, async ({ name }) => {
+  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z2.string().describe("Subgraph name") }, async ({ name }) => {
     const result = await getClient().subgraphs.delete(name);
     return { content: [{ type: "text", text: result.message }] };
   });
   defineTool(server, "subgraphs_deploy", "Deploy a subgraph from TypeScript code. Pass the full defineSubgraph() source — it will be bundled, validated, and deployed.", {
-    code: z3.string().describe("TypeScript source code containing a defineSubgraph() call"),
-    reindex: z3.boolean().optional().describe("Force reindex on breaking schema change (drops and rebuilds all data)")
+    code: z2.string().describe("TypeScript source code containing a defineSubgraph() call"),
+    reindex: z2.boolean().optional().describe("Force reindex on breaking schema change (drops and rebuilds all data)")
   }, async ({ code, reindex }) => {
     const bundled = await bundleSubgraphCode(code);
     const result = await getClient().subgraphs.deploy({
@@ -798,16 +319,29 @@ function registerSubgraphTools(server) {
       sources: bundled.sources,
       schema: bundled.schema,
       handlerCode: bundled.handlerCode,
+      sourceCode: code,
       reindex
     });
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
+  defineTool(server, "subgraphs_read_source", "Fetch the deployed TypeScript source of a subgraph (plus its stored version). Returns a readOnly payload for subgraphs deployed before source capture — in that case the caller should redeploy via CLI before editing.", { name: z2.string().describe("Subgraph name") }, async ({ name }) => {
+    const source = await getClient().subgraphs.getSource(name);
+    return {
+      content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
+    };
+  });
 }
 
 // src/tools/workflows.ts
-import { z as z4 } from "zod/v4";
+import { bundleWorkflowCode } from "@secondlayer/bundler";
+import {
+  generateWorkflowCode
+} from "@secondlayer/scaffold";
+import { VersionConflictError } from "@secondlayer/sdk";
+import { createPatch } from "diff";
+import { z as z3 } from "zod/v4";
 function registerWorkflowTools(server) {
   defineTool(server, "workflows_list", "List all workflows. Returns summary fields only.", {}, async () => {
     const { workflows } = await getClient().workflows.list();
@@ -820,15 +354,155 @@ function registerWorkflowTools(server) {
       ]
     };
   });
-  defineTool(server, "workflows_get", "Get full details of a workflow by name.", { name: z4.string().describe("Workflow name") }, async ({ name }) => {
+  defineTool(server, "workflows_get", "Get full details of a workflow by name.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
     const detail = await getClient().workflows.get(name);
     return {
       content: [{ type: "text", text: JSON.stringify(detail, null, 2) }]
     };
   });
+  defineTool(server, "workflows_get_definition", "Return the deployed TypeScript source of a workflow plus its stored version. Returns `sourceCode: null` + `readOnly: true` for workflows deployed before source capture.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
+    const source = await getClient().workflows.getSource(name);
+    return {
+      content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
+    };
+  });
+  defineTool(server, "workflows_propose_edit", "Validate a proposed edit WITHOUT deploying. Fetches the current stored source, bundles the proposed source, computes a unified diff, and returns everything for review. Use this when you want to show the user a diff before committing — pair it with workflows_deploy(expectedVersion=...) to persist.", {
+    name: z3.string().describe("Workflow name"),
+    proposedCode: z3.string().describe("New TypeScript source — must compile and validate."),
+    expectedVersion: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Version the proposer is editing from (for audit).")
+  }, async ({ name, proposedCode, expectedVersion }) => {
+    const current = await getClient().workflows.getSource(name);
+    if (current.sourceCode === null) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Workflow has no stored source. Redeploy via CLI first.",
+              readOnly: true,
+              version: current.version
+            }, null, 2)
+          }
+        ]
+      };
+    }
+    let bundleValid = false;
+    let validation;
+    let bundleSize = 0;
+    try {
+      const bundled = await bundleWorkflowCode(proposedCode);
+      bundleValid = true;
+      bundleSize = Buffer.byteLength(bundled.handlerCode, "utf8");
+      validation = {
+        name: bundled.name,
+        triggerType: bundled.trigger.type
+      };
+    } catch (err) {
+      validation = {
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    const diffText = createPatch(`${name}.ts`, current.sourceCode, proposedCode, `v${current.version}`, "proposed");
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            currentVersion: current.version,
+            expectedVersion,
+            currentSource: current.sourceCode,
+            proposedSource: proposedCode,
+            diffText,
+            bundleValid,
+            validation,
+            bundleSize
+          }, null, 2)
+        }
+      ]
+    };
+  });
+  defineTool(server, "workflows_tail_run", "Tail a workflow run via SSE and return a compacted log. Resolves as soon as the run completes, `limit` events are collected, or `timeoutMs` elapses (default 60s). MCP is not streaming-first — use this for short-lived follow-ups, not long tails.", {
+    name: z3.string().describe("Workflow name"),
+    runId: z3.string().describe("Run id"),
+    limit: z3.number().int().positive().max(200).optional().describe("Max step events to collect (default 50)"),
+    timeoutMs: z3.number().int().positive().max(5 * 60 * 1000).optional().describe("Hard timeout in ms (default 60000, max 300000)")
+  }, async ({ name, runId, limit, timeoutMs }) => {
+    const cap = limit ?? 50;
+    const deadline = timeoutMs ?? 60000;
+    const events = [];
+    let finalStatus = null;
+    let stoppedBy = "timeout";
+    const controller = new AbortController;
+    const timer = setTimeout(() => {
+      stoppedBy = "timeout";
+      controller.abort();
+    }, deadline);
+    try {
+      await getClient().workflows.streamRun(name, runId, (event) => {
+        if (event.type === "step") {
+          events.push(event.step);
+          if (events.length >= cap) {
+            stoppedBy = "limit";
+            controller.abort();
+          }
+        } else if (event.type === "done") {
+          finalStatus = event.done.status;
+          stoppedBy = "done";
+        }
+      }, controller.signal);
+    } catch (err) {
+      if (!(err instanceof Error) || err.name !== "AbortError") {
+        throw err;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            runId,
+            finalStatus,
+            stoppedBy,
+            eventCount: events.length,
+            events
+          }, null, 2)
+        }
+      ]
+    };
+  });
+  defineTool(server, "workflows_pause_all", "Pause ALL active workflows for the authenticated account. Irreversible only by calling pause/resume per workflow. Returns the list of affected workflows.", {}, async () => {
+    const result = await getClient().workflows.pauseAll();
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  });
+  defineTool(server, "workflows_cancel_run", "Cancel an in-flight workflow run. Marks the run as cancelled and removes any pending queue entry. No-ops if the run is already terminal.", { runId: z3.string().describe("Run id to cancel") }, async ({ runId }) => {
+    const result = await getClient().workflows.cancelRun(runId);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  });
+  defineTool(server, "workflows_rollback", "Roll a workflow back to a prior version. The restored handler is re-published as a NEW version (audit trail), so no history is lost. Pass toVersion to pick a specific bundle; omit to roll back to the immediate previous version on disk. Last 3 versions are retained.", {
+    name: z3.string().describe("Workflow name"),
+    toVersion: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Target version to restore. Must be one of the retained bundles on disk.")
+  }, async ({ name, toVersion }) => {
+    const result = await getClient().workflows.rollback(name, toVersion);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  });
+  defineTool(server, "workflows_delete", "Delete a workflow permanently.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
+    await getClient().workflows.delete(name);
+    return {
+      content: [{ type: "text", text: `Deleted workflow "${name}"` }]
+    };
+  });
   defineTool(server, "workflows_trigger", "Trigger a workflow run. Optionally pass input as a JSON string.", {
-    name: z4.string().describe("Workflow name"),
-    input: z4.string().optional().describe("Input as JSON string")
+    name: z3.string().describe("Workflow name"),
+    input: z3.string().optional().describe("Input as JSON string")
   }, async ({ name, input }) => {
     const parsed = input ? JSON.parse(input) : undefined;
     const result = await getClient().workflows.trigger(name, parsed);
@@ -836,89 +510,110 @@ function registerWorkflowTools(server) {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
     };
   });
-  defineTool(server, "workflows_pause", "Pause a running workflow.", { name: z4.string().describe("Workflow name") }, async ({ name }) => {
+  defineTool(server, "workflows_pause", "Pause a running workflow.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
     await getClient().workflows.pause(name);
     return {
       content: [{ type: "text", text: `Paused workflow "${name}"` }]
     };
   });
-  defineTool(server, "workflows_resume", "Resume a paused workflow.", { name: z4.string().describe("Workflow name") }, async ({ name }) => {
+  defineTool(server, "workflows_resume", "Resume a paused workflow.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
     await getClient().workflows.resume(name);
     return {
       content: [{ type: "text", text: `Resumed workflow "${name}"` }]
     };
   });
-  defineTool(server, "workflows_runs", "List runs for a workflow. Optionally filter by status and limit results.", {
-    name: z4.string().describe("Workflow name"),
-    status: z4.enum(["running", "completed", "failed", "cancelled"]).optional().describe("Filter by run status"),
-    limit: z4.number().optional().describe("Max runs to return (default 20)")
-  }, async ({ name, status, limit }) => {
-    const { runs } = await getClient().workflows.listRuns(name, {
-      status,
-      limit
+  defineTool(server, "workflows_scaffold", "Generate a compilable defineWorkflow() skeleton from a typed intent. Returns the TypeScript source; pass it to workflows_deploy to persist. Placeholders inside the source must be filled in before running a real workflow.", {
+    name: z3.string().regex(/^[a-z][a-z0-9-]*$/).describe("Workflow name (lowercase, hyphens)"),
+    trigger: z3.discriminatedUnion("type", [
+      z3.object({
+        type: z3.literal("event"),
+        filterType: z3.string().optional()
+      }),
+      z3.object({
+        type: z3.literal("schedule"),
+        cron: z3.string().min(1),
+        timezone: z3.string().optional()
+      }),
+      z3.object({ type: z3.literal("manual") })
+    ]).describe("Trigger shape"),
+    steps: z3.array(z3.enum(["run", "query", "ai", "deliver"])).describe("Ordered list of step kinds to include in the handler"),
+    deliveryTarget: z3.enum(["webhook", "slack", "email", "discord", "telegram"]).optional().describe("Delivery target used when steps includes `deliver`")
+  }, async ({ name, trigger, steps, deliveryTarget }) => {
+    const code = generateWorkflowCode({
+      name,
+      trigger,
+      steps,
+      deliveryTarget
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(runs, null, 2)
-        }
-      ]
-    };
-  });
-}
-
-// src/tools/templates.ts
-import {
-  getTemplateById,
-  getTemplatesByCategory,
-  templates as templates2
-} from "@secondlayer/subgraphs/templates";
-import { z as z5 } from "zod/v4";
-function registerTemplateTools(server) {
-  defineTool(server, "templates_list", "List available subgraph templates. Returns metadata only — use templates_get for full code.", {
-    category: z5.enum(["defi", "nft", "token", "infrastructure"]).optional().describe("Filter by category")
-  }, async ({ category }) => {
-    const list = category ? getTemplatesByCategory(category) : templates2;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(list.map((t) => ({
-            id: t.id,
-            name: t.name,
-            description: t.description,
-            category: t.category
-          })), null, 2)
-        }
-      ]
-    };
+    return { content: [{ type: "text", text: code }] };
   });
-  defineTool(server, "templates_get", "Get a template's full code and prompt by ID.", { id: z5.string().describe("Template ID (e.g. 'dex-swaps')") }, async ({ id }) => {
-    const template = getTemplateById(id);
-    if (!template) {
+  defineTool(server, "workflows_deploy", "Deploy a workflow from TypeScript source. Pass the full defineWorkflow() source — it will be bundled, validated, and deployed. Use expectedVersion for optimistic concurrency, or dryRun to validate without persisting.", {
+    code: z3.string().describe("TypeScript source code containing a defineWorkflow() call"),
+    expectedVersion: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Stored version the client expects (major.minor.patch). Server returns 409 on mismatch."),
+    dryRun: z3.boolean().optional().describe("If true, validate and bundle only — do not persist.")
+  }, async ({ code, expectedVersion, dryRun }) => {
+    let bundled;
+    try {
+      bundled = await bundleWorkflowCode(code);
+    } catch (err) {
       return {
+        isError: true,
         content: [
           {
             type: "text",
-            text: `Template "${id}" not found. Use templates_list to see available templates.`
+            text: err instanceof Error ? err.message : String(err)
           }
-        ],
-        isError: true
+        ]
       };
     }
+    const base = {
+      name: bundled.name,
+      trigger: bundled.trigger,
+      handlerCode: bundled.handlerCode,
+      sourceCode: bundled.sourceCode,
+      retries: bundled.retries,
+      timeout: bundled.timeout,
+      expectedVersion
+    };
+    try {
+      const result = dryRun ? await getClient().workflows.deploy({ ...base, dryRun: true }) : await getClient().workflows.deploy(base);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      if (err instanceof VersionConflictError) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: err.message,
+                code: "VERSION_CONFLICT",
+                currentVersion: err.currentVersion,
+                expectedVersion: err.expectedVersion
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      throw err;
+    }
+  });
+  defineTool(server, "workflows_runs", "List runs for a workflow. Optionally filter by status and limit results.", {
+    name: z3.string().describe("Workflow name"),
+    status: z3.enum(["running", "completed", "failed", "cancelled"]).optional().describe("Filter by run status"),
+    limit: z3.number().optional().describe("Max runs to return (default 20)")
+  }, async ({ name, status, limit }) => {
+    const { runs } = await getClient().workflows.listRuns(name, {
+      status,
+      limit
+    });
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({
-            id: template.id,
-            name: template.name,
-            description: template.description,
-            category: template.category,
-            code: template.code,
-            prompt: template.prompt
-          }, null, 2)
+          text: JSON.stringify(runs, null, 2)
         }
       ]
     };
@@ -933,9 +628,7 @@ function createServer() {
     name: "secondlayer",
     version: pkg.version
   });
-  registerTemplateTools(server);
   registerScaffoldTools(server);
-  registerStreamTools(server);
   registerSubgraphTools(server);
   registerAccountTools(server);
   registerWorkflowTools(server);
@@ -948,5 +641,5 @@ var server = createServer();
 var transport = new StdioServerTransport;
 await server.connect(transport);
 
-//# debugId=1A3C1AC5F1DDC78164756E2164756E21
+//# debugId=A6B30E8FDDD28B2464756E2164756E21
 //# sourceMappingURL=bin.js.map