tiny-stdio-mcp-server 0.1.17 → 0.1.19

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { createServer } from "./server.js";
-export type { MessageHandler, MessageSession, Server } from "./server.js";
+export type { CustomMethodHandler, MessageHandler, MessageSession, MessageSessionContext, Server } from "./server.js";
 export { defineSchema } from "./schema.js";
 export type { TypedSchema } from "./schema.js";
 export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, DEFAULT_FROM_URL_MAX_BYTES, } from "./content/index.js";

package/dist/server.d.ts

@@ -6,6 +6,7 @@ export interface Server {
     prompt(definition: Prompt, handler: PromptHandler): Server;
     resource(definition: Resource, handler: ResourceHandler): Server;
     resourceTemplate(definition: ResourceTemplate, handler: ResourceHandler): Server;
+    method(name: string, handler: CustomMethodHandler): Server;
     onNotification(listener: (notification: JSONRPCNotification) => void): () => void;
     removeTool(name: string): boolean;
     removePrompt(name: string): boolean;
@@ -21,6 +22,11 @@ export interface Server {
     connect(transport: Transport): Promise<void>;
     connectSDK(transport: SDKTransport): Promise<void>;
 }
+export interface MessageSessionContext {
+    readonly signal: AbortSignal;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+}
+export type CustomMethodHandler = (params: Record<string, unknown> | undefined, session: MessageSessionContext) => unknown | Promise<unknown>;
 export type MessageHandler = (method: string, params?: Record<string, unknown>) => Promise<HandleResult>;
 export interface MessageSession {
     handleMessage: MessageHandler;

package/dist/server.js

@@ -20,13 +20,15 @@ export function createServer(options) {
     const prompts = new Map();
     const resources = new Map();
     const resourceTemplates = new Map();
+    const methods = new Map();
     const notificationListeners = new Set();
     const connectionNotificationListeners = new Map();
     const defaultLifecycle = {
         initialized: false,
         initializeAccepted: false,
         notificationReady: false,
-        resourceSubscriptions: new Set()
+        resourceSubscriptions: new Set(),
+        abortController: new AbortController()
     };
     const messageLifecycles = new Set([defaultLifecycle]);
     const handleMessageWithLifecycle = async (method, lifecycle, params) => {
@@ -113,10 +115,11 @@ export function createServer(options) {
             }
             const tool = tools.get(toolName);
             if (!tool) {
+                const availableTools = [...tools.keys()].slice(0, 20);
                 return {
                     error: {
                         code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-                        message: `Tool not found: ${toolName}`
+                        message: `Tool not found: ${toolName}${availableTools.length === 0 ? "" : `. Available: ${availableTools.join(", ")}`}`
                     }
                 };
             }
@@ -269,6 +272,28 @@ export function createServer(options) {
             }
             return { result: {} };
         }
+        const customMethod = methods.get(method);
+        if (customMethod !== undefined) {
+            try {
+                const result = await customMethod(params, {
+                    signal: lifecycle.abortController.signal,
+                    async notify(notificationMethod, notificationParams) {
+                        if (!lifecycle.notificationReady || lifecycle.listener === undefined) {
+                            return;
+                        }
+                        await lifecycle.listener({
+                            jsonrpc: "2.0",
+                            method: notificationMethod,
+                            ...(notificationParams === undefined ? {} : { params: notificationParams })
+                        });
+                    }
+                });
+                return { result };
+            }
+            catch (error) {
+                return internalError(toErrorMessage(error));
+            }
+        }
         return {
             error: {
                 code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
@@ -281,7 +306,9 @@ export function createServer(options) {
             initialized: false,
             initializeAccepted: false,
             notificationReady: false,
-            resourceSubscriptions: new Set()
+            resourceSubscriptions: new Set(),
+            abortController: new AbortController(),
+            listener
         };
         messageLifecycles.add(lifecycle);
         if (listener !== undefined) {
@@ -290,6 +317,7 @@ export function createServer(options) {
         return {
             handleMessage: (method, params) => handleMessageWithLifecycle(method, lifecycle, params),
             close: () => {
+                lifecycle.abortController.abort();
                 if (listener !== undefined) {
                     connectionNotificationListeners.delete(listener);
                 }
@@ -360,6 +388,9 @@ export function createServer(options) {
     const server = {
         tool(name, description, inputSchema, handler, outputSchema) {
             assertNonEmptyName(name, "Tool name required");
+            if (tools.has(name)) {
+                throw new Error(`Tool already registered: ${name}`);
+            }
             const inputValidator = jsonSchemaValidator.compile(inputSchema);
             let outputValidator;
             if (outputSchema !== undefined) {
@@ -379,6 +410,9 @@ export function createServer(options) {
         },
         registerTool(definition, handler) {
             assertNonEmptyName(definition.name, "Tool name required");
+            if (tools.has(definition.name)) {
+                throw new Error(`Tool already registered: ${definition.name}`);
+            }
             const inputValidator = jsonSchemaValidator.compile(definition.inputSchema);
             let outputValidator;
             if (definition.outputSchema !== undefined) {
@@ -395,6 +429,9 @@ export function createServer(options) {
         },
         prompt(definition, handler) {
             assertNonEmptyName(definition.name, "Prompt name required");
+            if (prompts.has(definition.name)) {
+                throw new Error(`Prompt already registered: ${definition.name}`);
+            }
             prompts.set(definition.name, { ...definition, handler });
             return server;
         },
@@ -402,15 +439,26 @@ export function createServer(options) {
             if (!isValidUri(definition.uri)) {
                 throw new Error(`Invalid resource URI: ${definition.uri}`);
             }
+            if (resources.has(definition.uri)) {
+                throw new Error(`Resource already registered: ${definition.uri}`);
+            }
             resources.set(definition.uri, { ...definition, handler });
             return server;
         },
         resourceTemplate(definition, handler) {
             assertReadableUriTemplate(definition.uriTemplate);
             new UriTemplate(definition.uriTemplate);
+            if (resourceTemplates.has(definition.uriTemplate)) {
+                throw new Error(`Resource template already registered: ${definition.uriTemplate}`);
+            }
             resourceTemplates.set(definition.uriTemplate, { ...definition, handler });
             return server;
         },
+        method(name, handler) {
+            assertNonEmptyName(name, "Method name required");
+            methods.set(name, handler);
+            return server;
+        },
         onNotification(listener) {
             notificationListeners.add(listener);
             return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-stdio-mcp-server",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "bugs": {
     "url": "https://github.com/poe-platform/poe-code/issues"
   },