@ebowwa/mcp-nm 2.0.0 → 2.0.2

package/dist/index.js

@@ -13965,32 +13965,100 @@ async function handleXxdExtract(args) {
   return { content: [{ type: "text", text: summary }] };
 }
 async function handleXxdFindPattern(args) {
-  const result = await runXxd(args.filePath, {
-    plainHex: true,
-    length: args.maxLength
-  });
-  const fileHex = result.output.replace(/\s/g, "").toLowerCase();
   let searchPattern;
   if (args.patternFormat === "text" || !args.patternFormat) {
     searchPattern = args.pattern.split("").map((c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join("");
   } else {
     searchPattern = args.pattern.replace(/\s/g, "").toLowerCase();
   }
+  const { stdout: sizeStr } = await execAsync(`stat -f%z "${args.filePath}" 2>/dev/null || stat -c%s "${args.filePath}"`);
+  const fileSize = parseInt(sizeStr.trim(), 10);
+  const maxInMemory = args.maxLength ?? 50 * 1024 * 1024;
   const matches = [];
-  let idx = 0;
-  while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
-    const byteOffset = Math.floor(idx / 2);
-    const contextStart = Math.max(0, idx - 20);
-    const contextEnd = Math.min(fileHex.length, idx + searchPattern.length + 20);
-    const contextHex = fileHex.slice(contextStart, contextEnd);
-    matches.push({
-      offset: byteOffset,
-      context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex
+  if (fileSize <= maxInMemory) {
+    const result = await runXxd(args.filePath, {
+      plainHex: true,
+      length: args.maxLength
     });
-    idx++;
+    const fileHex = result.output.replace(/\s/g, "").toLowerCase();
+    let idx = 0;
+    while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
+      const byteOffset = Math.floor(idx / 2);
+      const contextStart = Math.max(0, idx - 20);
+      const contextEnd = Math.min(fileHex.length, idx + searchPattern.length + 20);
+      const contextHex = fileHex.slice(contextStart, contextEnd);
+      matches.push({
+        offset: byteOffset,
+        context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex
+      });
+      idx++;
+      if (matches.length >= 1000)
+        break;
+    }
+  } else {
+    try {
+      const patternBytes = searchPattern.match(/.{2}/g) ?? [];
+      const escapedPattern = patternBytes.map((b) => `\\x${b}`).join("");
+      const { stdout: grepResult } = await execAsync(`grep -abo "${escapedPattern}" "${args.filePath}" 2>/dev/null | head -1000`, { maxBuffer: 10 * 1024 * 1024 });
+      const lines = grepResult.trim().split(`
+`).filter(Boolean);
+      for (const line of lines) {
+        const match = line.match(/^(\d+):/);
+        if (match) {
+          const offset = parseInt(match[1], 10);
+          try {
+            const contextOffset = Math.max(0, offset - 10);
+            const contextLen = searchPattern.length / 2 + 20;
+            const { stdout: contextHex } = await execAsync(`dd if="${args.filePath}" bs=1 skip=${contextOffset} count=${contextLen} 2>/dev/null | xxd -p | tr -d '\\n'`);
+            matches.push({
+              offset,
+              context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex
+            });
+          } catch {
+            matches.push({ offset, context: "(context unavailable)" });
+          }
+        }
+      }
+    } catch {
+      try {
+        const { stdout: stringsResult } = await execAsync(`strings -t x -n ${Math.floor(searchPattern.length / 2)} "${args.filePath}" | grep -i "${args.pattern}" | head -1000`, { maxBuffer: 10 * 1024 * 1024 });
+        const lines = stringsResult.trim().split(`
+`).filter(Boolean);
+        for (const line of lines) {
+          const match = line.match(/^\s*([0-9a-fA-F]+)\s+(.+)$/);
+          if (match) {
+            matches.push({
+              offset: parseInt(match[1], 16),
+              context: match[2].slice(0, 40)
+            });
+          }
+        }
+      } catch {
+        const chunkSize = 10 * 1024 * 1024;
+        for (let chunkStart = 0;chunkStart < fileSize; chunkStart += chunkSize) {
+          try {
+            const { stdout: chunkHex } = await execAsync(`dd if="${args.filePath}" bs=1 skip=${chunkStart} count=${chunkSize} 2>/dev/null | xxd -p | tr -d '\\n'`);
+            const hex = chunkHex.toLowerCase();
+            let idx = 0;
+            while ((idx = hex.indexOf(searchPattern, idx)) !== -1) {
+              matches.push({
+                offset: chunkStart + Math.floor(idx / 2),
+                context: hex.slice(Math.max(0, idx - 20), idx + searchPattern.length + 20).match(/.{1,2}/g)?.join(" ") || ""
+              });
+              idx++;
+              if (matches.length >= 1000)
+                break;
+            }
+            if (matches.length >= 1000)
+              break;
+          } catch {}
+        }
+      }
+    }
   }
   const summary = [
     `Pattern search in: ${args.filePath}`,
+    `File size: ${(fileSize / 1024 / 1024).toFixed(2)} MB`,
     `Pattern: ${args.pattern} (${args.patternFormat || "text"})`,
     `Hex pattern: ${searchPattern}`,
     `Matches found: ${matches.length}`,
@@ -14001,6 +14069,112 @@ async function handleXxdFindPattern(args) {
 `);
   return { content: [{ type: "text", text: summary }] };
 }
+async function handleConvertNumber(args) {
+  let num;
+  const value = args.value.trim().toLowerCase();
+  try {
+    switch (args.fromFormat) {
+      case "hex":
+        num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        break;
+      case "decimal":
+        num = BigInt(value);
+        break;
+      case "binary":
+        num = BigInt(value.startsWith("0b") ? value.slice(2) : value, 2);
+        break;
+      case "octal":
+        num = BigInt(value.startsWith("0o") ? value.slice(2) : value, 8);
+        break;
+      case "auto":
+      default:
+        if (value.startsWith("0x") || /^[0-9a-f]+$/i.test(value) && value.length > 4) {
+          num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        } else if (value.startsWith("0b")) {
+          num = BigInt(value.slice(2), 2);
+        } else if (value.startsWith("0o")) {
+          num = BigInt(value.slice(2), 8);
+        } else {
+          num = BigInt(value);
+        }
+        break;
+    }
+  } catch {
+    return {
+      content: [{ type: "text", text: `Error: Invalid number format "${args.value}"` }],
+      isError: true
+    };
+  }
+  let signedNum = num;
+  if (args.signed && args.byteSize) {
+    const bits = args.byteSize;
+    const maxUnsigned = (1n << BigInt(bits)) - 1n;
+    const signBit = 1n << BigInt(bits - 1);
+    if (num & signBit) {
+      signedNum = num - (1n << BigInt(bits));
+    }
+  }
+  const toFormat = args.toFormat ?? "all";
+  const results = [];
+  if (toFormat === "all" || toFormat === "decimal") {
+    results.push(`Decimal: ${num.toString()}`);
+    if (args.signed && args.byteSize && signedNum !== num) {
+      results.push(`Signed:  ${signedNum.toString()}`);
+    }
+  }
+  if (toFormat === "all" || toFormat === "hex") {
+    const hexStr = num.toString(16).toUpperCase();
+    const paddedHex = args.byteSize ? hexStr.padStart(args.byteSize / 4, "0") : hexStr;
+    results.push(`Hex:     0x${paddedHex}`);
+  }
+  if (toFormat === "all" || toFormat === "binary") {
+    const binStr = num.toString(2);
+    const paddedBin = args.byteSize ? binStr.padStart(args.byteSize, "0") : binStr;
+    const formattedBin = paddedBin.match(/.{1,8}/g)?.join(" ") ?? paddedBin;
+    results.push(`Binary:  0b${formattedBin}`);
+  }
+  if (toFormat === "all" || toFormat === "octal") {
+    results.push(`Octal:   0o${num.toString(8)}`);
+  }
+  if (toFormat === "all" || toFormat === "ascii") {
+    let asciiStr = "";
+    let tempNum = num;
+    while (tempNum > 0n) {
+      const charCode = Number(tempNum & 0xffn);
+      if (charCode >= 32 && charCode <= 126) {
+        asciiStr = String.fromCharCode(charCode) + asciiStr;
+      } else {
+        asciiStr = `\\x${charCode.toString(16).padStart(2, "0")}` + asciiStr;
+      }
+      tempNum = tempNum >> 8n;
+    }
+    results.push(`ASCII:   ${asciiStr || "(non-printable)"}`);
+  }
+  if (args.byteSize) {
+    results.push("");
+    results.push(`Size:    ${args.byteSize}-bit (${args.byteSize / 8} bytes)`);
+  }
+  if (toFormat === "all" && num > 0xffn) {
+    const bytes = [];
+    let tempNum = num;
+    while (tempNum > 0n) {
+      bytes.unshift(tempNum & 0xffn);
+      tempNum = tempNum >> 8n;
+    }
+    results.push("");
+    results.push("Bytes (big-endian):");
+    results.push(`  ${bytes.map((b, i) => `[${i}] 0x${b.toString(16).padStart(2, "0")} (${b})`).join(`
+  `)}`);
+  }
+  const summary = [
+    `Number Conversion: ${args.value}`,
+    `From: ${args.fromFormat}`,
+    "",
+    ...results
+  ].join(`
+`);
+  return { content: [{ type: "text", text: summary }] };
+}
 var SYMBOL_TYPE_DESCRIPTIONS = {
   A: "Global absolute symbol",
   B: "Global BSS (uninitialized data)",
@@ -15024,6 +15198,33 @@ var TOOLS = [
       required: ["filePath", "pattern"]
     }
   },
+  {
+    name: "bin_convert",
+    description: "Convert numbers between hex, decimal, binary, octal, and ASCII formats",
+    inputSchema: {
+      type: "object",
+      properties: {
+        value: { type: "string", description: "Number value to convert" },
+        fromFormat: {
+          type: "string",
+          enum: ["hex", "decimal", "binary", "octal", "auto"],
+          description: "Input format (default: auto-detect)"
+        },
+        toFormat: {
+          type: "string",
+          enum: ["all", "hex", "decimal", "binary", "octal", "ascii"],
+          description: "Output format (default: all)"
+        },
+        byteSize: {
+          type: "number",
+          enum: [8, 16, 32, 64],
+          description: "Byte size for padding (8/16/32/64-bit)"
+        },
+        signed: { type: "boolean", description: "Treat as signed integer" }
+      },
+      required: ["value"]
+    }
+  },
   {
     name: "bin_strings",
     description: "Extract readable strings (ASCII, Unicode) from a binary file",
@@ -15313,6 +15514,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleNopSled(args);
       case "bin_hex_editor":
         return await handleHexEditor(args);
+      case "bin_convert":
+        return await handleConvertNumber(args);
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/mcp-nm",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Comprehensive binary analysis MCP server - symbols (nm), hex dumps (xxd), strings, disassembly, security audit, entropy analysis, ELF/Mach-O inspection, and binary patching",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -537,17 +537,9 @@ async function handleXxdFindPattern(args: {
   patternFormat?: "hex" | "text";
   maxLength?: number;
 }) {
-  // Read file as hex
-  const result = await runXxd(args.filePath, {
-    plainHex: true,
-    length: args.maxLength,
-  });
-
-  const fileHex = result.output.replace(/\s/g, "").toLowerCase();
+  // Convert pattern to hex if text
   let searchPattern: string;
-
   if (args.patternFormat === "text" || !args.patternFormat) {
-    // Convert text to hex
     searchPattern = args.pattern
       .split("")
       .map((c) => c.charCodeAt(0).toString(16).padStart(2, "0"))
@@ -556,24 +548,119 @@ async function handleXxdFindPattern(args: {
     searchPattern = args.pattern.replace(/\s/g, "").toLowerCase();
   }
 
+  // Get file size to determine approach
+  const { stdout: sizeStr } = await execAsync(`stat -f%z "${args.filePath}" 2>/dev/null || stat -c%s "${args.filePath}"`);
+  const fileSize = parseInt(sizeStr.trim(), 10);
+  const maxInMemory = args.maxLength ?? 50 * 1024 * 1024; // 50MB default limit
+
   const matches: { offset: number; context: string }[] = [];
-  let idx = 0;
-  while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
-    const byteOffset = Math.floor(idx / 2);
-    // Get context (10 bytes before and after)
-    const contextStart = Math.max(0, idx - 20);
-    const contextEnd = Math.min(fileHex.length, idx + searchPattern.length + 20);
-    const contextHex = fileHex.slice(contextStart, contextEnd);
-
-    matches.push({
-      offset: byteOffset,
-      context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex,
+
+  if (fileSize <= maxInMemory) {
+    // Small file: use in-memory approach
+    const result = await runXxd(args.filePath, {
+      plainHex: true,
+      length: args.maxLength,
     });
-    idx++;
+
+    const fileHex = result.output.replace(/\s/g, "").toLowerCase();
+
+    let idx = 0;
+    while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
+      const byteOffset = Math.floor(idx / 2);
+      const contextStart = Math.max(0, idx - 20);
+      const contextEnd = Math.min(fileHex.length, idx + searchPattern.length + 20);
+      const contextHex = fileHex.slice(contextStart, contextEnd);
+
+      matches.push({
+        offset: byteOffset,
+        context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex,
+      });
+      idx++;
+      if (matches.length >= 1000) break; // Limit matches
+    }
+  } else {
+    // Large file: use streaming grep approach
+    // Use grep -abo for byte offset (Linux) or grep -b with binary mode (macOS)
+    try {
+      // Try using grep with binary pattern
+      // Convert hex pattern to escaped bytes for grep
+      const patternBytes = searchPattern.match(/.{2}/g) ?? [];
+      const escapedPattern = patternBytes.map(b => `\\x${b}`).join("");
+
+      // Use grep -b to get byte offsets, with binary search
+      const { stdout: grepResult } = await execAsync(
+        `grep -abo "${escapedPattern}" "${args.filePath}" 2>/dev/null | head -1000`,
+        { maxBuffer: 10 * 1024 * 1024 }
+      );
+
+      const lines = grepResult.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        const match = line.match(/^(\d+):/);
+        if (match) {
+          const offset = parseInt(match[1], 10);
+          // Get context using dd
+          try {
+            const contextOffset = Math.max(0, offset - 10);
+            const contextLen = searchPattern.length / 2 + 20;
+            const { stdout: contextHex } = await execAsync(
+              `dd if="${args.filePath}" bs=1 skip=${contextOffset} count=${contextLen} 2>/dev/null | xxd -p | tr -d '\\n'`
+            );
+            matches.push({
+              offset,
+              context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex,
+            });
+          } catch {
+            matches.push({ offset, context: "(context unavailable)" });
+          }
+        }
+      }
+    } catch {
+      // grep failed, try alternative: use strings with offset
+      try {
+        const { stdout: stringsResult } = await execAsync(
+          `strings -t x -n ${Math.floor(searchPattern.length / 2)} "${args.filePath}" | grep -i "${args.pattern}" | head -1000`,
+          { maxBuffer: 10 * 1024 * 1024 }
+        );
+        const lines = stringsResult.trim().split("\n").filter(Boolean);
+        for (const line of lines) {
+          const match = line.match(/^\s*([0-9a-fA-F]+)\s+(.+)$/);
+          if (match) {
+            matches.push({
+              offset: parseInt(match[1], 16),
+              context: match[2].slice(0, 40),
+            });
+          }
+        }
+      } catch {
+        // Last resort: chunked reading
+        const chunkSize = 10 * 1024 * 1024; // 10MB chunks
+        for (let chunkStart = 0; chunkStart < fileSize; chunkStart += chunkSize) {
+          try {
+            const { stdout: chunkHex } = await execAsync(
+              `dd if="${args.filePath}" bs=1 skip=${chunkStart} count=${chunkSize} 2>/dev/null | xxd -p | tr -d '\\n'`
+            );
+            const hex = chunkHex.toLowerCase();
+            let idx = 0;
+            while ((idx = hex.indexOf(searchPattern, idx)) !== -1) {
+              matches.push({
+                offset: chunkStart + Math.floor(idx / 2),
+                context: hex.slice(Math.max(0, idx - 20), idx + searchPattern.length + 20).match(/.{1,2}/g)?.join(" ") || "",
+              });
+              idx++;
+              if (matches.length >= 1000) break;
+            }
+            if (matches.length >= 1000) break;
+          } catch {
+            // Skip failed chunk
+          }
+        }
+      }
+    }
   }
 
   const summary = [
     `Pattern search in: ${args.filePath}`,
+    `File size: ${(fileSize / 1024 / 1024).toFixed(2)} MB`,
     `Pattern: ${args.pattern} (${args.patternFormat || "text"})`,
     `Hex pattern: ${searchPattern}`,
     `Matches found: ${matches.length}`,
@@ -587,6 +674,147 @@ async function handleXxdFindPattern(args: {
   return { content: [{ type: "text", text: summary }] };
 }
 
+// ============================================================================
+// Number Format Conversion Utility
+// ============================================================================
+
+async function handleConvertNumber(args: {
+  value: string;
+  fromFormat: "hex" | "decimal" | "binary" | "octal" | "auto";
+  toFormat?: "all" | "hex" | "decimal" | "binary" | "octal" | "ascii";
+  byteSize?: 8 | 16 | 32 | 64;
+  signed?: boolean;
+}) {
+  let num: bigint;
+
+  // Parse input value
+  const value = args.value.trim().toLowerCase();
+
+  try {
+    switch (args.fromFormat) {
+      case "hex":
+        num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        break;
+      case "decimal":
+        num = BigInt(value);
+        break;
+      case "binary":
+        num = BigInt(value.startsWith("0b") ? value.slice(2) : value, 2);
+        break;
+      case "octal":
+        num = BigInt(value.startsWith("0o") ? value.slice(2) : value, 8);
+        break;
+      case "auto":
+      default:
+        // Auto-detect format
+        if (value.startsWith("0x") || /^[0-9a-f]+$/i.test(value) && value.length > 4) {
+          num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        } else if (value.startsWith("0b")) {
+          num = BigInt(value.slice(2), 2);
+        } else if (value.startsWith("0o")) {
+          num = BigInt(value.slice(2), 8);
+        } else {
+          num = BigInt(value);
+        }
+        break;
+    }
+  } catch {
+    return {
+      content: [{ type: "text", text: `Error: Invalid number format "${args.value}"` }],
+      isError: true,
+    };
+  }
+
+  // Handle signed conversion if requested
+  let signedNum: bigint = num;
+  if (args.signed && args.byteSize) {
+    const bits = args.byteSize;
+    const maxUnsigned = (1n << BigInt(bits)) - 1n;
+    const signBit = 1n << BigInt(bits - 1);
+
+    if (num & signBit) {
+      signedNum = num - (1n << BigInt(bits));
+    }
+  }
+
+  // Format outputs
+  const toFormat = args.toFormat ?? "all";
+  const results: string[] = [];
+
+  if (toFormat === "all" || toFormat === "decimal") {
+    results.push(`Decimal: ${num.toString()}`);
+    if (args.signed && args.byteSize && signedNum !== num) {
+      results.push(`Signed:  ${signedNum.toString()}`);
+    }
+  }
+
+  if (toFormat === "all" || toFormat === "hex") {
+    const hexStr = num.toString(16).toUpperCase();
+    const paddedHex = args.byteSize
+      ? hexStr.padStart(args.byteSize / 4, "0")
+      : hexStr;
+    results.push(`Hex:     0x${paddedHex}`);
+  }
+
+  if (toFormat === "all" || toFormat === "binary") {
+    const binStr = num.toString(2);
+    const paddedBin = args.byteSize
+      ? binStr.padStart(args.byteSize, "0")
+      : binStr;
+    // Add spaces every 8 bits for readability
+    const formattedBin = paddedBin.match(/.{1,8}/g)?.join(" ") ?? paddedBin;
+    results.push(`Binary:  0b${formattedBin}`);
+  }
+
+  if (toFormat === "all" || toFormat === "octal") {
+    results.push(`Octal:   0o${num.toString(8)}`);
+  }
+
+  if (toFormat === "all" || toFormat === "ascii") {
+    // Try to convert to ASCII string
+    let asciiStr = "";
+    let tempNum = num;
+    while (tempNum > 0n) {
+      const charCode = Number(tempNum & 0xffn);
+      if (charCode >= 32 && charCode <= 126) {
+        asciiStr = String.fromCharCode(charCode) + asciiStr;
+      } else {
+        asciiStr = `\\x${charCode.toString(16).padStart(2, "0")}` + asciiStr;
+      }
+      tempNum = tempNum >> 8n;
+    }
+    results.push(`ASCII:   ${asciiStr || "(non-printable)"}`);
+  }
+
+  // Add byte size info
+  if (args.byteSize) {
+    results.push("");
+    results.push(`Size:    ${args.byteSize}-bit (${args.byteSize / 8} bytes)`);
+  }
+
+  // Add byte breakdown for multi-byte values
+  if (toFormat === "all" && num > 0xffn) {
+    const bytes: string[] = [];
+    let tempNum = num;
+    while (tempNum > 0n) {
+      bytes.unshift(tempNum & 0xffn);
+      tempNum = tempNum >> 8n;
+    }
+    results.push("");
+    results.push("Bytes (big-endian):");
+    results.push(`  ${bytes.map((b, i) => `[${i}] 0x${b.toString(16).padStart(2, "0")} (${b})`).join("\n  ")}`);
+  }
+
+  const summary = [
+    `Number Conversion: ${args.value}`,
+    `From: ${args.fromFormat}`,
+    "",
+    ...results,
+  ].join("\n");
+
+  return { content: [{ type: "text", text: summary }] };
+}
+
 // ============================================================================
 // Symbol type descriptions
 // ============================================================================
@@ -1899,6 +2127,34 @@ const TOOLS = [
       required: ["filePath", "pattern"],
     },
   },
+  // Number Format Conversion
+  {
+    name: "bin_convert",
+    description: "Convert numbers between hex, decimal, binary, octal, and ASCII formats",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        value: { type: "string", description: "Number value to convert" },
+        fromFormat: {
+          type: "string",
+          enum: ["hex", "decimal", "binary", "octal", "auto"],
+          description: "Input format (default: auto-detect)",
+        },
+        toFormat: {
+          type: "string",
+          enum: ["all", "hex", "decimal", "binary", "octal", "ascii"],
+          description: "Output format (default: all)",
+        },
+        byteSize: {
+          type: "number",
+          enum: [8, 16, 32, 64],
+          description: "Byte size for padding (8/16/32/64-bit)",
+        },
+        signed: { type: "boolean", description: "Treat as signed integer" },
+      },
+      required: ["value"],
+    },
+  },
   // Extended Binary Analysis Tools
   {
     name: "bin_strings",
@@ -2235,6 +2491,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleNopSled(args as { filePath: string; offset: number; count: number; createBackup?: boolean });
       case "bin_hex_editor":
         return await handleHexEditor(args as { filePath: string; offset: number; length: number; newHex?: string });
+      // Number conversion utility
+      case "bin_convert":
+        return await handleConvertNumber(args as {
+          value: string;
+          fromFormat: "hex" | "decimal" | "binary" | "octal" | "auto";
+          toFormat?: "all" | "hex" | "decimal" | "binary" | "octal" | "ascii";
+          byteSize?: 8 | 16 | 32 | 64;
+          signed?: boolean;
+        });
       default:
         throw new Error(`Unknown tool: ${name}`);
     }