modality-mcp-kit 0.2.0 → 0.3.0

package/dist/FastHonoMcp.js

@@ -0,0 +1,345 @@
+/**
+ * MCP Middleware for Hono Integration
+ *
+ * This middleware integrates the Model Context Protocol (MCP) into a Hono web server.
+ * It delegates all MCP protocol handling to FastMCP's built-in capabilities, avoiding
+ * any custom protocol implementation.
+ *
+ * Architecture:
+ * - Hono serves as the primary and only HTTP server (port 8800)
+ * - FastMCP handles all MCP protocol logic, schema conversion, and responses
+ * - Middleware acts as a simple proxy to FastMCP's stateless request handling
+ * - No manual JSON-RPC method handling - FastMCP does everything
+ *
+ * Key Principle:
+ * - Always reuse FastMCP's built-in functions
+ * - Never implement custom MCP protocol logic
+ * - Let FastMCP handle initialize, tools/list, tools/call, etc.
+ *
+ * Usage:
+ *   app.use('/mcp', mcpMiddleware);
+ *   app.use('/mcp/*', mcpMiddleware);
+ *
+ * https://github.com/modelcontextprotocol/modelcontextprotocol/tree/main/schema
+ * https://modelcontextprotocol.io/specification/2025-11-25/schema
+ */
+import { ModalityFastMCP } from "modality-mcp-kit";
+import { JSONRPCManager, getLoggerInstance, } from "modality-kit";
+import { sseNotification, sseError, SSE_HEADERS, createSSEStream, } from "./sse-wrapper.js";
+import { McpSessionManager } from "./McpSessionManager.js";
+// Initialize FastMCP instance for internal use (NO SERVER)
+export class FastHonoMcp extends ModalityFastMCP {
+    logger;
+    config;
+    sessions = new McpSessionManager();
+    currentSessionId = "";
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    /**
+     * Disconnect and cleanup a session
+     */
+    disconnect(sessionId) {
+        const targetSession = sessionId || this.currentSessionId;
+        const disconnected = this.sessions.disconnect(targetSession);
+        if (disconnected) {
+            this.logger?.info(`Session disconnected: ${targetSession}`);
+        }
+        return disconnected;
+    }
+    /**
+     * Ensure session exists, create if needed
+     */
+    ensureSession() {
+        if (!this.sessions.has(this.currentSessionId)) {
+            const session = this.sessions.create();
+            this.currentSessionId = session.id;
+            this.logger?.info(`Session connected: ${this.currentSessionId}`);
+        }
+        else {
+            this.sessions.touch(this.currentSessionId);
+        }
+    }
+    handler() {
+        return async (c, next) => {
+            this.logger =
+                this.logger || getLoggerInstance("HonoMcpMiddleware", "debug");
+            const url = new URL(c.req.url);
+            // Only handle MCP routes
+            if (!url.pathname.startsWith("/mcp")) {
+                return next();
+            }
+            try {
+                // Handle DELETE for session disconnect
+                if (c.req.method === "DELETE" && url.pathname === "/mcp") {
+                    const requestSessionId = c.req.header("mcp-session-id");
+                    // Validate session ID matches
+                    if (requestSessionId && requestSessionId !== this.currentSessionId) {
+                        return c.json({ error: "Session ID mismatch" }, 400);
+                    }
+                    const disconnected = this.disconnect(requestSessionId || this.currentSessionId);
+                    if (disconnected) {
+                        return c.body(null, 204);
+                    }
+                    return c.json({ error: "Session not found" }, 404);
+                }
+                // Handle main MCP endpoint
+                if (c.req.method === "POST" && url.pathname === "/mcp") {
+                    // Ensure session exists (creates new one if disconnected)
+                    this.ensureSession();
+                    const headers = {
+                        "mcp-session-id": this.currentSessionId,
+                    };
+                    const bodyText = await c.req.text();
+                    this.logger.info("MCP Middleware Received Body", { bodyText });
+                    // Handle notifications/initialized locally (no response needed for notifications)
+                    try {
+                        const requestData = JSON.parse(bodyText);
+                        if (requestData?.method === "notifications/initialized") {
+                            return c.text(sseNotification(), 200, {
+                                ...SSE_HEADERS,
+                                ...headers,
+                            });
+                        }
+                    }
+                    catch {
+                        // Not valid JSON, continue with normal processing
+                    }
+                    // Use streaming SSE response
+                    return createSSEStream(async (writer) => {
+                        const result = await createJsonRpcManager(this).validateMessage(bodyText);
+                        writer.send(result);
+                    }, headers);
+                }
+                return c.json({ error: "MCP endpoint not implemented" }, 501);
+            }
+            catch (error) {
+                this.logger.error("MCP Middleware Error", error);
+                const message = error instanceof Error ? error.message : "Internal error";
+                return c.text(sseError(null, -32603, message), 500, SSE_HEADERS);
+            }
+        };
+    }
+    initHono(app, path = "mcp") {
+        const middlewareHandler = this.handler();
+        app.use(`/${path}`, middlewareHandler);
+        app.use(`/${path}/*`, middlewareHandler);
+        return this;
+    }
+}
+class HonoJSONRPCManager extends JSONRPCManager {
+    async sendMessage(message) {
+        return message;
+    }
+}
+function createJsonRpcManager(middleware) {
+    const mcpTools = middleware.getTools();
+    const mcpPrompts = middleware.getPrompts();
+    const jsonrpc = new HonoJSONRPCManager();
+    jsonrpc.registerMethod("initialize", {
+        handler(params) {
+            // Validate required request parameters
+            if (!params.capabilities) {
+                throw new Error("Missing required parameter: capabilities");
+            }
+            if (!params.clientInfo) {
+                throw new Error("Missing required parameter: clientInfo");
+            }
+            if (!params.protocolVersion) {
+                throw new Error("Missing required parameter: protocolVersion");
+            }
+            // Return valid InitializeResult
+            return {
+                protocolVersion: "2025-11-25",
+                capabilities: {
+                    tools: { listChanged: true },
+                    ...(mcpPrompts.length > 0 && { prompts: { listChanged: true } }),
+                    completions: {},
+                    logging: {},
+                },
+                serverInfo: {
+                    name: middleware.config.name,
+                    version: middleware.config.version,
+                },
+            };
+        },
+    });
+    jsonrpc.registerMethod("tools/list", {
+        async handler() {
+            const { toJsonSchema } = await import("xsschema");
+            const tools = await Promise.all(mcpTools.map(async (tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: await toJsonSchema(tool.parameters), // Simplified for example
+            })));
+            return {
+                tools,
+            };
+        },
+    });
+    jsonrpc.registerMethod("tools/call", {
+        async handler(params) {
+            const { ERROR_METHOD_NOT_FOUND } = await import("modality-kit");
+            const { name, arguments: args } = params;
+            const tool = mcpTools.find((t) => t.name === name);
+            if (!tool) {
+                throw new ERROR_METHOD_NOT_FOUND(`Tool not found: ${name}`);
+            }
+            return {
+                content: [
+                    {
+                        text: await tool.execute(args),
+                        type: "text",
+                    },
+                ],
+            };
+        },
+    });
+    jsonrpc.registerMethod("prompts/list", {
+        async handler() {
+            const prompts = mcpPrompts.map((prompt) => ({
+                name: prompt.name,
+                ...(prompt.description && { description: prompt.description }),
+                ...(prompt.title && { title: prompt.title }),
+                ...(prompt.arguments && {
+                    arguments: prompt.arguments.map((arg) => ({
+                        name: arg.name,
+                        ...(arg.description && { description: arg.description }),
+                        ...(arg.required !== undefined && { required: arg.required }),
+                        ...(arg.title && { title: arg.title }),
+                        ...(arg.enum && { enum: Array.from(arg.enum) }),
+                    })),
+                }),
+            }));
+            return { prompts };
+        },
+    });
+    jsonrpc.registerMethod("prompts/get", {
+        async handler(params) {
+            const { ERROR_METHOD_NOT_FOUND } = await import("modality-kit");
+            const { name, arguments: args } = params;
+            const prompt = mcpPrompts.find((p) => p.name === name);
+            if (!prompt) {
+                throw new ERROR_METHOD_NOT_FOUND(`Prompt not found: ${name}`);
+            }
+            const text = await prompt.load(args || {});
+            return {
+                ...(prompt.description && { description: prompt.description }),
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+    jsonrpc.registerMethod("completion/complete", {
+        async handler(params) {
+            const { ref, argument } = params;
+            // Only handle prompt references
+            if (ref?.type !== "ref/prompt") {
+                return { completion: { values: [], total: 0 } };
+            }
+            const prompt = mcpPrompts.find((p) => p.name === ref.name);
+            if (!prompt || !prompt.arguments) {
+                return { completion: { values: [], total: 0 } };
+            }
+            const arg = prompt.arguments.find((a) => a.name === argument.name);
+            if (!arg || !arg.enum) {
+                return { completion: { values: [], total: 0 } };
+            }
+            const enumValues = Array.from(arg.enum);
+            const inputValue = (argument.value || "").trim().toLowerCase();
+            const completionLimit = prompt.completionLimit ?? 10;
+            // Empty input: return first N items
+            if (!inputValue) {
+                const limit = Math.min(completionLimit, enumValues.length);
+                return {
+                    completion: {
+                        values: enumValues.slice(0, limit),
+                        total: enumValues.length,
+                        hasMore: enumValues.length > limit,
+                    },
+                };
+            }
+            // Filter enum values by the partial input
+            const matchingValues = enumValues.filter((v) => v.toLowerCase().startsWith(inputValue));
+            return {
+                completion: {
+                    values: matchingValues.slice(0, 100),
+                    total: matchingValues.length,
+                    hasMore: matchingValues.length > 100,
+                },
+            };
+        },
+    });
+    // Notification - no response needed (return empty result)
+    jsonrpc.registerMethod("notifications/initialized", {
+        handler() {
+            return {};
+        },
+    });
+    // notifications/cancelled - client requests cancellation of in-flight request
+    jsonrpc.registerMethod("notifications/cancelled", {
+        handler(params) {
+            const { requestId, reason } = params;
+            middleware.logger.info(`Request cancelled: ${requestId}`, { reason });
+            // Note: Stateless HTTP cannot cancel in-flight requests
+            // This handler acknowledges the notification for spec compliance
+            return {};
+        },
+    });
+    // ping - keep-alive check per MCP spec
+    jsonrpc.registerMethod("ping", {
+        handler() {
+            return {};
+        },
+    });
+    // logging/setLevel - validate and return empty result per MCP spec
+    jsonrpc.registerMethod("logging/setLevel", {
+        handler(params) {
+            const VALID_LOG_LEVELS = [
+                "debug",
+                "info",
+                "notice",
+                "warning",
+                "error",
+                "critical",
+                "alert",
+                "emergency",
+            ];
+            // Map MCP log levels to modality logger levels
+            const LOG_LEVEL_MAP = {
+                debug: "debug",
+                info: "info",
+                notice: "info",
+                warning: "warn",
+                error: "error",
+                critical: "error",
+                alert: "error",
+                emergency: "error",
+            };
+            const { level } = params;
+            // Validate level parameter exists
+            if (!level) {
+                throw new Error("Missing required parameter: level");
+            }
+            // Validate level is a valid LoggingLevel
+            if (!VALID_LOG_LEVELS.includes(level)) {
+                throw new Error(`Invalid log level: ${level}. Must be one of: ${VALID_LOG_LEVELS.join(", ")}`);
+            }
+            // Map and apply log level to modality logger
+            const modalityLogLevel = LOG_LEVEL_MAP[level];
+            middleware.logger.setLogLevel(modalityLogLevel);
+            middleware.logger.info(`Log level set to: ${level}`);
+            // Return empty result per MCP spec
+            return {};
+        },
+    });
+    return jsonrpc;
+}

package/dist/McpSessionManager.js

@@ -0,0 +1,46 @@
+/**
+ * MCP Session Manager - Simple session lifecycle management
+ */
+export class McpSessionManager {
+    sessions = new Map();
+    /**
+     * Create a new session
+     */
+    create() {
+        const now = new Date();
+        const session = {
+            id: crypto.randomUUID(),
+            createdAt: now,
+            lastActivity: now,
+        };
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    /**
+     * Get session by ID
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Update last activity timestamp
+     */
+    touch(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastActivity = new Date();
+        }
+    }
+    /**
+     * Remove a session
+     */
+    disconnect(sessionId) {
+        return this.sessions.delete(sessionId);
+    }
+    /**
+     * Check if session exists
+     */
+    has(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+}

package/dist/index.js

@@ -1,2 +1,3 @@
 export { toJsonSchema } from "xsschema";
 export { setupAITools, ModalityFastMCP } from "./util_mcp_tools_converter";
+export { FastHonoMcp } from "./FastHonoMcp";

package/dist/sse-wrapper.js

@@ -0,0 +1,206 @@
+/**
+ * SSE (Server-Sent Events) Wrapper Utility
+ *
+ * Wraps JSON-RPC responses in SSE format as per MCP specification.
+ * SSE format:
+ *   event: message
+ *   id: <unique-id>
+ *   data: <json-rpc-response>
+ *
+ * Supports both single-response and streaming modes.
+ * Uses modality-kit for JSON-RPC types and error codes.
+ */
+// ============================================
+// SSE HEADERS
+// ============================================
+/**
+ * Standard SSE response headers for MCP
+ */
+export const SSE_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+};
+// ============================================
+// CORE SSE FUNCTIONS
+// ============================================
+/**
+ * Generate a unique ID for SSE messages
+ */
+function generateSSEId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 9);
+    return `${timestamp}_${random}`;
+}
+/**
+ * Wrap a JSON-RPC response in SSE format
+ */
+export function wrapSSE(jsonrpcResponse) {
+    return {
+        event: "message",
+        id: generateSSEId(),
+        data: jsonrpcResponse,
+    };
+}
+/**
+ * Format SSE message as text for transmission
+ */
+export function formatSSE(sseMessage) {
+    return `event: ${sseMessage.event}\nid: ${sseMessage.id}\ndata: ${JSON.stringify(sseMessage.data)}\n\n`;
+}
+/**
+ * Wrap and format JSON-RPC response in one step
+ */
+export function wrapAndFormatSSE(jsonrpcResponse) {
+    const sseMessage = wrapSSE(jsonrpcResponse);
+    return formatSSE(sseMessage);
+}
+// ============================================
+// CONVENIENCE SSE FORMATTERS
+// ============================================
+/**
+ * Create SSE-formatted success response
+ */
+export function sseSuccess(id, result = {}) {
+    return wrapAndFormatSSE({
+        jsonrpc: "2.0",
+        id,
+        result,
+    });
+}
+/**
+ * Create SSE-formatted error response
+ */
+export function sseError(id, code, message, data) {
+    return wrapAndFormatSSE({
+        jsonrpc: "2.0",
+        id,
+        error: { code, message, ...(data !== undefined && { data }) },
+    });
+}
+/**
+ * Create SSE-formatted notification response (id: null, empty result)
+ */
+export function sseNotification() {
+    return wrapAndFormatSSE({
+        jsonrpc: "2.0",
+        id: null,
+        result: {},
+    });
+}
+// ============================================
+// STREAMING SSE SUPPORT
+// ============================================
+/**
+ * SSE Stream writer for true streaming support
+ */
+export class SSEStreamWriter {
+    controller = null;
+    encoder = new TextEncoder();
+    closed = false;
+    /**
+     * Create a ReadableStream for SSE responses
+     */
+    createStream() {
+        return new ReadableStream({
+            start: (controller) => {
+                this.controller = controller;
+            },
+            cancel: () => {
+                this.closed = true;
+                this.controller = null;
+            },
+        });
+    }
+    /**
+     * Send a JSON-RPC response as SSE message
+     */
+    send(response) {
+        if (this.closed || !this.controller)
+            return;
+        const formatted = wrapAndFormatSSE(response);
+        this.controller.enqueue(this.encoder.encode(formatted));
+    }
+    /**
+     * Send a progress notification
+     */
+    sendProgress(progressToken, progress, total) {
+        if (this.closed || !this.controller)
+            return;
+        const notification = {
+            jsonrpc: "2.0",
+            id: null,
+            result: {
+                method: "notifications/progress",
+                params: {
+                    progressToken,
+                    progress,
+                    ...(total !== undefined && { total }),
+                },
+            },
+        };
+        const formatted = wrapAndFormatSSE(notification);
+        this.controller.enqueue(this.encoder.encode(formatted));
+    }
+    /**
+     * Send a keep-alive ping (SSE comment)
+     */
+    ping() {
+        if (this.closed || !this.controller)
+            return;
+        this.controller.enqueue(this.encoder.encode(": ping\n\n"));
+    }
+    /**
+     * Send raw SSE event
+     */
+    sendEvent(event, data, id) {
+        if (this.closed || !this.controller)
+            return;
+        const sseId = id || generateSSEId();
+        const formatted = `event: ${event}\nid: ${sseId}\ndata: ${JSON.stringify(data)}\n\n`;
+        this.controller.enqueue(this.encoder.encode(formatted));
+    }
+    /**
+     * Close the stream
+     */
+    close() {
+        if (this.closed || !this.controller)
+            return;
+        this.closed = true;
+        this.controller.close();
+        this.controller = null;
+    }
+    /**
+     * Check if stream is still open
+     */
+    get isOpen() {
+        return !this.closed && this.controller !== null;
+    }
+}
+/**
+ * Create a streaming SSE response
+ */
+export function createSSEStream(handler, headers) {
+    const writer = new SSEStreamWriter();
+    const stream = writer.createStream();
+    // Execute handler asynchronously
+    handler(writer)
+        .catch((error) => {
+        if (writer.isOpen) {
+            writer.send({
+                jsonrpc: "2.0",
+                id: null,
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : "Internal error",
+                },
+            });
+        }
+    })
+        .finally(() => {
+        writer.close();
+    });
+    return new Response(stream, {
+        headers: { ...SSE_HEADERS, ...headers },
+    });
+}

package/dist/types/FastHonoMcp.d.ts

@@ -0,0 +1,50 @@
+/**
+ * MCP Middleware for Hono Integration
+ *
+ * This middleware integrates the Model Context Protocol (MCP) into a Hono web server.
+ * It delegates all MCP protocol handling to FastMCP's built-in capabilities, avoiding
+ * any custom protocol implementation.
+ *
+ * Architecture:
+ * - Hono serves as the primary and only HTTP server (port 8800)
+ * - FastMCP handles all MCP protocol logic, schema conversion, and responses
+ * - Middleware acts as a simple proxy to FastMCP's stateless request handling
+ * - No manual JSON-RPC method handling - FastMCP does everything
+ *
+ * Key Principle:
+ * - Always reuse FastMCP's built-in functions
+ * - Never implement custom MCP protocol logic
+ * - Let FastMCP handle initialize, tools/list, tools/call, etc.
+ *
+ * Usage:
+ *   app.use('/mcp', mcpMiddleware);
+ *   app.use('/mcp/*', mcpMiddleware);
+ *
+ * https://github.com/modelcontextprotocol/modelcontextprotocol/tree/main/schema
+ * https://modelcontextprotocol.io/specification/2025-11-25/schema
+ */
+import type { MiddlewareHandler, Hono } from "hono";
+import { ModalityFastMCP } from "modality-mcp-kit";
+import { getLoggerInstance } from "modality-kit";
+import { McpSessionManager } from "./McpSessionManager.js";
+export interface FastHonoMcpConfig extends Record<string, unknown> {
+    name: string;
+    version: string;
+}
+export declare class FastHonoMcp extends ModalityFastMCP {
+    logger: ReturnType<typeof getLoggerInstance>;
+    config: FastHonoMcpConfig;
+    sessions: McpSessionManager;
+    private currentSessionId;
+    constructor(config: FastHonoMcpConfig);
+    /**
+     * Disconnect and cleanup a session
+     */
+    disconnect(sessionId?: string): boolean;
+    /**
+     * Ensure session exists, create if needed
+     */
+    private ensureSession;
+    handler(): MiddlewareHandler;
+    initHono(app: Hono, path?: string): this;
+}

package/dist/types/McpSessionManager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP Session Manager - Simple session lifecycle management
+ */
+export interface McpSession {
+    id: string;
+    createdAt: Date;
+    lastActivity: Date;
+}
+export declare class McpSessionManager {
+    private sessions;
+    /**
+     * Create a new session
+     */
+    create(): McpSession;
+    /**
+     * Get session by ID
+     */
+    get(sessionId: string): McpSession | undefined;
+    /**
+     * Update last activity timestamp
+     */
+    touch(sessionId: string): void;
+    /**
+     * Remove a session
+     */
+    disconnect(sessionId: string): boolean;
+    /**
+     * Check if session exists
+     */
+    has(sessionId: string): boolean;
+}

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export { toJsonSchema } from "xsschema";
 export { setupAITools, ModalityFastMCP } from "./util_mcp_tools_converter";
 export type { AITools, AITool, FastMCPTool, } from "./schemas/schemas_tool_config";
 export type { FastMCPCompatible, Prompt } from "./util_mcp_tools_converter";
+export { FastHonoMcp } from "./FastHonoMcp";

package/dist/types/sse-wrapper.d.ts

@@ -0,0 +1,91 @@
+/**
+ * SSE (Server-Sent Events) Wrapper Utility
+ *
+ * Wraps JSON-RPC responses in SSE format as per MCP specification.
+ * SSE format:
+ *   event: message
+ *   id: <unique-id>
+ *   data: <json-rpc-response>
+ *
+ * Supports both single-response and streaming modes.
+ * Uses modality-kit for JSON-RPC types and error codes.
+ */
+import type { JSONRPCResponse, JSONRPCId } from "modality-kit";
+interface SSEMessage {
+    event: string;
+    id: string;
+    data: unknown;
+}
+/**
+ * Standard SSE response headers for MCP
+ */
+export declare const SSE_HEADERS: {
+    readonly "Content-Type": "text/event-stream";
+    readonly "Cache-Control": "no-cache";
+    readonly Connection: "keep-alive";
+};
+/**
+ * Wrap a JSON-RPC response in SSE format
+ */
+export declare function wrapSSE(jsonrpcResponse: JSONRPCResponse): SSEMessage;
+/**
+ * Format SSE message as text for transmission
+ */
+export declare function formatSSE(sseMessage: SSEMessage): string;
+/**
+ * Wrap and format JSON-RPC response in one step
+ */
+export declare function wrapAndFormatSSE(jsonrpcResponse: JSONRPCResponse): string;
+/**
+ * Create SSE-formatted success response
+ */
+export declare function sseSuccess(id: JSONRPCId, result?: unknown): string;
+/**
+ * Create SSE-formatted error response
+ */
+export declare function sseError(id: JSONRPCId, code: number, message: string, data?: unknown): string;
+/**
+ * Create SSE-formatted notification response (id: null, empty result)
+ */
+export declare function sseNotification(): string;
+/**
+ * SSE Stream writer for true streaming support
+ */
+export declare class SSEStreamWriter {
+    private controller;
+    private encoder;
+    private closed;
+    /**
+     * Create a ReadableStream for SSE responses
+     */
+    createStream(): ReadableStream<Uint8Array>;
+    /**
+     * Send a JSON-RPC response as SSE message
+     */
+    send(response: JSONRPCResponse): void;
+    /**
+     * Send a progress notification
+     */
+    sendProgress(progressToken: string | number, progress: number, total?: number): void;
+    /**
+     * Send a keep-alive ping (SSE comment)
+     */
+    ping(): void;
+    /**
+     * Send raw SSE event
+     */
+    sendEvent(event: string, data: unknown, id?: string): void;
+    /**
+     * Close the stream
+     */
+    close(): void;
+    /**
+     * Check if stream is still open
+     */
+    get isOpen(): boolean;
+}
+/**
+ * Create a streaming SSE response
+ */
+export declare function createSSEStream(handler: (writer: SSEStreamWriter) => Promise<void>, headers?: Record<string, string>): Response;
+export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.0",
+  "version": "0.3.0",
   "name": "modality-mcp-kit",
   "repository": {
     "type": "git",
@@ -22,15 +22,18 @@
   "author": "Hill <hill@kimo.com>",
   "license": "ISC",
   "dependencies": {
-    "modality-kit": "^0.14.5",
+    "modality-kit": "^0.14.17",
     "xsschema": "0.3.5",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.25.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.3",
+    "@types/bun": "^1.3.5",
     "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "hono": "^4.11.2"
+  },
   "exports": {
     "types": "./dist/types/index.d.ts",
     "require": "./dist/index.js",
@@ -42,7 +45,7 @@
   "scripts": {
     "build": "bun tsc -p ./",
     "build:types": "echo 'Starting build validation...' && bun --version && echo 'Running TypeScript type checking...' && bun tsc --noEmit --strict && echo '✅ Build validation successful - no TypeScript errors found' || (echo '❌ Build failed' && exit 1)",
-    "test": "bun test",
+    "test": "bun build:types && bun test",
     "prepublishOnly": "npm run build && npm run test"
   },
   "files": ["package.json", "README.md", "dist"]