@aashari/boilerplate-mcp-server 1.14.0 → 1.16.0

package/.trigger-ci

@@ -0,0 +1 @@
+# CI/CD trigger Thu Sep 18 00:40:39 WIB 2025

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+# [1.16.0](https://github.com/aashari/boilerplate-mcp-server/compare/v1.15.0...v1.16.0) (2025-12-01)
+
+
+### Bug Fixes
+
+* regenerate package-lock.json to fix CI dependency resolution ([a0225a8](https://github.com/aashari/boilerplate-mcp-server/commit/a0225a8f9bb0bb5b27a436099d0b131fa47e8cbc))
+
+
+### Features
+
+* modernize SDK usage and update dependencies ([#127](https://github.com/aashari/boilerplate-mcp-server/issues/127)) ([a36c9f6](https://github.com/aashari/boilerplate-mcp-server/commit/a36c9f644d842e9c5360d4ed2f207ada18d97ebd))
+
+# [1.15.0](https://github.com/aashari/boilerplate-mcp-server/compare/v1.14.0...v1.15.0) (2025-12-01)
+
+
+### Bug Fixes
+
+* update tests for TOON output format ([6054be3](https://github.com/aashari/boilerplate-mcp-server/commit/6054be313fd54c6678b39da214c13e17b04ec4a6))
+
+
+### Features
+
+* add TOON output format with JMESPath filtering support ([#126](https://github.com/aashari/boilerplate-mcp-server/issues/126)) ([2b3d8d8](https://github.com/aashari/boilerplate-mcp-server/commit/2b3d8d8a6811a1296475b6971d840b9392ceff08))
+
 # [1.14.0](https://github.com/aashari/boilerplate-mcp-server/compare/v1.13.5...v1.14.0) (2025-09-09)
 
 

package/README.md

@@ -9,7 +9,10 @@ A production-ready foundation for developing custom Model Context Protocol (MCP)
 
 - **Dual Transport Support**: STDIO and Streamable HTTP transports with automatic fallback
 - **5-Layer Architecture**: Clean separation between CLI, tools, controllers, services, and utilities
-- **Type Safety**: Full TypeScript implementation with Zod schema validation
+- **Type Safety**: Full TypeScript implementation with Zod v4 schema validation
+- **TOON Output Format**: Token-Oriented Object Notation for 30-60% fewer tokens than JSON
+- **JMESPath Filtering**: Extract only needed fields from responses to reduce token costs
+- **Modern SDK**: Uses MCP SDK v1.23.0 with `registerTool` API pattern
 - **Complete IP Address Example**: Tools, resources, and CLI commands for IP geolocation
 - **Comprehensive Testing**: Unit and integration tests with coverage reporting
 - **Production Tooling**: ESLint, Prettier, semantic-release, and MCP Inspector integration
@@ -43,6 +46,8 @@ npm run build
 npm run cli -- get-ip-details 8.8.8.8
 npm run cli -- get-ip-details              # Get your current IP
 npm run cli -- get-ip-details 1.1.1.1 --include-extended-data
+npm run cli -- get-ip-details 8.8.8.8 --jq "{ip: query, country: country}"  # JQ filter
+npm run cli -- get-ip-details 8.8.8.8 --output-format json                   # JSON output
 
 # 2. STDIO Transport - For AI assistant integration (Claude Desktop, Cursor)
 npm run mcp:stdio
@@ -69,6 +74,52 @@ npm run mcp:inspect                         # Auto-opens browser with debugging
 - Health Check: `http://localhost:3000/` → Returns server version
 - Run with: `TRANSPORT_MODE=http node dist/index.js`
 
+## Output Formats
+
+### TOON Format (Default)
+
+TOON (Token-Oriented Object Notation) is a human-readable format optimized for LLMs, reducing token usage by 30-60% compared to JSON:
+
+```
+status: success
+query: 8.8.8.8
+country: United States
+city: Ashburn
+lat: 39.03
+lon: -77.5
+```
+
+### JSON Format
+
+Standard JSON output when `--output-format json` is specified:
+
+```json
+{
+  "status": "success",
+  "query": "8.8.8.8",
+  "country": "United States",
+  "city": "Ashburn"
+}
+```
+
+### JMESPath Filtering
+
+Use `--jq` to extract only needed fields, reducing token costs:
+
+```bash
+# Extract specific fields
+npm run cli -- get-ip-details 8.8.8.8 --jq "{ip: query, country: country}"
+
+# Output:
+# ip: 8.8.8.8
+# country: United States
+
+# Nested structure
+npm run cli -- get-ip-details 8.8.8.8 --jq "{location: {city: city, coords: {lat: lat, lon: lon}}}"
+```
+
+See [JMESPath documentation](https://jmespath.org) for more filter examples.
+
 ## Architecture Overview
 
 <details>
@@ -99,6 +150,8 @@ src/
 │   ├── config.util.ts      # Environment configuration
 │   ├── constants.util.ts   # Version and package constants
 │   ├── formatter.util.ts   # Markdown formatting
+│   ├── toon.util.ts        # TOON format encoding
+│   ├── jq.util.ts          # JMESPath filtering
 │   └── transport.util.ts   # HTTP transport utilities
 └── index.ts                # Server entry point (dual transport)
 ```
@@ -126,9 +179,9 @@ The boilerplate follows a clean, layered architecture that promotes maintainabil
 ### 3. Resources Layer (`src/resources/`)
 
 - **Purpose**: MCP resources providing contextual data accessible via URIs
-- **Implementation**: Resource handlers that respond to URI-based requests
-- **Example**: `ip://8.8.8.8` resource providing IP geolocation data
-- **Pattern**: Register URI patterns → Parse requests → Return formatted content
+- **Implementation**: Uses `registerResource` API with `ResourceTemplate` for parameterized URIs
+- **Example**: `ip://{ipAddress}` resource template providing IP geolocation data
+- **Pattern**: Register URI template → Extract variables → Return formatted content
 
 ### 4. Controllers Layer (`src/controllers/`)
 
@@ -147,11 +200,13 @@ The boilerplate follows a clean, layered architecture that promotes maintainabil
 ### 6. Utils Layer (`src/utils/`)
 
 - **Purpose**: Shared functionality across all layers
-- **Key Components**: 
+- **Key Components**:
   - `logger.util.ts`: Contextual logging (file:method context)
   - `error.util.ts`: MCP-specific error formatting
   - `transport.util.ts`: HTTP/API utilities with retry logic
   - `config.util.ts`: Environment configuration management
+  - `toon.util.ts`: TOON format encoding (token-efficient output)
+  - `jq.util.ts`: JMESPath filtering for response transformation
 
 ## Developer Guide
 
@@ -396,16 +451,20 @@ async function handleGetData(args: Record<string, unknown>) {
 	}
 }
 
-// Registration function following the pattern used by existing tools
+// Registration function using the modern registerTool API (SDK v1.22.0+)
 function registerTools(server: McpServer) {
 	const registerLogger = logger.forMethod('registerTools');
 	registerLogger.debug('Registering example tools...');
 
-	server.tool(
+	// SDK best practices: 'title' for UI display name, 'description' for detailed info
+	server.registerTool(
 		'example_get_data',
-		`Gets data from the Example API with optional parameter.
+		{
+			title: 'Get Example Data',  // Display name for UI (e.g., 'Get Example Data')
+			description: `Gets data from the Example API with optional parameter.
 Use this tool to fetch example data. Returns formatted data as Markdown.`,
-		GetDataSchema.shape,
+			inputSchema: GetDataSchema,
+		},
 		handleGetData
 	);
 
@@ -484,6 +543,63 @@ import exampleTools from './tools/example.tool.js';
 exampleTools.registerTools(serverInstance);
 ```
 
+### 6. Add MCP Resource (Optional)
+
+Create a resource in `src/resources/` using the modern `registerResource` API:
+
+```typescript
+// src/resources/example.resource.ts
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Logger } from '../utils/logger.util.js';
+import exampleController from '../controllers/example.controller.js';
+import { formatErrorForMcpResource } from '../utils/error.util.js';
+
+const logger = Logger.forContext('resources/example.resource.ts');
+
+function registerResources(server: McpServer) {
+	const registerLogger = logger.forMethod('registerResources');
+	registerLogger.debug('Registering example resources...');
+
+	// Use registerResource with ResourceTemplate for parameterized URIs (SDK v1.22.0+)
+	server.registerResource(
+		'example-data',
+		new ResourceTemplate('example://{param}', { list: undefined }),
+		{
+			title: 'Example Data',  // Display name for UI
+			description: 'Retrieve example data by parameter'
+		},
+		async (uri, variables) => {
+			const methodLogger = logger.forMethod('exampleResource');
+			try {
+				// Extract parameter from template variables
+				const param = variables.param as string | undefined;
+
+				methodLogger.debug('Example resource called', { uri: uri.href, param });
+
+				const result = await exampleController.getData({ param });
+
+				return {
+					contents: [
+						{
+							uri: uri.href,
+							text: result.content,
+							mimeType: 'text/markdown'
+						}
+					]
+				};
+			} catch (error) {
+				methodLogger.error('Resource error', error);
+				return formatErrorForMcpResource(error, uri.href);
+			}
+		}
+	);
+
+	registerLogger.debug('Example resources registered successfully');
+}
+
+export default { registerResources };
+```
+
 </details>
 
 ## IP Address Example Implementation
@@ -494,26 +610,30 @@ The boilerplate includes a complete IP address geolocation example demonstrating
 
 **CLI Commands:**
 ```bash
-npm run cli -- get-ip-details                           # Get current public IP
-npm run cli -- get-ip-details 8.8.8.8                  # Get details for specific IP
+npm run cli -- get-ip-details                           # Get current public IP (TOON format)
+npm run cli -- get-ip-details 8.8.8.8                   # Get details for specific IP
 npm run cli -- get-ip-details 1.1.1.1 --include-extended-data   # With extended data
-npm run cli -- get-ip-details 8.8.8.8 --no-use-https   # Force HTTP (for free tier)
+npm run cli -- get-ip-details 8.8.8.8 --no-use-https    # Force HTTP (for free tier)
+npm run cli -- get-ip-details 8.8.8.8 --output-format json      # JSON output
+npm run cli -- get-ip-details 8.8.8.8 --jq "{ip: query, country: country}"  # Filtered output
 ```
 
 **MCP Tools:**
 - `ip_get_details` - IP geolocation lookup for AI assistants
+  - Supports `outputFormat`: "toon" (default) or "json"
+  - Supports `jq`: JMESPath expression for filtering
 
 **MCP Resources:**
-- `ip://` - Current IP details  
-- `ip://8.8.8.8` - Specific IP details
+- `ip://{ipAddress}` - IP details resource template (e.g., `ip://8.8.8.8`)
 
 ### Features Demonstrated
 
+- **TOON Output**: Token-efficient format (30-60% fewer tokens than JSON)
+- **JMESPath Filtering**: Extract only needed fields to reduce costs
 - **Fallback Logic**: HTTPS → HTTP fallback for free tier users
 - **Environment Detection**: Different behavior in test vs production
 - **API Token Support**: Optional token for extended data (ASN, mobile detection, etc.)
 - **Error Handling**: Structured errors for private/reserved IP addresses
-- **Response Formatting**: Clean Markdown output with geolocation data
 
 ### Configuration Options
 
@@ -592,9 +712,10 @@ npm run test:cli           # CLI-specific tests only
 ## Resources & Documentation
 
 ### MCP Protocol Resources
-- [MCP Specification](https://modelcontextprotocol.io/specification/2025-06-18)
-- [MCP SDK Documentation](https://github.com/modelcontextprotocol/sdk)
+- [MCP Specification](https://modelcontextprotocol.io/specification) - Latest protocol specification
+- [MCP SDK Documentation](https://github.com/modelcontextprotocol/typescript-sdk) - TypeScript SDK v1.23.0+
 - [MCP Inspector](https://github.com/modelcontextprotocol/inspector) - Visual debugging tool
+- [MCP Concepts](https://modelcontextprotocol.io/docs/concepts) - Tools, resources, transports
 
 ### Implementation References
 - [Anthropic MCP Announcement](https://www.anthropic.com/news/model-context-protocol)

package/STYLE_GUIDE.md

@@ -1,12 +1,15 @@
 # MCP Server Style Guide
 
-Based on the patterns observed and best practices, I recommend adopting the following consistent style guide across all your MCP servers:
+Based on the MCP SDK v1.22.0+ best practices and observed patterns, this guide ensures consistency across all MCP servers.
+
+## Naming Conventions
 
 | Element              | Convention                                                                                                                                    | Rationale / Examples                                                                                                                              |
 | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------ |
 | **CLI Commands**     | `verb-noun` in `kebab-case`. Use the shortest unambiguous verb (`ls`, `get`, `create`, `add`, `exec`, `search`).                              | `ls-repos`, `get-pr`, `create-comment`, `exec-command`                                                                                            |
 | **CLI Options**      | `--kebab-case`. Be specific (e.g., `--workspace-slug`, not just `--slug`).                                                                    | `--project-key-or-id`, `--source-branch`                                                                                                          |
 | **MCP Tool Names**   | `<namespace>_<verb>_<noun>` in `snake_case`. Use a concise 2-4 char namespace. Avoid noun repetition.                                         | `bb_ls_repos` (Bitbucket list repos), `conf_get_page` (Confluence get page), `aws_exec_command` (AWS execute command). Avoid `ip_ip_get_details`. |
+| **MCP Resource Names**| `kebab-case`. Descriptive identifier for the resource type.                                                                                  | `ip-lookup`, `user-profile`, `config-data`                                                                                                        |
 | **MCP Arguments**    | `camelCase`. Suffix identifiers consistently (e.g., `Id`, `Key`, `Slug`). Avoid abbreviations unless universal.                               | `workspaceSlug`, `pullRequestId`, `sourceBranch`, `pageId`.                                                                                       |
 | **Boolean Args**     | Use verb prefixes for clarity (`includeXxx`, `launchBrowser`). Avoid bare adjectives (`--https`).                                             | `includeExtendedData: boolean`, `launchBrowser: boolean`                                                                                          |
 | **Array Args**       | Use plural names (`spaceIds`, `labels`, `statuses`).                                                                                          | `spaceIds: string[]`, `labels: string[]`                                                                                                          |
@@ -14,4 +17,60 @@ Based on the patterns observed and best practices, I recommend adopting the foll
 | **Arg Descriptions** | Start lowercase, explain purpose clearly. Mention defaults or constraints.                                                                    | `numeric ID of the page to retrieve (e.g., "456789"). Required.`                                                                                  |
 | **ID/Key Naming**    | Use consistent suffixes like `Id`, `Key`, `Slug`, `KeyOrId` where appropriate.                                                                | `pageId`, `projectKeyOrId`, `workspaceSlug`                                                                                                       |
 
+## SDK Best Practices (v1.22.0+)
+
+### Title vs Name
+
+All registrations (`registerTool`, `registerResource`, `registerPrompt`) support both `name` and `title`:
+
+| Field | Purpose | Example |
+| :---- | :------ | :------ |
+| `name` | Unique identifier for programmatic use | `ip_get_details` |
+| `title` | Human-readable display name for UI | `IP Address Lookup` |
+
+**Always provide both** - `name` for code, `title` for user interfaces.
+
+### Modern Registration APIs
+
+Use the modern `register*` methods instead of deprecated alternatives:
+
+| Deprecated | Modern (SDK v1.22.0+) |
+| :--------- | :-------------------- |
+| `server.tool()` | `server.registerTool()` |
+| `server.resource()` | `server.registerResource()` |
+| `server.prompt()` | `server.registerPrompt()` |
+
+### Resource Templates
+
+Use `ResourceTemplate` for parameterized resource URIs:
+
+```typescript
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+// Static resource - fixed URI
+server.registerResource('config', 'config://app', { ... }, handler);
+
+// Dynamic resource - parameterized URI
+server.registerResource(
+    'user-profile',
+    new ResourceTemplate('users://{userId}/profile', { list: undefined }),
+    { title: 'User Profile', description: '...' },
+    async (uri, variables) => {
+        const userId = variables.userId as string;
+        // ...
+    }
+);
+```
+
+### Error Handling
+
+Use `isError: true` for tool execution failures:
+
+```typescript
+return {
+    content: [{ type: 'text', text: 'Error: Something went wrong' }],
+    isError: true
+};
+```
+
 Adopting this guide will make the tools more predictable and easier for both humans and AI agents to understand and use correctly.

package/dist/cli/ipaddress.cli.js

@@ -21,6 +21,8 @@ function register(program) {
         .option('-e, --include-extended-data', 'Include extended data (ASN, host, org). Requires API token.')
         .option('--no-use-https', // commander creates a 'useHttps' boolean, defaulting to true
     'Use HTTP instead of HTTPS for the API call.')
+        .option('--jq <expression>', 'JMESPath expression to filter/transform the response.')
+        .option('-o, --output-format <format>', 'Output format: "toon" (default, token-efficient) or "json".', 'toon')
         .action(async (ipAddress, options) => {
         const actionLogger = logger.forMethod('action:get-ip-details');
         try {
@@ -33,6 +35,8 @@ function register(program) {
                 ipAddress,
                 includeExtendedData: options.includeExtendedData || false,
                 useHttps: options.useHttps, // commander handles the default via --no-use-https
+                jq: options.jq,
+                outputFormat: options.outputFormat,
             };
             const result = await ipaddress_controller_js_1.default.get(args);
             console.log(result.content);

package/dist/controllers/ipaddress.controller.d.ts

@@ -1,4 +1,13 @@
-import { ControllerResponse } from '../types/common.types.js';
+/**
+ * Output format type
+ */
+type OutputFormat = 'toon' | 'json';
+/**
+ * Controller response type
+ */
+interface ControllerResponse {
+    content: string;
+}
 /**
  * @namespace IpAddressController
  * @description Controller responsible for handling IP address lookup logic.
@@ -14,13 +23,17 @@ import { ControllerResponse } from '../types/common.types.js';
  * @param {string} [args.ipAddress] - Optional IP address to look up. If omitted, the service will fetch the current device's public IP.
  * @param {boolean} [args.includeExtendedData=false] - Whether to include extended data fields requiring an API token
  * @param {boolean} [args.useHttps=true] - Whether to use HTTPS for the API request
- * @returns {Promise<ControllerResponse>} A promise that resolves to the standard controller response containing the formatted IP details in Markdown.
+ * @param {string} [args.jq] - JMESPath expression to filter the response
+ * @param {OutputFormat} [args.outputFormat] - Output format (toon or json)
+ * @returns {Promise<ControllerResponse>} A promise that resolves to the standard controller response containing the formatted IP details.
  * @throws {McpError} Throws an McpError (handled by `handleControllerError`) if the service call fails or returns an error.
  */
 declare function get(args?: {
     ipAddress?: string;
     includeExtendedData?: boolean;
     useHttps?: boolean;
+    jq?: string;
+    outputFormat?: OutputFormat;
 }): Promise<ControllerResponse>;
 declare const _default: {
     get: typeof get;

package/dist/controllers/ipaddress.controller.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_util_js_1 = require("../utils/logger.util.js");
 const vendor_ip_api_com_service_js_1 = __importDefault(require("../services/vendor.ip-api.com.service.js"));
-const ipaddress_formatter_js_1 = require("./ipaddress.formatter.js");
 const error_handler_util_js_1 = require("../utils/error-handler.util.js");
 const config_util_js_1 = require("../utils/config.util.js");
 const error_util_js_1 = require("../utils/error.util.js");
 const error_handler_util_js_2 = require("../utils/error-handler.util.js");
+const jq_util_js_1 = require("../utils/jq.util.js");
 /**
  * @namespace IpAddressController
  * @description Controller responsible for handling IP address lookup logic.
@@ -25,7 +25,9 @@ const error_handler_util_js_2 = require("../utils/error-handler.util.js");
  * @param {string} [args.ipAddress] - Optional IP address to look up. If omitted, the service will fetch the current device's public IP.
  * @param {boolean} [args.includeExtendedData=false] - Whether to include extended data fields requiring an API token
  * @param {boolean} [args.useHttps=true] - Whether to use HTTPS for the API request
- * @returns {Promise<ControllerResponse>} A promise that resolves to the standard controller response containing the formatted IP details in Markdown.
+ * @param {string} [args.jq] - JMESPath expression to filter the response
+ * @param {OutputFormat} [args.outputFormat] - Output format (toon or json)
+ * @returns {Promise<ControllerResponse>} A promise that resolves to the standard controller response containing the formatted IP details.
  * @throws {McpError} Throws an McpError (handled by `handleControllerError`) if the service call fails or returns an error.
  */
 async function get(args = {}) {
@@ -71,12 +73,11 @@ async function get(args = {}) {
             serviceOptions,
             isTestEnvironment,
         });
+        let data;
         try {
             // Call the service with ipAddress and the mapped serviceOptions
-            const data = await vendor_ip_api_com_service_js_1.default.get(args.ipAddress, serviceOptions);
+            data = await vendor_ip_api_com_service_js_1.default.get(args.ipAddress, serviceOptions);
             methodLogger.debug(`Got the response from the service`, data);
-            const formattedContent = (0, ipaddress_formatter_js_1.formatIpDetails)(data);
-            return { content: formattedContent };
         }
         catch (error) {
             // If HTTPS fails with permission/SSL error and useHttps was true, try again with HTTP
@@ -87,17 +88,24 @@ async function get(args = {}) {
                     error.message.includes('Access denied'))) {
                 methodLogger.warn('HTTPS request failed, falling back to HTTP');
                 // Try again with HTTP
-                const httpData = await vendor_ip_api_com_service_js_1.default.get(args.ipAddress, {
+                data = await vendor_ip_api_com_service_js_1.default.get(args.ipAddress, {
                     ...serviceOptions,
                     useHttps: false,
                 });
-                methodLogger.debug(`Got the response from HTTP fallback`, httpData);
-                const formattedContent = (0, ipaddress_formatter_js_1.formatIpDetails)(httpData);
-                return { content: formattedContent };
+                methodLogger.debug(`Got the response from HTTP fallback`, data);
+            }
+            else {
+                // For other errors, rethrow
+                throw error;
             }
-            // For other errors, rethrow
-            throw error;
         }
+        // Apply JQ filter if provided
+        const filteredData = (0, jq_util_js_1.applyJqFilter)(data, args.jq);
+        // Determine output format (default to TOON)
+        const useToon = args.outputFormat !== 'json';
+        // Format the output
+        const content = await (0, jq_util_js_1.toOutputString)(filteredData, useToon);
+        return { content };
     }
     catch (error) {
         throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_2.buildErrorContext)('IP Address', 'get', 'controllers/ipaddress.controller.ts@get', args.ipAddress || 'current device', { args }));

package/dist/resources/ipaddress.resource.d.ts

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
  * Register an IP address lookup resource with the MCP server
+ * Uses the modern registerResource API (SDK v1.22.0+) with ResourceTemplate
  *
  * @param server The MCP server instance
  */

package/dist/resources/ipaddress.resource.js

@@ -3,29 +3,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const logger_util_js_1 = require("../utils/logger.util.js");
 const ipaddress_controller_js_1 = __importDefault(require("../controllers/ipaddress.controller.js"));
 const error_util_js_1 = require("../utils/error.util.js");
 const logger = logger_util_js_1.Logger.forContext('resources/ipaddress.resource.ts');
 /**
  * Register an IP address lookup resource with the MCP server
+ * Uses the modern registerResource API (SDK v1.22.0+) with ResourceTemplate
  *
  * @param server The MCP server instance
  */
 function registerResources(server) {
     const registerLogger = logger.forMethod('registerResources');
     registerLogger.debug('Registering IP lookup resources...');
-    // Register the IP lookup resource
-    server.resource('ip-lookup', 'Lookup IP address details, returning formatted text result', async (uri) => {
+    // Register the IP lookup resource using modern registerResource API
+    // ResourceTemplate enables parameterized URIs with {ipAddress} placeholder
+    server.registerResource('ip-lookup', new mcp_js_1.ResourceTemplate('ip://{ipAddress}', { list: undefined }), {
+        title: 'IP Address Lookup', // Display name for UI
+        description: 'Retrieve geolocation and network information for a public IP address',
+    }, async (uri, variables) => {
         const methodLogger = logger.forMethod('ipLookupResource');
         try {
-            // Extract the IP address from the request path (if present)
-            // Format of the URI would be ip://<ip-address> or ip://
+            // Extract ipAddress from template variables
+            const ipAddress = variables.ipAddress;
             methodLogger.debug('IP lookup resource called', {
-                uri: uri.toString(),
+                uri: uri.href,
+                ipAddress,
             });
-            // Get everything after the ip:// protocol
-            const ipAddress = uri.toString().replace(/^ip:\/\//, '');
             // Call the controller to get the IP details
             const result = await ipaddress_controller_js_1.default.get({
                 ipAddress: ipAddress || undefined,
@@ -36,17 +41,16 @@ function registerResources(server) {
             return {
                 contents: [
                     {
-                        uri: uri.toString(),
+                        uri: uri.href,
                         text: result.content,
                         mimeType: 'text/markdown',
-                        description: `IP Details for ${ipAddress || 'current'}`,
                     },
                 ],
             };
         }
         catch (error) {
             methodLogger.error('Resource error', error);
-            return (0, error_util_js_1.formatErrorForMcpResource)(error, uri.toString());
+            return (0, error_util_js_1.formatErrorForMcpResource)(error, uri.href);
         }
     });
     registerLogger.debug('IP lookup resources registered successfully');

package/dist/services/vendor.ip-api.com.types.d.ts

@@ -24,49 +24,7 @@ export declare const IPDetailSchema: z.ZodObject<{
     mobile: z.ZodOptional<z.ZodBoolean>;
     proxy: z.ZodOptional<z.ZodBoolean>;
     hosting: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    status: string;
-    message?: string | undefined;
-    query?: string | undefined;
-    country?: string | undefined;
-    countryCode?: string | undefined;
-    region?: string | undefined;
-    regionName?: string | undefined;
-    city?: string | undefined;
-    zip?: string | undefined;
-    lat?: number | undefined;
-    lon?: number | undefined;
-    timezone?: string | undefined;
-    isp?: string | undefined;
-    org?: string | undefined;
-    as?: string | undefined;
-    asname?: string | undefined;
-    reverse?: string | undefined;
-    mobile?: boolean | undefined;
-    proxy?: boolean | undefined;
-    hosting?: boolean | undefined;
-}, {
-    status: string;
-    message?: string | undefined;
-    query?: string | undefined;
-    country?: string | undefined;
-    countryCode?: string | undefined;
-    region?: string | undefined;
-    regionName?: string | undefined;
-    city?: string | undefined;
-    zip?: string | undefined;
-    lat?: number | undefined;
-    lon?: number | undefined;
-    timezone?: string | undefined;
-    isp?: string | undefined;
-    org?: string | undefined;
-    as?: string | undefined;
-    asname?: string | undefined;
-    reverse?: string | undefined;
-    mobile?: boolean | undefined;
-    proxy?: boolean | undefined;
-    hosting?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * TypeScript type inferred from the IPDetailSchema.
  * Represents the expected structure of a successful ip-api.com response.

package/dist/tools/ipaddress.tool.d.ts

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
  * @function registerTools
  * @description Registers the IP address lookup tool ('ip_get_details') with the MCP server.
+ *              Uses the modern registerTool API (SDK v1.22.0+) instead of deprecated tool() method.
  *
  * @param {McpServer} server - The MCP server instance.
  */

package/dist/tools/ipaddress.tool.js

@@ -19,10 +19,6 @@ const GetIpDetailsToolSchema = zod_1.z.object({
         .describe('IP address to lookup (omit for current IP)'),
     ...ipaddress_types_js_1.IpAddressToolArgs.shape, // Merge options schema
 });
-/**
- * TypeScript type inferred from the combined tool arguments schema.
- */
-// type GetIpDetailsToolArgsType = z.infer<typeof GetIpDetailsToolSchema>;
 /**
  * @function handleGetIpDetails
  * @description MCP Tool handler to retrieve details for a given IP address (or the current IP).
@@ -54,16 +50,49 @@ async function handleGetIpDetails(args) {
         return (0, error_util_js_1.formatErrorForMcpTool)(error);
     }
 }
+/**
+ * Tool description for ip_get_details
+ */
+const IP_GET_DETAILS_DESCRIPTION = `Retrieve geolocation and network information for a public IP address. Returns TOON format by default (30-60% fewer tokens than JSON).
+
+**IMPORTANT - Cost Optimization:**
+- Use \`jq\` param to extract only needed fields. Unfiltered responses are expensive!
+- Example: \`jq: "{ip: query, country: country, city: city}"\` - extract specific fields
+- If unsure about available fields, first call WITHOUT jq filter to see all fields, then use jq in subsequent calls
+
+**Schema Discovery Pattern:**
+1. First call: \`ipAddress: "8.8.8.8"\` (no jq) - explore available fields
+2. Then use: \`jq: "{ip: query, location: {city: city, country: country}}"\` - extract only what you need
+
+**Output format:** TOON (default, token-efficient) or JSON (\`outputFormat: "json"\`)
+
+**Parameters:**
+- \`ipAddress\` - IP to lookup (omit for current device's public IP)
+- \`includeExtendedData\` - Include ASN, host, proxy detection (requires API token)
+- \`useHttps\` - Use HTTPS (default: true)
+- \`jq\` - JMESPath expression to filter response
+- \`outputFormat\` - "toon" (default) or "json"
+
+**JQ examples:** \`query\` (IP only), \`{ip: query, country: country}\`, \`{location: {lat: lat, lon: lon}}\`
+
+**Note:** Cannot lookup private IPs (192.168.x.x, 10.x.x.x). Powered by ip-api.com.`;
 /**
  * @function registerTools
  * @description Registers the IP address lookup tool ('ip_get_details') with the MCP server.
+ *              Uses the modern registerTool API (SDK v1.22.0+) instead of deprecated tool() method.
  *
  * @param {McpServer} server - The MCP server instance.
  */
 function registerTools(server) {
     const methodLogger = logger_util_js_1.Logger.forContext('tools/ipaddress.tool.ts', 'registerTools');
     methodLogger.debug(`Registering IP address tools...`);
-    server.tool('ip_get_details', `Retrieves detailed geolocation and network information for a public IP address (\`ipAddress\`). If no IP is provided, automatically uses the server's current public IP. Returns comprehensive location data including country, region, city, coordinates, timezone, and network details like ISP and organization. Use \`includeExtendedData\` to get additional information such as ASN, mobile/proxy detection (requires API token). **Note:** Cannot lookup private IPs (e.g., 192.168.x.x, 10.x.x.x). Powered by ip-api.com. Enable \`useHttps\` for secure connections (required for paid tier).`, GetIpDetailsToolSchema.shape, handleGetIpDetails);
+    // Use the modern registerTool API (SDK v1.22.0+)
+    // Following SDK best practices: title for UI display, description for details
+    server.registerTool('ip_get_details', {
+        title: 'IP Address Lookup',
+        description: IP_GET_DETAILS_DESCRIPTION,
+        inputSchema: GetIpDetailsToolSchema,
+    }, handleGetIpDetails);
     methodLogger.debug('Successfully registered ip_get_details tool.');
 }
 exports.default = { registerTools };

package/dist/tools/ipaddress.types.d.ts

@@ -1,17 +1,25 @@
 import { z } from 'zod';
+/**
+ * Output format options for API responses
+ * - toon: Token-Oriented Object Notation (default, more token-efficient for LLMs)
+ * - json: Standard JSON format
+ */
+export declare const OutputFormat: z.ZodOptional<z.ZodEnum<{
+    toon: "toon";
+    json: "json";
+}>>;
 /**
  * Zod schema for the IP address tool arguments.
  */
 export declare const IpAddressToolArgs: z.ZodObject<{
     includeExtendedData: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     useHttps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strict", z.ZodTypeAny, {
-    useHttps: boolean;
-    includeExtendedData: boolean;
-}, {
-    useHttps?: boolean | undefined;
-    includeExtendedData?: boolean | undefined;
-}>;
+    jq: z.ZodOptional<z.ZodString>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        toon: "toon";
+        json: "json";
+    }>>;
+}, z.core.$strict>;
 /**
  * TypeScript type inferred from the IpAddressToolArgs Zod schema.
  * This represents the optional arguments passed to the tool handler and controller.

package/dist/tools/ipaddress.types.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IpAddressToolArgs = void 0;
+exports.IpAddressToolArgs = exports.OutputFormat = void 0;
 const zod_1 = require("zod");
+/**
+ * Output format options for API responses
+ * - toon: Token-Oriented Object Notation (default, more token-efficient for LLMs)
+ * - json: Standard JSON format
+ */
+exports.OutputFormat = zod_1.z
+    .enum(['toon', 'json'])
+    .optional()
+    .describe('Output format: "toon" (default, 30-60% fewer tokens) or "json". TOON is optimized for LLMs with tabular arrays and minimal syntax.');
 /**
  * Zod schema for the IP address tool arguments.
  */
@@ -19,5 +28,10 @@ exports.IpAddressToolArgs = zod_1.z
         .optional()
         .default(true)
         .describe('Whether to use HTTPS for the API call (recommended).'),
+    jq: zod_1.z
+        .string()
+        .optional()
+        .describe('JMESPath expression to filter/transform the response. IMPORTANT: Always use this to extract only needed fields and reduce token costs. Examples: "{ip: query, country: country}" (extract specific fields), "lat" (single field). See https://jmespath.org'),
+    outputFormat: exports.OutputFormat,
 })
     .strict();

package/dist/utils/cli.test.util.d.ts

@@ -21,8 +21,14 @@ export declare class CliTestUtil {
      * Validates that stdout contains expected strings/patterns
      */
     static validateOutputContains(output: string, expectedPatterns: (string | RegExp)[]): void;
+    /**
+     * Validates TOON output format
+     * TOON uses "key: value" syntax for objects
+     */
+    static validateToonOutput(output: string): void;
     /**
      * Validates Markdown output format
+     * @deprecated Use validateToonOutput for new code - output is now TOON by default
      */
     static validateMarkdownOutput(output: string): void;
 }

package/dist/utils/cli.test.util.js

@@ -99,8 +99,28 @@ class CliTestUtil {
             }
         }
     }
+    /**
+     * Validates TOON output format
+     * TOON uses "key: value" syntax for objects
+     */
+    static validateToonOutput(output) {
+        // Filter out debug log lines for cleaner validation
+        const cleanOutput = output
+            .split('\n')
+            .filter((line) => !line.match(/^\[\d{2}:\d{2}:\d{2}\]/))
+            .join('\n');
+        // TOON format characteristics:
+        // - Key-value pairs in "key: value" format
+        // - No curly braces for objects
+        // - Arrays use [count]{fields}: notation
+        const toonPatterns = [
+            /^\w+:\s*.+/m, // key: value pattern
+        ];
+        expect(toonPatterns.some((pattern) => pattern.test(cleanOutput))).toBe(true);
+    }
     /**
      * Validates Markdown output format
+     * @deprecated Use validateToonOutput for new code - output is now TOON by default
      */
     static validateMarkdownOutput(output) {
         // Filter out debug log lines for cleaner validation

package/dist/utils/constants.util.d.ts

@@ -8,7 +8,7 @@
  * Current application version
  * This should match the version in package.json
  */
-export declare const VERSION = "1.14.0";
+export declare const VERSION = "1.16.0";
 /**
  * Package name with scope
  * Used for initialization and identification

package/dist/utils/constants.util.js

@@ -11,7 +11,7 @@ exports.CLI_NAME = exports.PACKAGE_NAME = exports.VERSION = void 0;
  * Current application version
  * This should match the version in package.json
  */
-exports.VERSION = '1.14.0';
+exports.VERSION = '1.16.0';
 /**
  * Package name with scope
  * Used for initialization and identification

package/dist/utils/jq.util.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Apply a JMESPath filter to JSON data
+ *
+ * @param data - The data to filter (any JSON-serializable value)
+ * @param filter - JMESPath expression to apply
+ * @returns Filtered data or original data if filter is empty/invalid
+ *
+ * @example
+ * // Get single field
+ * applyJqFilter(data, "name")
+ *
+ * // Get nested field
+ * applyJqFilter(data, "body.storage.value")
+ *
+ * // Get multiple fields as object
+ * applyJqFilter(data, "{id: id, title: title}")
+ *
+ * // Array operations
+ * applyJqFilter(data, "results[*].title")
+ */
+export declare function applyJqFilter(data: unknown, filter?: string): unknown;
+/**
+ * Convert data to JSON string for MCP response
+ *
+ * @param data - The data to stringify
+ * @param pretty - Whether to pretty-print the JSON (default: true)
+ * @returns JSON string
+ */
+export declare function toJsonString(data: unknown, pretty?: boolean): string;
+/**
+ * Convert data to output string for MCP response
+ *
+ * By default, converts to TOON format (Token-Oriented Object Notation)
+ * for improved LLM token efficiency (30-60% fewer tokens).
+ * Falls back to JSON if TOON conversion fails or if useToon is false.
+ *
+ * @param data - The data to convert
+ * @param useToon - Whether to use TOON format (default: true)
+ * @param pretty - Whether to pretty-print JSON (default: true)
+ * @returns TOON formatted string (default), or JSON string
+ */
+export declare function toOutputString(data: unknown, useToon?: boolean, pretty?: boolean): Promise<string>;

package/dist/utils/jq.util.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyJqFilter = applyJqFilter;
+exports.toJsonString = toJsonString;
+exports.toOutputString = toOutputString;
+const jmespath_1 = __importDefault(require("jmespath"));
+const logger_util_js_1 = require("./logger.util.js");
+const toon_util_js_1 = require("./toon.util.js");
+const logger = logger_util_js_1.Logger.forContext('utils/jq.util.ts');
+/**
+ * Apply a JMESPath filter to JSON data
+ *
+ * @param data - The data to filter (any JSON-serializable value)
+ * @param filter - JMESPath expression to apply
+ * @returns Filtered data or original data if filter is empty/invalid
+ *
+ * @example
+ * // Get single field
+ * applyJqFilter(data, "name")
+ *
+ * // Get nested field
+ * applyJqFilter(data, "body.storage.value")
+ *
+ * // Get multiple fields as object
+ * applyJqFilter(data, "{id: id, title: title}")
+ *
+ * // Array operations
+ * applyJqFilter(data, "results[*].title")
+ */
+function applyJqFilter(data, filter) {
+    const methodLogger = logger.forMethod('applyJqFilter');
+    // Return original data if no filter provided
+    if (!filter || filter.trim() === '') {
+        methodLogger.debug('No filter provided, returning original data');
+        return data;
+    }
+    try {
+        methodLogger.debug(`Applying JMESPath filter: ${filter}`);
+        const result = jmespath_1.default.search(data, filter);
+        methodLogger.debug('Filter applied successfully');
+        return result;
+    }
+    catch (error) {
+        methodLogger.error(`Invalid JMESPath expression: ${filter}`, error);
+        // Return original data with error info if filter is invalid
+        return {
+            _jqError: `Invalid JMESPath expression: ${filter}`,
+            _originalData: data,
+        };
+    }
+}
+/**
+ * Convert data to JSON string for MCP response
+ *
+ * @param data - The data to stringify
+ * @param pretty - Whether to pretty-print the JSON (default: true)
+ * @returns JSON string
+ */
+function toJsonString(data, pretty = true) {
+    if (pretty) {
+        return JSON.stringify(data, null, 2);
+    }
+    return JSON.stringify(data);
+}
+/**
+ * Convert data to output string for MCP response
+ *
+ * By default, converts to TOON format (Token-Oriented Object Notation)
+ * for improved LLM token efficiency (30-60% fewer tokens).
+ * Falls back to JSON if TOON conversion fails or if useToon is false.
+ *
+ * @param data - The data to convert
+ * @param useToon - Whether to use TOON format (default: true)
+ * @param pretty - Whether to pretty-print JSON (default: true)
+ * @returns TOON formatted string (default), or JSON string
+ */
+async function toOutputString(data, useToon = true, pretty = true) {
+    const jsonString = toJsonString(data, pretty);
+    // Return JSON directly if TOON is not requested
+    if (!useToon) {
+        return jsonString;
+    }
+    // Try TOON conversion with JSON fallback
+    return (0, toon_util_js_1.toToonOrJson)(data, jsonString);
+}

package/dist/utils/toon.util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Convert data to TOON format with JSON fallback.
+ *
+ * TOON (Token-Oriented Object Notation) is 30-60% more token-efficient than JSON
+ * for tabular data, making it ideal for LLM responses.
+ *
+ * @param data - The data to convert
+ * @param jsonFallback - JSON string to return if TOON encoding fails
+ * @returns TOON formatted string, or JSON fallback on failure
+ *
+ * @example
+ * const json = JSON.stringify(data, null, 2);
+ * const output = await toToonOrJson(data, json);
+ */
+export declare function toToonOrJson(data: unknown, jsonFallback: string): Promise<string>;

package/dist/utils/toon.util.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toToonOrJson = toToonOrJson;
+const logger_util_js_1 = require("./logger.util.js");
+const logger = logger_util_js_1.Logger.forContext('utils/toon.util.ts');
+/**
+ * Cached TOON encoder to avoid repeated dynamic imports
+ */
+let toonEncode = null;
+/**
+ * Dynamically loads the TOON encoder module.
+ * Uses dynamic import because @toon-format/toon is an ESM-only package.
+ *
+ * @returns Promise resolving to the encode function or null if loading fails
+ */
+async function loadToonEncoder() {
+    const methodLogger = logger.forMethod('loadToonEncoder');
+    // Return cached encoder if available
+    if (toonEncode) {
+        return toonEncode;
+    }
+    try {
+        methodLogger.debug('Loading TOON encoder module...');
+        // Dynamic import for ESM module in CommonJS project
+        const toon = await import('@toon-format/toon');
+        toonEncode = toon.encode;
+        methodLogger.debug('TOON encoder loaded successfully');
+        return toonEncode;
+    }
+    catch (error) {
+        methodLogger.error('Failed to load TOON encoder', error);
+        return null;
+    }
+}
+/**
+ * Convert data to TOON format with JSON fallback.
+ *
+ * TOON (Token-Oriented Object Notation) is 30-60% more token-efficient than JSON
+ * for tabular data, making it ideal for LLM responses.
+ *
+ * @param data - The data to convert
+ * @param jsonFallback - JSON string to return if TOON encoding fails
+ * @returns TOON formatted string, or JSON fallback on failure
+ *
+ * @example
+ * const json = JSON.stringify(data, null, 2);
+ * const output = await toToonOrJson(data, json);
+ */
+async function toToonOrJson(data, jsonFallback) {
+    const methodLogger = logger.forMethod('toToonOrJson');
+    try {
+        const encode = await loadToonEncoder();
+        if (!encode) {
+            methodLogger.debug('TOON encoder not available, using JSON fallback');
+            return jsonFallback;
+        }
+        const result = encode(data, { indent: 2 });
+        methodLogger.debug('Successfully converted to TOON format');
+        return result;
+    }
+    catch (error) {
+        methodLogger.error('TOON encoding failed, using JSON fallback', error);
+        return jsonFallback;
+    }
+}

package/dist/utils/transport.util.js

@@ -134,7 +134,6 @@ async function fetchApi(url, options = {}) {
         try {
             const responseData = await response.json();
             methodLogger.debug('Response body successfully parsed as JSON.');
-            // methodLogger.debug('Response Data:', responseData); // Uncomment for full response logging
             return responseData;
         }
         catch (parseError) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aashari/boilerplate-mcp-server",
-	"version": "1.14.0",
+	"version": "1.16.0",
 	"description": "TypeScript MCP server boilerplate with STDIO and HTTP transport support, CLI tools, and extensible architecture",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -51,35 +51,38 @@
 		"node": ">=18.0.0"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.35.0",
+		"@eslint/js": "^9.39.1",
 		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/exec": "^7.1.0",
 		"@semantic-release/git": "^10.0.1",
-		"@semantic-release/github": "^11.0.5",
-		"@semantic-release/npm": "^12.0.2",
+		"@semantic-release/github": "^12.0.2",
+		"@semantic-release/npm": "^13.1.2",
 		"@types/cors": "^2.8.19",
-		"@types/express": "^5.0.3",
+		"@types/express": "^5.0.5",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^24.3.1",
-		"@typescript-eslint/eslint-plugin": "^8.43.0",
-		"@typescript-eslint/parser": "^8.43.0",
-		"eslint": "^9.35.0",
+		"@types/jmespath": "^0.15.2",
+		"@types/node": "^24.10.1",
+		"@typescript-eslint/eslint-plugin": "^8.48.0",
+		"@typescript-eslint/parser": "^8.48.0",
+		"eslint": "^9.39.1",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-prettier": "^5.5.4",
-		"jest": "^30.1.3",
-		"prettier": "^3.6.2",
-		"semantic-release": "^24.2.7",
-		"ts-jest": "^29.4.1",
-		"typescript": "^5.9.2",
-		"typescript-eslint": "^8.43.0"
+		"jest": "^30.2.0",
+		"prettier": "^3.7.3",
+		"semantic-release": "^25.0.2",
+		"ts-jest": "^29.4.5",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.48.0"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.17.5",
-		"commander": "^14.0.0",
+		"@modelcontextprotocol/sdk": "^1.23.0",
+		"@toon-format/toon": "^2.0.1",
+		"commander": "^14.0.2",
 		"cors": "^2.8.5",
-		"dotenv": "^17.2.2",
+		"dotenv": "^17.2.3",
 		"express": "^5.1.0",
-		"zod": "^3.25.76"
+		"jmespath": "^0.16.0",
+		"zod": "^4.1.13"
 	},
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/",

package/package.json.bak

@@ -1,6 +1,6 @@
 {
 	"name": "@aashari/boilerplate-mcp-server",
-	"version": "1.13.5",
+	"version": "1.15.0",
 	"description": "TypeScript MCP server boilerplate with STDIO and HTTP transport support, CLI tools, and extensible architecture",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -51,35 +51,38 @@
 		"node": ">=18.0.0"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.35.0",
+		"@eslint/js": "^9.39.1",
 		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/exec": "^7.1.0",
 		"@semantic-release/git": "^10.0.1",
-		"@semantic-release/github": "^11.0.5",
-		"@semantic-release/npm": "^12.0.2",
+		"@semantic-release/github": "^12.0.2",
+		"@semantic-release/npm": "^13.1.2",
 		"@types/cors": "^2.8.19",
-		"@types/express": "^5.0.3",
+		"@types/express": "^5.0.5",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^24.3.1",
-		"@typescript-eslint/eslint-plugin": "^8.43.0",
-		"@typescript-eslint/parser": "^8.43.0",
-		"eslint": "^9.35.0",
+		"@types/jmespath": "^0.15.2",
+		"@types/node": "^24.10.1",
+		"@typescript-eslint/eslint-plugin": "^8.48.0",
+		"@typescript-eslint/parser": "^8.48.0",
+		"eslint": "^9.39.1",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-prettier": "^5.5.4",
-		"jest": "^30.1.3",
-		"prettier": "^3.6.2",
-		"semantic-release": "^24.2.7",
-		"ts-jest": "^29.4.1",
-		"typescript": "^5.9.2",
-		"typescript-eslint": "^8.43.0"
+		"jest": "^30.2.0",
+		"prettier": "^3.7.3",
+		"semantic-release": "^25.0.2",
+		"ts-jest": "^29.4.5",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.48.0"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.17.5",
-		"commander": "^14.0.0",
+		"@modelcontextprotocol/sdk": "^1.23.0",
+		"@toon-format/toon": "^2.0.1",
+		"commander": "^14.0.2",
 		"cors": "^2.8.5",
-		"dotenv": "^17.2.2",
+		"dotenv": "^17.2.3",
 		"express": "^5.1.0",
-		"zod": "^3.25.76"
+		"jmespath": "^0.16.0",
+		"zod": "^4.1.13"
 	},
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/",