@atmaticai/agent-tools 1.0.0 → 1.0.2

package/dist/cli.js

@@ -0,0 +1,3933 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var settings = require('@atmaticai/agent-tools-core/settings');
+var agentToolsCore = require('@atmaticai/agent-tools-core');
+var express = require('express');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var express__default = /*#__PURE__*/_interopDefault(express);
+
+var jsonTools = [
+  {
+    name: "agent_tools_json_format",
+    description: "Format JSON with configurable indentation. Returns pretty-printed JSON.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The JSON string to format"
+        },
+        indent: {
+          type: "number",
+          enum: [2, 4],
+          description: "Number of spaces for indentation (default: 2)"
+        },
+        sortKeys: {
+          type: "boolean",
+          description: "Sort object keys alphabetically (default: false)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.json.format(args.input, {
+          indent: args.indent || 2,
+          sortKeys: args.sortKeys || false
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_json_validate",
+    description: "Validate JSON, optionally against a JSON Schema. Returns validation result with errors.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The JSON string to validate"
+        },
+        schema: {
+          type: "string",
+          description: "Optional JSON Schema to validate against"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.validate(args.input, args.schema);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_json_query",
+    description: "Query JSON using JSONPath or JMESPath. Returns the matched values.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The JSON string to query"
+        },
+        path: {
+          type: "string",
+          description: 'The query path (e.g., "$.store.book[*].author")'
+        },
+        dialect: {
+          type: "string",
+          enum: ["jsonpath", "jmespath"],
+          description: "Query dialect (default: jsonpath)"
+        }
+      },
+      required: ["input", "path"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.query(args.input, args.path, {
+        dialect: args.dialect || "jsonpath"
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_json_convert",
+    description: "Convert between JSON, JSON5, JSONC, YAML, and TOML formats.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The input string to convert"
+        },
+        from: {
+          type: "string",
+          enum: ["json", "json5", "jsonc", "yaml", "toml"],
+          description: "Source format"
+        },
+        to: {
+          type: "string",
+          enum: ["json", "json5", "jsonc", "yaml", "toml"],
+          description: "Target format"
+        }
+      },
+      required: ["input", "from", "to"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.convert(args.input, {
+        from: args.from,
+        to: args.to
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_json_diff",
+    description: "Compare two JSON documents and return the differences as JSON Patch operations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: {
+          type: "string",
+          description: "First JSON document"
+        },
+        b: {
+          type: "string",
+          description: "Second JSON document"
+        }
+      },
+      required: ["a", "b"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.diff(args.a, args.b);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_json_minify",
+    description: "Minify JSON by removing all whitespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The JSON string to minify"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.minify(args.input);
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_json_stats",
+    description: "Get statistics about a JSON document (key count, depth, types, size).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The JSON string to analyze"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.getStats(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_json_schema_validate",
+    description: "Validate JSON against a schema with detailed error analysis, coverage stats, and actionable fix suggestions. Returns a comprehensive summary suitable for LLM consumption.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The JSON string to validate"
+        },
+        schema: {
+          type: "string",
+          description: "The JSON Schema to validate against"
+        }
+      },
+      required: ["input", "schema"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.json.validateWithSummary(args.input, args.schema);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var csvTools = [
+  {
+    name: "agent_tools_csv_parse",
+    description: "Parse CSV data into structured JSON. Auto-detects delimiter if not specified.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The CSV string to parse"
+        },
+        delimiter: {
+          type: "string",
+          description: "Field delimiter (auto-detected if not specified)"
+        },
+        header: {
+          type: "boolean",
+          description: "First row contains headers (default: true)"
+        },
+        skipRows: {
+          type: "number",
+          description: "Number of rows to skip at the beginning"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.csv.parse(args.input, {
+        delimiter: args.delimiter,
+        header: args.header ?? true,
+        skipRows: args.skipRows
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_csv_to_json",
+    description: "Convert CSV to JSON array.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The CSV string to convert"
+        },
+        pretty: {
+          type: "boolean",
+          description: "Pretty-print output (default: true)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.csv.toJson(args.input, args.pretty ?? true);
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_csv_filter",
+    description: "Filter CSV rows based on column conditions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The CSV string to filter"
+        },
+        filters: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              column: { type: "string" },
+              operator: {
+                type: "string",
+                enum: [
+                  "eq",
+                  "neq",
+                  "gt",
+                  "gte",
+                  "lt",
+                  "lte",
+                  "contains",
+                  "startsWith",
+                  "endsWith",
+                  "matches",
+                  "isNull",
+                  "isNotNull"
+                ]
+              },
+              value: {}
+            },
+            required: ["column", "operator"]
+          },
+          description: "Array of filter conditions"
+        }
+      },
+      required: ["input", "filters"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.csv.filter(args.input, args.filters);
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_csv_stats",
+    description: "Get column statistics for CSV data (types, counts, min/max, top values).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The CSV string to analyze"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.csv.getStats(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_csv_transform",
+    description: "Transform CSV by selecting, renaming, or excluding columns.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The CSV string to transform"
+        },
+        select: {
+          type: "array",
+          items: { type: "string" },
+          description: "Columns to include"
+        },
+        exclude: {
+          type: "array",
+          items: { type: "string" },
+          description: "Columns to exclude"
+        },
+        rename: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Column rename mapping (oldName: newName)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.csv.transform(args.input, {
+        select: args.select,
+        exclude: args.exclude,
+        rename: args.rename
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_csv_export",
+    description: "Export CSV to different formats (csv, tsv, json, jsonl).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The CSV string to export"
+        },
+        format: {
+          type: "string",
+          enum: ["csv", "tsv", "json", "jsonl"],
+          description: "Target format"
+        },
+        headers: {
+          type: "boolean",
+          description: "Include headers in output (default: true)"
+        }
+      },
+      required: ["input", "format"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.csv.exportData(args.input, {
+        format: args.format,
+        headers: args.headers ?? true
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  }
+];
+var pdfTools = [
+  {
+    name: "agent_tools_pdf_merge",
+    description: "Merge multiple PDF files into one. Files should be base64 encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Array of base64-encoded PDF files"
+        },
+        pageRanges: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Optional page ranges for each file (e.g., ["1-3", "all", "5,7-10"])'
+        }
+      },
+      required: ["files"]
+    },
+    handler: async (args) => {
+      const buffers = args.files.map((f) => Buffer.from(f, "base64"));
+      const result = await agentToolsCore.pdf.merge(buffers, { pageRanges: args.pageRanges });
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_split",
+    description: "Split a PDF into multiple documents based on page ranges. Returns array of base64 PDFs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        ranges: {
+          type: "string",
+          description: 'Comma-separated page ranges (e.g., "1-3,4-6,7-10")'
+        }
+      },
+      required: ["file", "ranges"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const results = await agentToolsCore.pdf.split(buffer, { ranges: args.ranges });
+      const base64Results = results.map((r) => Buffer.from(r).toString("base64"));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(base64Results)
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_extract_pages",
+    description: "Extract specific pages from a PDF. Returns base64-encoded PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        pageRange: {
+          type: "string",
+          description: 'Pages to extract (e.g., "1,3,5-10")'
+        }
+      },
+      required: ["file", "pageRange"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.extractPages(buffer, args.pageRange);
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_extract_text",
+    description: "Extract text content from a PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        pages: {
+          type: "array",
+          items: { type: "number" },
+          description: "Optional specific pages to extract text from"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.extractText(buffer, { pages: args.pages });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_pdf_metadata",
+    description: "Get metadata from a PDF (title, author, page count, etc.).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.getInfo(buffer);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_set_metadata",
+    description: "Set metadata on a PDF. Returns modified base64-encoded PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        metadata: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            author: { type: "string" },
+            subject: { type: "string" },
+            keywords: { type: "array", items: { type: "string" } }
+          },
+          description: "Metadata to set"
+        }
+      },
+      required: ["file", "metadata"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.setMetadata(buffer, args.metadata);
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_rotate",
+    description: "Rotate pages in a PDF. Returns base64-encoded PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        degrees: {
+          type: "number",
+          enum: [90, 180, 270],
+          description: "Rotation angle"
+        },
+        pages: {
+          type: "array",
+          items: { type: "number" },
+          description: "Pages to rotate (all pages if not specified)"
+        }
+      },
+      required: ["file", "degrees"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.rotate(buffer, {
+        degrees: args.degrees,
+        pages: args.pages
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_compress",
+    description: "Compress a PDF to reduce file size. Returns base64-encoded PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        quality: {
+          type: "string",
+          enum: ["low", "medium", "high"],
+          description: "Compression quality (default: medium)"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.compress(buffer, {
+        quality: args.quality || "medium"
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_page_count",
+    description: "Get the number of pages in a PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const count = await agentToolsCore.pdf.getPageCount(buffer);
+      return {
+        content: [{ type: "text", text: String(count) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_to_template",
+    description: "Extract a reusable JSON template from a PDF, detecting {{placeholder}} fields. Returns template JSON.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        name: {
+          type: "string",
+          description: "Optional template name"
+        },
+        description: {
+          type: "string",
+          description: "Optional template description"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const template = await agentToolsCore.pdf.pdfToTemplate(buffer, {
+        name: args.name,
+        description: args.description
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(template, null, 2)
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_from_template",
+    description: "Generate a PDF from a template JSON and data JSON, replacing placeholders with values. Returns base64-encoded PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        template: {
+          type: "object",
+          description: "PDF template JSON object"
+        },
+        data: {
+          type: "object",
+          description: "Key-value pairs for placeholder replacement"
+        },
+        missingFieldBehavior: {
+          type: "string",
+          enum: ["leave_placeholder", "use_default", "empty_string"],
+          description: "How to handle missing fields (default: leave_placeholder)"
+        }
+      },
+      required: ["template"]
+    },
+    handler: async (args) => {
+      const result = await agentToolsCore.pdf.templateToPdf(args.template, args.data ?? {}, {
+        missingFieldBehavior: args.missingFieldBehavior
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_read_form",
+    description: "Read AcroForm fields from a fillable PDF. Returns field names, types, current values, and options.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.readFormFields(buffer);
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_pdf_fill_form",
+    description: "Fill AcroForm fields in a fillable PDF with provided data. Returns base64-encoded filled PDF.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded PDF file"
+        },
+        data: {
+          type: "object",
+          description: "Key-value pairs mapping field names to values (string for text/radio/dropdown, boolean for checkbox)"
+        },
+        flatten: {
+          type: "boolean",
+          description: "If true, flatten the form fields making them non-editable (default: false)"
+        }
+      },
+      required: ["file", "data"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.pdf.fillFormFields(buffer, args.data, {
+        flatten: args.flatten
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  }
+];
+var xmlTools = [
+  {
+    name: "agent_tools_xml_parse",
+    description: "Parse XML string into a JSON object representation. Supports attributes, nested elements, and text nodes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "XML string to parse" },
+        ignoreAttributes: {
+          type: "boolean",
+          description: "Whether to ignore XML attributes (default: false)"
+        },
+        trimValues: {
+          type: "boolean",
+          description: "Whether to trim text values (default: true)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.parse(args.input, {
+        ignoreAttributes: args.ignoreAttributes,
+        trimValues: args.trimValues
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_xml_format",
+    description: "Pretty-print XML with configurable indentation. Reformats XML to be human-readable.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "XML string to format" },
+        indent: {
+          type: "number",
+          description: "Number of spaces for indentation (default: 2)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.format(args.input, {
+        indent: args.indent || 2
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_xml_minify",
+    description: "Minify XML by removing unnecessary whitespace and formatting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "XML string to minify" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.minify(args.input);
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_xml_validate",
+    description: "Validate XML syntax. Returns whether the XML is well-formed with error details if invalid.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "XML string to validate" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.validate(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_xml_query",
+    description: 'Query XML using a simplified path expression (e.g., "root/items/item"). Returns matching nodes.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "XML string to query" },
+        path: {
+          type: "string",
+          description: 'Path expression (e.g., "catalog/book/title")'
+        }
+      },
+      required: ["input", "path"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.query(args.input, args.path);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_xml_convert",
+    description: "Convert between XML and JSON formats.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Input string to convert" },
+        from: {
+          type: "string",
+          enum: ["xml", "json"],
+          description: "Source format"
+        },
+        to: {
+          type: "string",
+          enum: ["xml", "json"],
+          description: "Target format"
+        }
+      },
+      required: ["input", "from", "to"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.convert(
+        args.input,
+        args.from,
+        args.to
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_xml_stats",
+    description: "Get statistics about an XML document: element count, attribute count, text nodes, depth, and size.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "XML string to analyze" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.xml.getStats(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var excelTools = [
+  {
+    name: "agent_tools_excel_parse",
+    description: "Parse an Excel file (XLSX) into JSON. Returns sheet info, headers, row data, and row count. Input file must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded Excel file"
+        },
+        sheet: {
+          type: "string",
+          description: "Sheet name or index to parse (default: first sheet)"
+        },
+        header: {
+          type: "boolean",
+          description: "Whether first row is headers (default: true)"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const sheetArg = args.sheet;
+      const sheet = sheetArg !== void 0 && !isNaN(Number(sheetArg)) ? Number(sheetArg) : sheetArg;
+      const result = await agentToolsCore.excel.parse(buffer, {
+        sheet,
+        header: args.header
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_excel_convert",
+    description: "Convert an Excel file to JSON, CSV, or TSV format. Input file must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded Excel file"
+        },
+        format: {
+          type: "string",
+          enum: ["json", "csv", "tsv"],
+          description: "Target format"
+        },
+        sheet: {
+          type: "string",
+          description: "Sheet name or index (default: first sheet)"
+        },
+        header: {
+          type: "boolean",
+          description: "Whether first row is headers (default: true)"
+        }
+      },
+      required: ["file", "format"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.excel.convert(buffer, args.format, {
+        sheet: args.sheet,
+        header: args.header
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_excel_stats",
+    description: "Get statistics about an Excel file: sheet count, total rows, columns, and sheet details. Input file must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded Excel file"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.excel.getStats(buffer);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_excel_sheets",
+    description: "List all sheets in an Excel file with their names, row counts, and column counts. Input file must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Base64-encoded Excel file"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.excel.getSheets(buffer);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_excel_create",
+    description: "Create an Excel file from JSON data. Returns the file as base64-encoded XLSX.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        data: {
+          type: "string",
+          description: "JSON string of an array of objects to convert to Excel"
+        },
+        sheetName: {
+          type: "string",
+          description: "Name for the worksheet (default: Sheet1)"
+        }
+      },
+      required: ["data"]
+    },
+    handler: async (args) => {
+      const data = JSON.parse(args.data);
+      const result = await agentToolsCore.excel.createExcel(data, args.sheetName);
+      return {
+        content: [
+          {
+            type: "text",
+            text: Buffer.from(result).toString("base64")
+          }
+        ]
+      };
+    }
+  }
+];
+var imageTools = [
+  {
+    name: "agent_tools_image_resize",
+    description: "Resize an image to specified dimensions. Supports fit modes: cover, contain, fill, inside, outside. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" },
+        width: { type: "number", description: "Target width in pixels" },
+        height: { type: "number", description: "Target height in pixels" },
+        fit: {
+          type: "string",
+          enum: ["cover", "contain", "fill", "inside", "outside"],
+          description: "How to fit the image (default: inside)"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.resize(buffer, {
+        width: args.width,
+        height: args.height,
+        fit: args.fit
+      });
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_image_crop",
+    description: "Crop an image to a specified rectangle. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" },
+        left: { type: "number", description: "Left offset in pixels" },
+        top: { type: "number", description: "Top offset in pixels" },
+        width: { type: "number", description: "Crop width in pixels" },
+        height: { type: "number", description: "Crop height in pixels" }
+      },
+      required: ["file", "left", "top", "width", "height"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.crop(buffer, {
+        left: args.left,
+        top: args.top,
+        width: args.width,
+        height: args.height
+      });
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_image_convert",
+    description: "Convert an image to a different format: png, jpeg, webp, gif, tiff, avif. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" },
+        format: {
+          type: "string",
+          enum: ["png", "jpeg", "webp", "gif", "tiff", "avif"],
+          description: "Target image format"
+        },
+        quality: {
+          type: "number",
+          description: "Quality for lossy formats 1-100 (default: 80)"
+        }
+      },
+      required: ["file", "format"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.convert(buffer, {
+        format: args.format,
+        quality: args.quality
+      });
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_image_compress",
+    description: "Compress an image to reduce file size. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" },
+        quality: {
+          type: "number",
+          description: "Compression quality 1-100 (default: 70)"
+        },
+        format: {
+          type: "string",
+          enum: ["png", "jpeg", "webp", "gif", "tiff", "avif"],
+          description: "Output format (default: jpeg)"
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.compress(buffer, {
+        quality: args.quality,
+        format: args.format
+      });
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_image_rotate",
+    description: "Rotate an image by a specified number of degrees. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" },
+        degrees: { type: "number", description: "Rotation angle in degrees" }
+      },
+      required: ["file", "degrees"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.rotate(buffer, {
+        degrees: args.degrees
+      });
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_image_metadata",
+    description: "Get metadata from an image: dimensions, format, channels, color space, DPI, alpha channel. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.getMetadata(buffer);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_image_grayscale",
+    description: "Convert an image to grayscale. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded image file" }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.image.grayscale(buffer);
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  }
+];
+var markdownTools = [
+  {
+    name: "agent_tools_markdown_convert",
+    description: "Convert between Markdown, HTML, and plain text formats. Supports GitHub Flavored Markdown.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Input text to convert" },
+        from: {
+          type: "string",
+          enum: ["markdown", "html", "text"],
+          description: "Source format"
+        },
+        to: {
+          type: "string",
+          enum: ["markdown", "html", "text"],
+          description: "Target format"
+        },
+        gfm: {
+          type: "boolean",
+          description: "Enable GitHub Flavored Markdown (default: true)"
+        }
+      },
+      required: ["input", "from", "to"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.markdown.convert(args.input, {
+        from: args.from,
+        to: args.to,
+        gfm: args.gfm
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_markdown_toc",
+    description: "Generate a table of contents from a Markdown document. Returns structured heading entries with levels and slugs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Markdown text" },
+        render: {
+          type: "boolean",
+          description: "Return rendered Markdown TOC instead of JSON (default: false)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const entries = agentToolsCore.markdown.generateToc(args.input);
+      if (args.render) {
+        const rendered = agentToolsCore.markdown.renderToc(entries);
+        return { content: [{ type: "text", text: rendered }] };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(entries, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_markdown_links",
+    description: "Extract all links from a Markdown document. Returns link text, URL, and line number for each link.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Markdown text" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.markdown.extractLinks(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_markdown_frontmatter",
+    description: "Extract YAML frontmatter from a Markdown document. Parses key-value pairs from the --- delimited header.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Markdown text with frontmatter" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.markdown.extractFrontmatter(args.input);
+      return {
+        content: [
+          {
+            type: "text",
+            text: result ? JSON.stringify(result, null, 2) : "No frontmatter found"
+          }
+        ]
+      };
+    }
+  },
+  {
+    name: "agent_tools_markdown_stats",
+    description: "Get statistics about a Markdown document: word count, headings, links, images, code blocks, lists, and more.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Markdown text to analyze" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.markdown.getStats(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var archiveTools = [
+  {
+    name: "agent_tools_archive_create",
+    description: "Create a ZIP archive from a list of files. Each file needs a path and base64-encoded content. Returns the archive as base64.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          description: "Array of files to add. Each item: { path: string, content: string (base64) }",
+          items: {
+            type: "object",
+            properties: {
+              path: { type: "string", description: "File path within archive" },
+              content: { type: "string", description: "Base64-encoded file content" }
+            },
+            required: ["path", "content"]
+          }
+        },
+        compressionLevel: {
+          type: "number",
+          description: "Compression level 0-9 (default: 6)"
+        }
+      },
+      required: ["files"]
+    },
+    handler: async (args) => {
+      const files = args.files.map((f) => ({
+        path: f.path,
+        content: Buffer.from(f.content, "base64")
+      }));
+      const result = await agentToolsCore.archive.create(files, {
+        compressionLevel: args.compressionLevel
+      });
+      return {
+        content: [{ type: "text", text: Buffer.from(result).toString("base64") }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_archive_extract",
+    description: "Extract files from a ZIP archive. Returns extracted files with paths and base64-encoded content. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded ZIP file" },
+        files: {
+          type: "array",
+          description: "Optional list of specific file paths to extract",
+          items: { type: "string" }
+        }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.archive.extract(buffer, {
+        files: args.files
+      });
+      const output = result.map((f) => ({
+        path: f.path,
+        content: f.content.toString("base64"),
+        size: f.content.length
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_archive_list",
+    description: "List contents of a ZIP archive without extracting. Returns file paths, sizes, and modification dates. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded ZIP file" }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.archive.list(buffer);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_archive_stats",
+    description: "Get statistics about a ZIP archive: file count, directory count, total size, compressed size. Input must be base64-encoded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "Base64-encoded ZIP file" }
+      },
+      required: ["file"]
+    },
+    handler: async (args) => {
+      const buffer = Buffer.from(args.file, "base64");
+      const result = await agentToolsCore.archive.getStats(buffer);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var regexTools = [
+  {
+    name: "agent_tools_regex_test",
+    description: "Test a regex pattern against input text. Returns all matches with positions and named groups.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Text to search" },
+        pattern: { type: "string", description: "Regular expression pattern" },
+        flags: {
+          type: "string",
+          description: 'Regex flags (e.g., "gi" for global case-insensitive)'
+        },
+        caseInsensitive: {
+          type: "boolean",
+          description: "Case-insensitive matching (default: false)"
+        },
+        multiline: {
+          type: "boolean",
+          description: "Multiline mode (default: false)"
+        }
+      },
+      required: ["input", "pattern"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.regex.test(args.input, args.pattern, {
+        flags: args.flags,
+        caseInsensitive: args.caseInsensitive,
+        multiline: args.multiline
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_regex_replace",
+    description: "Replace matches of a regex pattern in text. Supports backreferences ($1, $2) and named groups ($<name>).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Text to process" },
+        pattern: { type: "string", description: "Regular expression pattern" },
+        replacement: {
+          type: "string",
+          description: "Replacement string (supports $1, $<name> backreferences)"
+        },
+        flags: { type: "string", description: "Regex flags" },
+        global: {
+          type: "boolean",
+          description: "Replace all matches (default: true)"
+        }
+      },
+      required: ["input", "pattern", "replacement"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.regex.replace(
+        args.input,
+        args.pattern,
+        args.replacement,
+        {
+          flags: args.flags,
+          global: args.global
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_regex_extract",
+    description: "Extract all matches of a regex pattern from text. Returns matched strings and named groups.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Text to search" },
+        pattern: { type: "string", description: "Regular expression pattern" },
+        flags: { type: "string", description: "Regex flags" },
+        caseInsensitive: {
+          type: "boolean",
+          description: "Case-insensitive matching"
+        }
+      },
+      required: ["input", "pattern"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.regex.extract(args.input, args.pattern, {
+        flags: args.flags,
+        caseInsensitive: args.caseInsensitive
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_regex_validate",
+    description: "Validate a regex pattern for syntax correctness. Returns whether the pattern is valid with error details.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Regular expression pattern to validate" },
+        flags: { type: "string", description: "Optional regex flags to validate" }
+      },
+      required: ["pattern"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.regex.validate(args.pattern, args.flags);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var diffTools = [
+  {
+    name: "agent_tools_diff_compare",
+    description: "Compare two texts and return their differences. Supports line, word, and character-level diffing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: { type: "string", description: "First text (original)" },
+        b: { type: "string", description: "Second text (modified)" },
+        type: {
+          type: "string",
+          enum: ["line", "word", "char"],
+          description: "Diff granularity (default: line)"
+        },
+        ignoreWhitespace: {
+          type: "boolean",
+          description: "Ignore whitespace differences (default: false)"
+        }
+      },
+      required: ["a", "b"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.diff.compare(args.a, args.b, {
+        type: args.type,
+        ignoreWhitespace: args.ignoreWhitespace
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_diff_unified",
+    description: "Generate a unified diff (patch format) between two texts. Compatible with git diff output.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: { type: "string", description: "Original text" },
+        b: { type: "string", description: "Modified text" },
+        fromFile: {
+          type: "string",
+          description: 'Original file name (default: "a")'
+        },
+        toFile: {
+          type: "string",
+          description: 'Modified file name (default: "b")'
+        },
+        context: {
+          type: "number",
+          description: "Number of context lines (default: 3)"
+        }
+      },
+      required: ["a", "b"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.diff.unifiedDiff(args.a, args.b, {
+        fromFile: args.fromFile,
+        toFile: args.toFile,
+        context: args.context
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_diff_apply",
+    description: "Apply a unified diff patch to a text. Use to transform text using a previously generated patch.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Original text" },
+        patch: { type: "string", description: "Unified diff patch to apply" },
+        fuzz: {
+          type: "number",
+          description: "Fuzz factor for approximate matching (default: 0)"
+        }
+      },
+      required: ["input", "patch"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.diff.apply(args.input, args.patch, {
+          fuzz: args.fuzz
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${e.message}` }]
+        };
+      }
+    }
+  }
+];
+var sqlTools = [
+  {
+    name: "agent_tools_sql_format",
+    description: "Format SQL queries with configurable dialect, indentation, and keyword casing. Supports MySQL, PostgreSQL, SQLite, TransactSQL, BigQuery.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "SQL query to format" },
+        dialect: {
+          type: "string",
+          enum: ["mysql", "postgresql", "sqlite", "transactsql", "bigquery"],
+          description: "SQL dialect (default: postgresql)"
+        },
+        indent: {
+          type: "number",
+          description: "Indentation spaces (default: 2)"
+        },
+        uppercase: {
+          type: "boolean",
+          description: "Uppercase SQL keywords (default: true)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.sql.format(args.input, {
+        dialect: args.dialect,
+        indent: args.indent,
+        uppercase: args.uppercase
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_sql_minify",
+    description: "Minify SQL by removing comments and excess whitespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "SQL query to minify" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.sql.minify(args.input);
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_sql_parse",
+    description: "Parse a SQL query into an AST. Returns query type, referenced tables, and columns.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "SQL query to parse" },
+        dialect: {
+          type: "string",
+          enum: ["mysql", "postgresql", "sqlite", "transactsql", "bigquery"],
+          description: "SQL dialect (default: postgresql)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.sql.parse(args.input, args.dialect);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_sql_validate",
+    description: "Validate SQL syntax. Returns whether the query is syntactically correct with error details.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "SQL query to validate" },
+        dialect: {
+          type: "string",
+          enum: ["mysql", "postgresql", "sqlite", "transactsql", "bigquery"],
+          description: "SQL dialect (default: postgresql)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.sql.validate(args.input, args.dialect);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_sql_convert",
+    description: "Convert SQL between dialects (MySQL, PostgreSQL, SQLite, TransactSQL, BigQuery).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "SQL query to convert" },
+        from: {
+          type: "string",
+          enum: ["mysql", "postgresql", "sqlite", "transactsql", "bigquery"],
+          description: "Source dialect"
+        },
+        to: {
+          type: "string",
+          enum: ["mysql", "postgresql", "sqlite", "transactsql", "bigquery"],
+          description: "Target dialect"
+        }
+      },
+      required: ["input", "to"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.sql.convert(args.input, {
+        from: args.from,
+        to: args.to
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_sql_stats",
+    description: "Analyze SQL queries. Returns query count, types, referenced tables, joins, and subqueries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "SQL queries to analyze" },
+        dialect: {
+          type: "string",
+          enum: ["mysql", "postgresql", "sqlite", "transactsql", "bigquery"],
+          description: "SQL dialect (default: postgresql)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.sql.getStats(args.input, args.dialect);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var cryptoMcpTools = [
+  {
+    name: "agent_tools_crypto_hash",
+    description: "Hash a string using MD5, SHA-1, SHA-256, SHA-384, or SHA-512. Returns the hex digest.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "String to hash" },
+        algorithm: {
+          type: "string",
+          enum: ["md5", "sha1", "sha256", "sha384", "sha512"],
+          description: "Hash algorithm (default: sha256)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.crypto.hash(
+        args.input,
+        args.algorithm
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_crypto_hmac",
+    description: "Generate an HMAC (Hash-based Message Authentication Code) for a string with a secret key.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Message to authenticate" },
+        key: { type: "string", description: "Secret key for HMAC" },
+        algorithm: {
+          type: "string",
+          enum: ["md5", "sha1", "sha256", "sha384", "sha512"],
+          description: "Hash algorithm (default: sha256)"
+        }
+      },
+      required: ["input", "key"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.crypto.hmac(args.input, args.key, {
+        algorithm: args.algorithm
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_crypto_encode",
+    description: "Encode a string to Base64, Hex, URL-encoded, or HTML-encoded format.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "String to encode" },
+        format: {
+          type: "string",
+          enum: ["base64", "hex", "url", "html"],
+          description: "Encoding format"
+        }
+      },
+      required: ["input", "format"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.crypto.encode(
+        args.input,
+        args.format
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_crypto_decode",
+    description: "Decode a string from Base64, Hex, URL-encoded, or HTML-encoded format.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Encoded string to decode" },
+        format: {
+          type: "string",
+          enum: ["base64", "hex", "url", "html"],
+          description: "Encoding format to decode from"
+        }
+      },
+      required: ["input", "format"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.crypto.decode(
+        args.input,
+        args.format
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_crypto_jwt_decode",
+    description: "Decode a JWT token without verification. Returns header, payload, signature, and expiration status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "JWT token to decode" }
+      },
+      required: ["token"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.crypto.decodeJwt(args.token);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_crypto_uuid",
+    description: "Generate a new UUID v4.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    handler: async () => {
+      const result = agentToolsCore.crypto.generateUuid();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_crypto_checksum",
+    description: "Calculate the checksum of data. Useful for verifying file integrity. Accepts text or base64-encoded binary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "Text or base64-encoded data" },
+        algorithm: {
+          type: "string",
+          enum: ["md5", "sha1", "sha256", "sha384", "sha512"],
+          description: "Hash algorithm (default: sha256)"
+        },
+        base64: {
+          type: "boolean",
+          description: "Whether input is base64-encoded binary (default: false)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const data = args.base64 ? Buffer.from(args.input, "base64") : args.input;
+      const result = agentToolsCore.crypto.checksum(data, args.algorithm);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var datetimeTools = [
+  {
+    name: "agent_tools_datetime_parse",
+    description: "Parse a date string (ISO, Unix timestamp, RFC 2822, SQL) into a structured object with year, month, day, timezone, and more.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "Date string or Unix timestamp to parse"
+        },
+        timezone: {
+          type: "string",
+          description: "Timezone to interpret the date in (default: utc)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.parseDate(args.input, args.timezone);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_datetime_format",
+    description: "Format a date string using a Luxon format pattern. Supports timezone conversion.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "ISO date string to format" },
+        format: {
+          type: "string",
+          description: 'Luxon format pattern (e.g., "yyyy-MM-dd HH:mm:ss")'
+        },
+        timezone: {
+          type: "string",
+          description: "Target timezone (default: utc)"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.formatDate(args.input, {
+        format: args.format,
+        timezone: args.timezone
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_datetime_now",
+    description: "Get the current date and time with full details in a specified timezone.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        timezone: {
+          type: "string",
+          description: "Timezone (default: utc)"
+        }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.now(args.timezone);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_datetime_add",
+    description: "Add time to a date. Specify years, months, weeks, days, hours, minutes, and/or seconds to add.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "ISO date string" },
+        years: { type: "number", description: "Years to add" },
+        months: { type: "number", description: "Months to add" },
+        weeks: { type: "number", description: "Weeks to add" },
+        days: { type: "number", description: "Days to add" },
+        hours: { type: "number", description: "Hours to add" },
+        minutes: { type: "number", description: "Minutes to add" },
+        seconds: { type: "number", description: "Seconds to add" },
+        timezone: { type: "string", description: "Timezone" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.add(
+        args.input,
+        {
+          years: args.years,
+          months: args.months,
+          weeks: args.weeks,
+          days: args.days,
+          hours: args.hours,
+          minutes: args.minutes,
+          seconds: args.seconds
+        },
+        args.timezone
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_datetime_subtract",
+    description: "Subtract time from a date. Specify years, months, weeks, days, hours, minutes, and/or seconds to subtract.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "ISO date string" },
+        years: { type: "number", description: "Years to subtract" },
+        months: { type: "number", description: "Months to subtract" },
+        weeks: { type: "number", description: "Weeks to subtract" },
+        days: { type: "number", description: "Days to subtract" },
+        hours: { type: "number", description: "Hours to subtract" },
+        minutes: { type: "number", description: "Minutes to subtract" },
+        seconds: { type: "number", description: "Seconds to subtract" },
+        timezone: { type: "string", description: "Timezone" }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.subtract(
+        args.input,
+        {
+          years: args.years,
+          months: args.months,
+          weeks: args.weeks,
+          days: args.days,
+          hours: args.hours,
+          minutes: args.minutes,
+          seconds: args.seconds
+        },
+        args.timezone
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_datetime_diff",
+    description: "Calculate the difference between two dates. Returns years, months, days, hours, minutes, seconds and totals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: { type: "string", description: "First date (ISO string)" },
+        b: { type: "string", description: "Second date (ISO string)" }
+      },
+      required: ["a", "b"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.diff(args.a, args.b);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_datetime_timezone_convert",
+    description: "Convert a date from one timezone to another. Returns the converted date with offset information.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: { type: "string", description: "ISO date string" },
+        from: { type: "string", description: 'Source timezone (e.g., "America/New_York")' },
+        to: { type: "string", description: 'Target timezone (e.g., "Asia/Tokyo")' }
+      },
+      required: ["input", "from", "to"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.convertTimezone(
+        args.input,
+        args.from,
+        args.to
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_datetime_cron",
+    description: "Parse a cron expression. Returns a human-readable description and the next scheduled run times.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        expression: {
+          type: "string",
+          description: "Cron expression (5 fields: min hour dom month dow)"
+        },
+        count: {
+          type: "number",
+          description: "Number of next run times to return (default: 5)"
+        }
+      },
+      required: ["expression"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.datetime.parseCron(
+        args.expression,
+        args.count
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_datetime_timezones",
+    description: "List all available IANA timezone names.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    handler: async () => {
+      const result = agentToolsCore.datetime.listTimezones();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var textTools = [
+  {
+    name: "agent_tools_text_case",
+    description: "Convert text between case formats: camel, snake, kebab, pascal, title, sentence, upper, lower, constant.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The text to convert"
+        },
+        to: {
+          type: "string",
+          enum: ["camel", "snake", "kebab", "pascal", "title", "sentence", "upper", "lower", "constant"],
+          description: "Target case format"
+        }
+      },
+      required: ["input", "to"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.text.convertCase(args.input, args.to);
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_text_slugify",
+    description: "Convert text to a URL-friendly slug.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The text to slugify"
+        },
+        separator: {
+          type: "string",
+          description: 'Separator character (default: "-")'
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.text.slugify(args.input, args.separator);
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_text_stats",
+    description: "Get text statistics: character count, word count, sentence count, paragraph count, lines, and reading time.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The text to analyze"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.text.getTextStats(args.input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_text_truncate",
+    description: "Truncate text to a specified length with word or character boundary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The text to truncate"
+        },
+        length: {
+          type: "number",
+          description: "Maximum length"
+        },
+        boundary: {
+          type: "string",
+          enum: ["character", "word"],
+          description: 'Truncation boundary (default: "word")'
+        },
+        suffix: {
+          type: "string",
+          description: 'Suffix to append (default: "...")'
+        }
+      },
+      required: ["input", "length"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.text.truncate(args.input, {
+          length: args.length,
+          boundary: args.boundary,
+          suffix: args.suffix
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_text_lorem",
+    description: "Generate Lorem Ipsum placeholder text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        count: {
+          type: "number",
+          description: "Number of units to generate"
+        },
+        unit: {
+          type: "string",
+          enum: ["words", "sentences", "paragraphs"],
+          description: 'Unit type (default: "words")'
+        }
+      },
+      required: ["count"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.text.generateLorem(args.count, args.unit);
+      return { content: [{ type: "text", text: result }] };
+    }
+  },
+  {
+    name: "agent_tools_text_similarity",
+    description: "Compare two strings and return Levenshtein distance and similarity ratio (0-1).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: {
+          type: "string",
+          description: "First string"
+        },
+        b: {
+          type: "string",
+          description: "Second string"
+        }
+      },
+      required: ["a", "b"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.text.similarity(args.a, args.b);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  },
+  {
+    name: "agent_tools_text_template",
+    description: "Interpolate variables into a template string using {{key}} syntax. Reports missing keys.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        template: {
+          type: "string",
+          description: "Template string with {{key}} placeholders"
+        },
+        variables: {
+          type: "object",
+          description: "Key-value pairs for interpolation"
+        }
+      },
+      required: ["template", "variables"]
+    },
+    handler: async (args) => {
+      const result = agentToolsCore.text.interpolate(args.template, args.variables);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  }
+];
+var mathTools = [
+  {
+    name: "agent_tools_math_convert",
+    description: "Convert between units of measurement (length, weight, temperature, data).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        value: {
+          type: "number",
+          description: "The numeric value to convert"
+        },
+        from: {
+          type: "string",
+          description: 'Source unit (e.g., "km", "lb", "celsius", "gb")'
+        },
+        to: {
+          type: "string",
+          description: 'Target unit (e.g., "mi", "kg", "fahrenheit", "mb")'
+        },
+        category: {
+          type: "string",
+          enum: ["length", "weight", "temperature", "data"],
+          description: "Unit category"
+        }
+      },
+      required: ["value", "from", "to", "category"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.math.convertUnit(args.value, args.from, args.to, args.category);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_math_base",
+    description: "Convert numbers between binary, octal, decimal, and hexadecimal bases.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The number string to convert"
+        },
+        fromBase: {
+          type: "string",
+          enum: ["binary", "octal", "decimal", "hex"],
+          description: "Source number base"
+        }
+      },
+      required: ["input", "fromBase"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.math.convertBase(args.input, args.fromBase);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_math_statistics",
+    description: "Calculate statistics for a set of numbers: mean, median, mode, std deviation, percentiles.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        numbers: {
+          type: "array",
+          items: { type: "number" },
+          description: "Array of numbers to analyze"
+        }
+      },
+      required: ["numbers"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.math.calculateStats(args.numbers);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_math_format",
+    description: "Format a number with locale-aware formatting, currency, or percentage display.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        value: {
+          type: "number",
+          description: "The number to format"
+        },
+        locale: {
+          type: "string",
+          description: 'Locale string (default: "en-US")'
+        },
+        style: {
+          type: "string",
+          enum: ["decimal", "currency", "percent"],
+          description: 'Format style (default: "decimal")'
+        },
+        currency: {
+          type: "string",
+          description: 'Currency code when style is "currency" (e.g., "USD")'
+        },
+        minimumFractionDigits: {
+          type: "number",
+          description: "Minimum decimal places"
+        },
+        maximumFractionDigits: {
+          type: "number",
+          description: "Maximum decimal places"
+        }
+      },
+      required: ["value"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.math.formatNumber(args.value, {
+          locale: args.locale,
+          style: args.style,
+          currency: args.currency,
+          minimumFractionDigits: args.minimumFractionDigits,
+          maximumFractionDigits: args.maximumFractionDigits
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_math_percentage",
+    description: "Calculate percentages: what percentage a value is of a total, or percentage change between two values.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["of", "change"],
+          description: '"of" for value/total percentage, "change" for percentage change from/to'
+        },
+        value: {
+          type: "number",
+          description: 'The value (or "from" value for change)'
+        },
+        total: {
+          type: "number",
+          description: 'The total (or "to" value for change)'
+        }
+      },
+      required: ["action", "value", "total"]
+    },
+    handler: async (args) => {
+      try {
+        if (args.action === "change") {
+          const result2 = agentToolsCore.math.percentageChange(args.value, args.total);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result2, null, 2) }]
+          };
+        }
+        const result = agentToolsCore.math.percentage(args.value, args.total);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  }
+];
+var colorTools = [
+  {
+    name: "agent_tools_color_parse",
+    description: "Parse a color string (hex, rgb(), hsl()) and return all format representations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: 'Color string to parse (e.g., "#FF5733", "rgb(255,87,51)", "hsl(9,100%,60%)")'
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.color.parseColor(args.input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_color_convert",
+    description: "Convert a color to a specific format (hex, rgb, hsl).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "Color string to convert"
+        },
+        to: {
+          type: "string",
+          enum: ["hex", "rgb", "hsl"],
+          description: "Target color format"
+        }
+      },
+      required: ["input", "to"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.color.convertColor(args.input, args.to);
+        return { content: [{ type: "text", text: result }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_color_contrast",
+    description: "Calculate WCAG 2.1 contrast ratio between two colors with AA/AAA pass/fail results.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        color1: {
+          type: "string",
+          description: "First color"
+        },
+        color2: {
+          type: "string",
+          description: "Second color"
+        }
+      },
+      required: ["color1", "color2"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.color.contrastRatio(args.color1, args.color2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_color_palette",
+    description: "Generate a color palette from a base color: complementary, analogous, triadic, shades, or tints.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        base: {
+          type: "string",
+          description: "Base color string"
+        },
+        type: {
+          type: "string",
+          enum: ["complementary", "analogous", "triadic", "shades", "tints"],
+          description: "Palette generation strategy"
+        },
+        count: {
+          type: "number",
+          description: "Number of colors to generate (default: 5, ignored for complementary/triadic)"
+        }
+      },
+      required: ["base", "type"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.color.generatePalette(args.base, {
+          type: args.type,
+          count: args.count
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_color_blend",
+    description: "Blend two colors together at a given ratio.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        color1: {
+          type: "string",
+          description: "First color"
+        },
+        color2: {
+          type: "string",
+          description: "Second color"
+        },
+        ratio: {
+          type: "number",
+          description: "Blend ratio 0-1 (0 = all color1, 1 = all color2, default: 0.5)"
+        }
+      },
+      required: ["color1", "color2"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.color.blendColors(args.color1, args.color2, args.ratio);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_color_name",
+    description: "Find the nearest CSS named color for a given color input.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "Color string to identify"
+        }
+      },
+      required: ["input"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.color.colorName(args.input);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  }
+];
+var physicsTools = [
+  {
+    name: "agent_tools_physics_constants",
+    description: "Look up physical constants (speed of light, Planck, Boltzmann, etc.) or list all constants by category.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Constant key (c, G, h, hbar, k_B, N_A, R, e, epsilon_0, mu_0, m_e, m_p, sigma, g, atm, k_e)" },
+        category: { type: "string", description: "Filter by category: universal, electromagnetic, thermodynamics, quantum, atomic, mechanics, chemistry" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        if (args.key) {
+          const result2 = agentToolsCore.physics.getConstant(args.key);
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const result = agentToolsCore.physics.listConstants(args.category);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_kinematics",
+    description: "Solve kinematics equations of motion. Provide at least 3 known values to solve for the remaining.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        displacement: { type: "number", description: "Displacement in meters" },
+        initialVelocity: { type: "number", description: "Initial velocity in m/s" },
+        finalVelocity: { type: "number", description: "Final velocity in m/s" },
+        acceleration: { type: "number", description: "Acceleration in m/s\xB2" },
+        time: { type: "number", description: "Time in seconds" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.solveKinematics(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_projectile",
+    description: "Calculate projectile motion: range, max height, flight time, and velocity at peak.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        initialVelocity: { type: "number", description: "Initial velocity in m/s" },
+        angle: { type: "number", description: "Launch angle in degrees (0-90)" },
+        gravity: { type: "number", description: "Gravity in m/s\xB2 (default: 9.80665)" }
+      },
+      required: ["initialVelocity", "angle"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.projectileMotion(args.initialVelocity, args.angle, args.gravity);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_force",
+    description: "Calculate force using Newton's second law (F = ma).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mass: { type: "number", description: "Mass in kg" },
+        acceleration: { type: "number", description: "Acceleration in m/s\xB2" }
+      },
+      required: ["mass", "acceleration"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.calculateForce(args.mass, args.acceleration);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_energy",
+    description: "Calculate kinetic energy, potential energy, and total mechanical energy.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mass: { type: "number", description: "Mass in kg" },
+        velocity: { type: "number", description: "Velocity in m/s" },
+        height: { type: "number", description: "Height in meters (default: 0)" },
+        gravity: { type: "number", description: "Gravity in m/s\xB2 (default: 9.80665)" }
+      },
+      required: ["mass", "velocity"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.calculateEnergy(args.mass, args.velocity, args.height, args.gravity);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_gravity",
+    description: "Calculate gravitational force between two masses using Newton's law of universal gravitation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mass1: { type: "number", description: "First mass in kg" },
+        mass2: { type: "number", description: "Second mass in kg" },
+        distance: { type: "number", description: "Distance between centers in meters" }
+      },
+      required: ["mass1", "mass2", "distance"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.gravitationalForce(args.mass1, args.mass2, args.distance);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_orbital",
+    description: "Calculate orbital velocity and escape velocity for a body orbiting a central mass.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mass: { type: "number", description: "Central body mass in kg" },
+        radius: { type: "number", description: "Orbital radius in meters" }
+      },
+      required: ["mass", "radius"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.orbitalMechanics(args.mass, args.radius);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_ohms_law",
+    description: "Apply Ohm's law. Provide at least 2 of voltage, current, resistance to solve for the third and power.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        voltage: { type: "number", description: "Voltage in volts" },
+        current: { type: "number", description: "Current in amperes" },
+        resistance: { type: "number", description: "Resistance in ohms" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.ohmsLaw(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_resistors",
+    description: "Calculate total resistance for resistors in series or parallel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        values: { type: "array", items: { type: "number" }, description: "Resistor values in ohms" },
+        configuration: { type: "string", enum: ["series", "parallel"], description: "Circuit configuration" }
+      },
+      required: ["values", "configuration"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.resistors(args.values, args.configuration);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_wave",
+    description: "Solve wave equation (v = f\u03BB). Provide at least 2 of frequency, wavelength, speed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        frequency: { type: "number", description: "Frequency in Hz" },
+        wavelength: { type: "number", description: "Wavelength in meters" },
+        speed: { type: "number", description: "Wave speed in m/s" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.waveEquation(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_snell",
+    description: "Apply Snell's law for light refraction. Calculates refraction angle and detects total internal reflection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        n1: { type: "number", description: "Refractive index of medium 1" },
+        n2: { type: "number", description: "Refractive index of medium 2" },
+        angle: { type: "number", description: "Incident angle in degrees" }
+      },
+      required: ["n1", "n2", "angle"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.snellsLaw(args.n1, args.n2, args.angle);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_ideal_gas",
+    description: "Solve the ideal gas law (PV = nRT). Provide at least 3 of pressure, volume, moles, temperature.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pressure: { type: "number", description: "Pressure in Pa" },
+        volume: { type: "number", description: "Volume in m\xB3" },
+        moles: { type: "number", description: "Amount in mol" },
+        temperature: { type: "number", description: "Temperature in K" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.idealGasLaw(args);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_carnot",
+    description: "Calculate Carnot efficiency for a heat engine given hot and cold reservoir temperatures.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        hotTemperature: { type: "number", description: "Hot reservoir temperature in Kelvin" },
+        coldTemperature: { type: "number", description: "Cold reservoir temperature in Kelvin" }
+      },
+      required: ["hotTemperature", "coldTemperature"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.carnotEfficiency(args.hotTemperature, args.coldTemperature);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_lorentz",
+    description: "Calculate the Lorentz factor (gamma) for special relativity given a velocity.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        velocity: { type: "number", description: "Velocity in m/s" }
+      },
+      required: ["velocity"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.lorentzFactor(args.velocity);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_time_dilation",
+    description: "Calculate relativistic time dilation for a moving object.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        properTime: { type: "number", description: "Proper time in seconds" },
+        velocity: { type: "number", description: "Velocity in m/s" }
+      },
+      required: ["properTime", "velocity"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.timeDilation(args.properTime, args.velocity);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_mass_energy",
+    description: "Calculate mass-energy equivalence (E = mc\xB2). Convert mass to energy or energy to mass.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mass: { type: "number", description: "Mass in kg (for mass\u2192energy)" },
+        energy: { type: "number", description: "Energy in joules (for energy\u2192mass)" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        const result = args.mass !== void 0 ? agentToolsCore.physics.massEnergy(args.mass) : agentToolsCore.physics.energyToMass(args.energy);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_physics_unit_convert",
+    description: "Convert between physics units: force (N, lbf, kgf), energy (J, cal, eV, kWh, BTU), power (W, hp), pressure (Pa, atm, bar, psi), speed (m/s, km/h, mph).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        value: { type: "number", description: "Value to convert" },
+        from: { type: "string", description: "Source unit" },
+        to: { type: "string", description: "Target unit" },
+        category: { type: "string", enum: ["force", "energy", "power", "pressure", "speed"], description: "Unit category" }
+      },
+      required: ["value", "from", "to", "category"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.physics.convertPhysicsUnit(args.value, args.from, args.to, args.category);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  }
+];
+var structuralTools = [
+  // --- Stress & Strain ---
+  {
+    name: "agent_tools_structural_normal_stress",
+    description: "Calculate normal stress (\u03C3 = F/A) given force and cross-sectional area.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        force: { type: "number", description: "Axial force in Newtons" },
+        area: { type: "number", description: "Cross-sectional area in m\xB2" }
+      },
+      required: ["force", "area"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.normalStress(args.force, args.area);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_shear_stress",
+    description: "Calculate shear stress (\u03C4 = V/A) given shear force and area.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        force: { type: "number", description: "Shear force in Newtons" },
+        area: { type: "number", description: "Cross-sectional area in m\xB2" }
+      },
+      required: ["force", "area"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.shearStress(args.force, args.area);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_strain",
+    description: "Calculate strain (\u03B5 = \u0394L/L) given change in length and original length.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        deltaLength: { type: "number", description: "Change in length in meters" },
+        originalLength: { type: "number", description: "Original length in meters" }
+      },
+      required: ["deltaLength", "originalLength"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.strain(args.deltaLength, args.originalLength);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_youngs_modulus",
+    description: "Calculate Young's modulus (E = \u03C3/\u03B5) from stress and strain values.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        stress: { type: "number", description: "Stress in Pa" },
+        strain: { type: "number", description: "Strain (dimensionless)" }
+      },
+      required: ["stress", "strain"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.youngsModulus(args.stress, args.strain);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_factor_of_safety",
+    description: "Calculate factor of safety (FoS = \u03C3_ultimate / \u03C3_working).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ultimateStress: { type: "number", description: "Ultimate stress in Pa" },
+        workingStress: { type: "number", description: "Working/allowable stress in Pa" }
+      },
+      required: ["ultimateStress", "workingStress"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.factorOfSafety(args.ultimateStress, args.workingStress);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_hoop_stress",
+    description: "Calculate hoop and longitudinal stress in thin-walled pressure vessels (\u03C3 = pR/t).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pressure: { type: "number", description: "Internal pressure in Pa" },
+        radius: { type: "number", description: "Vessel radius in meters" },
+        thickness: { type: "number", description: "Wall thickness in meters" }
+      },
+      required: ["pressure", "radius", "thickness"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.hoopStress(args.pressure, args.radius, args.thickness);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  // --- Beams ---
+  {
+    name: "agent_tools_structural_simply_supported_beam",
+    description: "Analyze a simply supported beam: reactions, max moment, max shear, and deflection. Load types: point-center, point-custom, uniform, triangular.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        length: { type: "number", description: "Beam length in meters" },
+        load: { type: "number", description: "Total load in Newtons" },
+        loadType: { type: "string", enum: ["point-center", "point-custom", "uniform", "triangular"], description: "Type of loading" },
+        E: { type: "number", description: "Elastic modulus in Pa (optional, for deflection)" },
+        I: { type: "number", description: "Moment of inertia in m\u2074 (optional, for deflection)" },
+        loadPosition: { type: "number", description: "Load position from left end in meters (for point-custom)" }
+      },
+      required: ["length", "load", "loadType"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.simplySupported(args.length, args.load, args.loadType, args.E, args.I, args.loadPosition);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_cantilever_beam",
+    description: "Analyze a cantilever beam: reactions, max moment, max shear, and deflection. Load types: point-end, point-custom, uniform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        length: { type: "number", description: "Beam length in meters" },
+        load: { type: "number", description: "Total load in Newtons" },
+        loadType: { type: "string", enum: ["point-end", "point-custom", "uniform"], description: "Type of loading" },
+        E: { type: "number", description: "Elastic modulus in Pa (optional, for deflection)" },
+        I: { type: "number", description: "Moment of inertia in m\u2074 (optional, for deflection)" },
+        loadPosition: { type: "number", description: "Load position from fixed end in meters (for point-custom)" }
+      },
+      required: ["length", "load", "loadType"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.cantilever(args.length, args.load, args.loadType, args.E, args.I, args.loadPosition);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  // --- Columns ---
+  {
+    name: "agent_tools_structural_euler_buckling",
+    description: "Calculate Euler's critical buckling load (Pcr = \u03C0\xB2EI/Le\xB2) for columns with various end conditions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        E: { type: "number", description: "Elastic modulus in Pa" },
+        I: { type: "number", description: "Moment of inertia in m\u2074" },
+        length: { type: "number", description: "Column length in meters" },
+        endCondition: { type: "string", enum: ["pinned-pinned", "fixed-free", "fixed-pinned", "fixed-fixed"], description: "End support conditions" }
+      },
+      required: ["E", "I", "length", "endCondition"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.eulerBuckling(args.E, args.I, args.length, args.endCondition);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_slenderness_ratio",
+    description: "Calculate slenderness ratio (\u03BB = Le/r) and classify column as short, intermediate, or long.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        effectiveLength: { type: "number", description: "Effective length in meters" },
+        radiusOfGyration: { type: "number", description: "Radius of gyration in meters" }
+      },
+      required: ["effectiveLength", "radiusOfGyration"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.slendernessRatio(args.effectiveLength, args.radiusOfGyration);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  // --- Sections ---
+  {
+    name: "agent_tools_structural_rectangle_section",
+    description: "Calculate properties of a rectangular cross-section: area, Ixx, Iyy, Sx, Sy, rx, ry.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        width: { type: "number", description: "Width in meters" },
+        height: { type: "number", description: "Height in meters" }
+      },
+      required: ["width", "height"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.rectangleSection(args.width, args.height);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_circular_section",
+    description: "Calculate properties of a solid circular cross-section: area, I, S, r.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        diameter: { type: "number", description: "Diameter in meters" }
+      },
+      required: ["diameter"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.circularSection(args.diameter);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_hollow_circular_section",
+    description: "Calculate properties of a hollow circular (tube) cross-section: area, I, S, r.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        outerDiameter: { type: "number", description: "Outer diameter in meters" },
+        innerDiameter: { type: "number", description: "Inner diameter in meters" }
+      },
+      required: ["outerDiameter", "innerDiameter"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.hollowCircularSection(args.outerDiameter, args.innerDiameter);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_i_beam_section",
+    description: "Calculate properties of an I-beam (wide flange) cross-section: area, Ixx, Iyy, Sx, Sy, rx, ry.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        flangeWidth: { type: "number", description: "Flange width in meters" },
+        flangeThickness: { type: "number", description: "Flange thickness in meters" },
+        webHeight: { type: "number", description: "Web height (between flanges) in meters" },
+        webThickness: { type: "number", description: "Web thickness in meters" }
+      },
+      required: ["flangeWidth", "flangeThickness", "webHeight", "webThickness"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.iBeamSection(args.flangeWidth, args.flangeThickness, args.webHeight, args.webThickness);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  // --- Soils ---
+  {
+    name: "agent_tools_structural_terzaghi_bearing",
+    description: "Calculate Terzaghi's bearing capacity for shallow foundations (strip, square, circular).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cohesion: { type: "number", description: "Soil cohesion in Pa" },
+        depth: { type: "number", description: "Foundation depth in meters" },
+        unitWeight: { type: "number", description: "Soil unit weight in N/m\xB3" },
+        frictionAngle: { type: "number", description: "Soil friction angle in degrees" },
+        foundationType: { type: "string", enum: ["strip", "square", "circular"], description: "Foundation shape" }
+      },
+      required: ["cohesion", "depth", "unitWeight", "frictionAngle", "foundationType"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.terzaghiBearing(args.cohesion, args.depth, args.unitWeight, args.frictionAngle, args.foundationType);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_lateral_earth_pressure",
+    description: "Calculate Rankine lateral earth pressure coefficients and forces (active, passive, at-rest).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        unitWeight: { type: "number", description: "Soil unit weight in N/m\xB3" },
+        height: { type: "number", description: "Wall/excavation height in meters" },
+        frictionAngle: { type: "number", description: "Soil friction angle in degrees" },
+        pressureType: { type: "string", enum: ["active", "passive", "at-rest"], description: "Type of earth pressure" }
+      },
+      required: ["unitWeight", "height", "frictionAngle", "pressureType"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.lateralEarthPressure(args.unitWeight, args.height, args.frictionAngle, args.pressureType);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_settlement",
+    description: "Calculate elastic settlement (\u03B4 = qH/E) for foundations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        load: { type: "number", description: "Applied load in Newtons" },
+        area: { type: "number", description: "Foundation area in m\xB2" },
+        elasticModulus: { type: "number", description: "Soil elastic modulus in Pa" },
+        thickness: { type: "number", description: "Compressible layer thickness in meters" }
+      },
+      required: ["load", "area", "elasticModulus", "thickness"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.settlement(args.load, args.area, args.elasticModulus, args.thickness);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  // --- Materials ---
+  {
+    name: "agent_tools_structural_get_material",
+    description: "Look up structural material properties (E, fy, fu, density, Poisson ratio, thermal expansion) by name.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Material name (e.g., A36, A992, 304, 6061, C30, Douglas Fir)" }
+      },
+      required: ["name"]
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.getMaterial(args.name);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  },
+  {
+    name: "agent_tools_structural_list_materials",
+    description: "List structural materials, optionally filtered by category (steel, aluminum, concrete, timber, other).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: { type: "string", description: "Filter by category: steel, aluminum, concrete, timber, other" }
+      },
+      required: []
+    },
+    handler: async (args) => {
+      try {
+        const result = agentToolsCore.structural.listMaterials(args.category);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  }
+];
+
+// src/tools/index.ts
+var allTools = [
+  ...jsonTools,
+  ...csvTools,
+  ...pdfTools,
+  ...xmlTools,
+  ...excelTools,
+  ...imageTools,
+  ...markdownTools,
+  ...archiveTools,
+  ...regexTools,
+  ...diffTools,
+  ...sqlTools,
+  ...cryptoMcpTools,
+  ...datetimeTools,
+  ...textTools,
+  ...mathTools,
+  ...colorTools,
+  ...physicsTools,
+  ...structuralTools
+];
+
+// src/server.ts
+function getToolCategory(toolName) {
+  const match = toolName.match(/^agent_tools_([a-z]+)_/);
+  return match ? match[1] : null;
+}
+function createServer() {
+  const server = new index_js.Server(
+    {
+      name: "agent-tools",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
+    const settings$1 = await settings.settingsService.getSettings();
+    const enabledTools = allTools.filter((tool) => {
+      const category = getToolCategory(tool.name);
+      return !category || settings$1.enabled[category] !== false;
+    });
+    return {
+      tools: enabledTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      }))
+    };
+  });
+  server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const category = getToolCategory(name);
+    if (category) {
+      const enabled = await settings.settingsService.isToolEnabled(category);
+      if (!enabled) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: The "${category}" tool category is currently disabled. Enable it in Settings.`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    const tool = allTools.find((t) => t.name === name);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    try {
+      const result = await tool.handler(args);
+      return result;
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function runStdioServer() {
+  const server = createServer();
+  const transport = new stdio_js.StdioServerTransport();
+  await server.connect(transport);
+}
+function createHttpServer(port = 3001) {
+  const app = express__default.default();
+  app.use(express__default.default.json({ limit: "50mb" }));
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  app.options("*", (_req, res) => {
+    res.sendStatus(200);
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", server: "agent-tools-mcp", version: "1.0.0" });
+  });
+  app.post("/mcp", async (req, res) => {
+    const request = req.body;
+    if (request.jsonrpc !== "2.0") {
+      return res.status(400).json({
+        jsonrpc: "2.0",
+        id: request.id,
+        error: { code: -32600, message: "Invalid Request" }
+      });
+    }
+    try {
+      const result = await handleRequest(request);
+      res.json(result);
+    } catch (error) {
+      res.json({
+        jsonrpc: "2.0",
+        id: request.id,
+        error: {
+          code: -32603,
+          message: error.message
+        }
+      });
+    }
+  });
+  app.post("/mcp/stream", async (req, res) => {
+    const request = req.body;
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    try {
+      res.write(`event: start
+`);
+      res.write(`data: ${JSON.stringify({ id: request.id })}
+
+`);
+      const result = await handleRequest(request);
+      res.write(`event: result
+`);
+      res.write(`data: ${JSON.stringify(result)}
+
+`);
+      res.write(`event: end
+`);
+      res.write(`data: {}
+
+`);
+      res.end();
+    } catch (error) {
+      res.write(`event: error
+`);
+      res.write(
+        `data: ${JSON.stringify({ error: error.message })}
+
+`
+      );
+      res.end();
+    }
+  });
+  app.get("/tools", (_req, res) => {
+    res.json({
+      tools: allTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      }))
+    });
+  });
+  return app.listen(port, () => {
+    console.log(`Agent Tools MCP HTTP server running on port ${port}`);
+    console.log(`Endpoints:`);
+    console.log(`  POST /mcp          - JSON-RPC endpoint`);
+    console.log(`  POST /mcp/stream   - Streaming endpoint`);
+    console.log(`  GET  /tools        - List available tools`);
+    console.log(`  GET  /health       - Health check`);
+  });
+}
+async function handleRequest(request) {
+  const { method, params, id } = request;
+  switch (method) {
+    case "tools/list":
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          tools: allTools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+          }))
+        }
+      };
+    case "tools/call": {
+      const { name, arguments: args } = params;
+      const tool = allTools.find((t) => t.name === name);
+      if (!tool) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `Unknown tool: ${name}` }
+        };
+      }
+      try {
+        const result = await tool.handler(args);
+        return { jsonrpc: "2.0", id, result };
+      } catch (error) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32603, message: error.message }
+        };
+      }
+    }
+    case "initialize":
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: "2024-11-05",
+          serverInfo: {
+            name: "agent-tools",
+            version: "1.0.0"
+          },
+          capabilities: {
+            tools: {}
+          }
+        }
+      };
+    default:
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32601, message: `Method not found: ${method}` }
+      };
+  }
+}
+var clients = /* @__PURE__ */ new Map();
+function createSSEServer(port = 3001) {
+  const app = express__default.default();
+  app.use(express__default.default.json({ limit: "50mb" }));
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", server: "agent-tools-mcp-sse", version: "1.0.0" });
+  });
+  app.get("/sse", (req, res) => {
+    const clientId = Math.random().toString(36).substring(7);
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.write(`event: connected
+`);
+    res.write(`data: ${JSON.stringify({ clientId })}
+
+`);
+    res.write(`event: endpoint
+`);
+    res.write(`data: ${JSON.stringify({ endpoint: `/message?clientId=${clientId}` })}
+
+`);
+    clients.set(clientId, { id: clientId, res });
+    req.on("close", () => {
+      clients.delete(clientId);
+    });
+  });
+  app.post("/message", async (req, res) => {
+    const clientId = req.query.clientId;
+    const client = clients.get(clientId);
+    if (!client) {
+      return res.status(404).json({ error: "Client not found" });
+    }
+    const { method, params, id } = req.body;
+    try {
+      let result;
+      switch (method) {
+        case "tools/list":
+          result = {
+            tools: allTools.map((tool) => ({
+              name: tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema
+            }))
+          };
+          break;
+        case "tools/call": {
+          const { name, arguments: args } = params;
+          const tool = allTools.find((t) => t.name === name);
+          if (!tool) {
+            throw new Error(`Unknown tool: ${name}`);
+          }
+          result = await tool.handler(args);
+          break;
+        }
+        case "initialize":
+          result = {
+            protocolVersion: "2024-11-05",
+            serverInfo: {
+              name: "agent-tools",
+              version: "1.0.0"
+            },
+            capabilities: {
+              tools: {}
+            }
+          };
+          break;
+        default:
+          throw new Error(`Unknown method: ${method}`);
+      }
+      client.res.write(`event: message
+`);
+      client.res.write(
+        `data: ${JSON.stringify({ jsonrpc: "2.0", id, result })}
+
+`
+      );
+      res.json({ status: "sent" });
+    } catch (error) {
+      client.res.write(`event: message
+`);
+      client.res.write(
+        `data: ${JSON.stringify({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32603, message: error.message }
+        })}
+
+`
+      );
+      res.json({ status: "error", error: error.message });
+    }
+  });
+  app.get("/tools", (_req, res) => {
+    res.json({
+      tools: allTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      }))
+    });
+  });
+  return app.listen(port, () => {
+    console.log(`Agent Tools MCP SSE server running on port ${port}`);
+    console.log(`Endpoints:`);
+    console.log(`  GET  /sse          - SSE connection`);
+    console.log(`  POST /message      - Send message (requires clientId)`);
+    console.log(`  GET  /tools        - List available tools`);
+    console.log(`  GET  /health       - Health check`);
+  });
+}
+
+// src/cli.ts
+var program = new commander.Command();
+program.name("agent-tools-mcp").description("Agent Tools MCP Server - Deterministic data transformation tools").version("1.0.0");
+program.option("-t, --transport <type>", "Transport type: stdio, sse, http", "stdio").option("-p, --port <number>", "Port for HTTP/SSE transport", "3001").action(async (options) => {
+  const { transport, port } = options;
+  console.log(`Starting Agent Tools MCP server...`);
+  console.log(`Transport: ${transport}`);
+  switch (transport) {
+    case "stdio":
+      await runStdioServer();
+      break;
+    case "http":
+      createHttpServer(parseInt(port, 10));
+      break;
+    case "sse":
+      createSSEServer(parseInt(port, 10));
+      break;
+    default:
+      console.error(`Unknown transport: ${transport}`);
+      process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map