tiny-stdio-mcp-server 0.1.13 → 0.1.15

package/README.md

@@ -14,7 +14,7 @@ npm install tiny-stdio-mcp-server
 import { createServer, defineSchema } from "tiny-stdio-mcp-server";
 
 const schema = defineSchema({
-  text: { type: "string", description: "Text to reverse" },
+  text: { type: "string", description: "Text to reverse" }
 });
 
 createServer({ name: "my-server", version: "1.0.0" })
@@ -49,7 +49,7 @@ Register a tool. The handler receives typed args matching the schema and returns
 ```ts
 const schema = defineSchema({
   query: { type: "string", description: "Search query" },
-  limit: { type: "number", description: "Max results", optional: true },
+  limit: { type: "number", description: "Max results", optional: true }
 });
 
 server.tool("search", "Search for things", schema, async ({ query, limit }) => {
@@ -62,7 +62,7 @@ For structured-data tools, pass a root-object output schema. The server advertis
 
 ```ts
 const input = defineSchema({
-  query: { type: "string" },
+  query: { type: "string" }
 });
 const output = defineSchema({
   items: {
@@ -71,16 +71,22 @@ const output = defineSchema({
       type: "object",
       properties: {
         title: { type: "string" },
-        score: { type: "number" },
+        score: { type: "number" }
       },
-      required: ["title", "score"],
-    },
-  },
+      required: ["title", "score"]
+    }
+  }
 });
 
-server.tool("search", "Search", input, async ({ query }) => ({
-  items: [{ title: query, score: 1 }],
-}), output);
+server.tool(
+  "search",
+  "Search",
+  input,
+  async ({ query }) => ({
+    items: [{ title: query, score: 1 }]
+  }),
+  output
+);
 ```
 
 Output schemas must have `type: "object"` at the root. Tools whose natural result is prose, images, audio, files, or other content blocks should omit `outputSchema` and keep returning content.
@@ -113,6 +119,12 @@ await server.connectSDK(sdkTransport);
 
 Dynamically add/remove tools at runtime and notify connected clients.
 
+## Configuration Options
+
+- `createServer({ name, version })`: server identity sent during MCP initialization.
+- `.tool(name, description, schema, handler, outputSchema?)`: tool metadata, input schema, handler, and optional structured output schema.
+- `.connect({ readable, writable })`: custom stream transport for tests or embedded hosts.
+
 ## `defineSchema(definition)`
 
 Type-safe schema builder. Returns a JSON Schema object with inferred TypeScript types.
@@ -120,11 +132,15 @@ Type-safe schema builder. Returns a JSON Schema object with inferred TypeScript
 ```ts
 const schema = defineSchema({
   name: { type: "string", description: "User name" },
-  age: { type: "number", description: "User age", optional: true },
+  age: { type: "number", description: "User age", optional: true }
 });
 // Handler receives: { name: string; age?: number }
 ```
 
+## Environment Variables
+
+This package does not read public environment variables.
+
 Supported types: `string`, `number`, `boolean`, `object`, `array`.
 
 ## Content helpers
@@ -189,8 +205,12 @@ Use `createTestPair` with the official MCP SDK for in-memory testing:
 ```ts
 import { createTestPair } from "tiny-stdio-mcp-server/testing";
 
-const server = createServer({ name: "test", version: "1.0.0" })
-  .tool("ping", "Ping", defineSchema({}), () => "pong");
+const server = createServer({ name: "test", version: "1.0.0" }).tool(
+  "ping",
+  "Ping",
+  defineSchema({}),
+  () => "pong"
+);
 
 const { client, cleanup } = await createTestPair(server);
 

package/dist/jsonrpc.js

@@ -37,7 +37,8 @@ export function parseMessage(line) {
                 : null;
     if ("params" in obj
         && (typeof obj.params !== "object"
-            || obj.params === null)) {
+            || obj.params === null
+            || Array.isArray(obj.params))) {
         return {
             success: false,
             error: {

package/dist/server.js

@@ -292,7 +292,21 @@ export function createServer(options) {
             }) + "\n");
             return;
         }
-        const { result, error } = await messageHandler(request.method, request.params);
+        let handled;
+        try {
+            handled = await messageHandler(request.method, request.params);
+        }
+        catch {
+            if (!isNotification) {
+                const requestWithId = request;
+                write(formatErrorResponse(requestWithId.id, {
+                    code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+                    message: "Internal error",
+                }) + "\n");
+            }
+            return;
+        }
+        const { result, error } = handled;
         if (isNotification) {
             return;
         }
@@ -412,20 +426,17 @@ export function createServer(options) {
         },
         async connect(transport) {
             return new Promise((resolve) => {
-                const lifecycle = { initialized: false, initializeAccepted: false, notificationReady: false, resourceSubscriptions: new Set() };
-                const messageHandler = (method, params) => handleMessageWithLifecycle(method, lifecycle, params);
-                messageLifecycles.add(lifecycle);
                 const listener = (notification) => {
                     transport.writable.write(`${JSON.stringify(notification)}\n`);
                 };
-                connectionNotificationListeners.set(listener, lifecycle);
+                const session = server.createMessageSession(listener);
                 const rl = readline.createInterface({
                     input: transport.readable,
                     crlfDelay: Infinity,
                 });
                 const pendingMessages = new Set();
                 rl.on("line", (line) => {
-                    const message = processLine(line, (data) => transport.writable.write(data), messageHandler);
+                    const message = processLine(line, (data) => transport.writable.write(data), session.handleMessage);
                     pendingMessages.add(message);
                     void message.finally(() => {
                         pendingMessages.delete(message);
@@ -433,19 +444,15 @@ export function createServer(options) {
                 });
                 rl.on("close", async () => {
                     await Promise.all([...pendingMessages]);
-                    connectionNotificationListeners.delete(listener);
-                    messageLifecycles.delete(lifecycle);
+                    session.close();
                     resolve();
                 });
             });
         },
         async connectSDK(transport) {
             return new Promise((resolve, reject) => {
-                const lifecycle = { initialized: false, initializeAccepted: false, notificationReady: false, resourceSubscriptions: new Set() };
-                const messageHandler = (method, params) => handleMessageWithLifecycle(method, lifecycle, params);
-                messageLifecycles.add(lifecycle);
                 const listener = (notification) => transport.send(notification);
-                connectionNotificationListeners.set(listener, lifecycle);
+                const session = server.createMessageSession(listener);
                 transport.onmessage = async (message) => {
                     // Ignore responses (we only handle requests/notifications)
                     if (!("method" in message)) {
@@ -456,7 +463,12 @@ export function createServer(options) {
                         if (message.method === "initialize") {
                             return;
                         }
-                        await messageHandler(message.method, message.params);
+                        try {
+                            await session.handleMessage(message.method, message.params);
+                        }
+                        catch {
+                            return;
+                        }
                         return;
                     }
                     if (message.method === "notifications/initialized") {
@@ -471,7 +483,22 @@ export function createServer(options) {
                         return;
                     }
                     const request = message;
-                    const { result, error } = await messageHandler(request.method, request.params);
+                    let handled;
+                    try {
+                        handled = await session.handleMessage(request.method, request.params);
+                    }
+                    catch {
+                        await transport.send({
+                            jsonrpc: "2.0",
+                            id: request.id,
+                            error: {
+                                code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+                                message: "Internal error",
+                            },
+                        });
+                        return;
+                    }
+                    const { result, error } = handled;
                     if (error) {
                         const response = {
                             jsonrpc: "2.0",
@@ -490,13 +517,11 @@ export function createServer(options) {
                     }
                 };
                 transport.onclose = () => {
-                    connectionNotificationListeners.delete(listener);
-                    messageLifecycles.delete(lifecycle);
+                    session.close();
                     resolve();
                 };
                 void transport.start().catch((error) => {
-                    connectionNotificationListeners.delete(listener);
-                    messageLifecycles.delete(lifecycle);
+                    session.close();
                     reject(error);
                 });
             });

package/package.json

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