toolcraft 0.0.199 → 0.0.201

package/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.13",
+      "version": "0.1.15",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.199",
+      "version": "0.0.201",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.199",
+      "version": "0.0.201",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.13",
+      "version": "0.1.15",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.199",
+      "version": "0.0.201",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.199",
+      "version": "0.0.201",
       "license": "MIT"
     },
     {

package/node_modules/tiny-http-mcp-server/dist/composition.json

@@ -18,7 +18,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.13",
+      "version": "0.1.15",
       "license": "MIT"
     },
     {

package/node_modules/tiny-http-mcp-server/dist/http-transport.js

@@ -754,7 +754,7 @@ export class StreamableHttpTransport {
         const history = this.sseEventHistory.get(sessionId) ?? [];
         for (const event of history) {
             if (event.id > lastEventId && !res.writableEnded) {
-                res.write(formatSseEvent({ id: String(event.id), data: event.data }));
+                this.writeToLiveGetStream(res, formatSseEvent({ id: String(event.id), data: event.data }));
             }
         }
     }

package/node_modules/tiny-http-mcp-server/dist/parse-body.js

@@ -64,12 +64,19 @@ async function readStreamBody(req, maxBytes) {
     return Buffer.concat(chunks).toString("utf8");
 }
 async function readRawBody(req, preParsed, options) {
-    if (preParsed !== undefined) {
-        return preParsed;
-    }
     const reqWithBody = req;
-    if (reqWithBody.body !== undefined) {
-        return reqWithBody.body;
+    const body = preParsed !== undefined ? preParsed : reqWithBody.body;
+    if (body !== undefined) {
+        if (options.maxBytes !== undefined) {
+            const serialized = JSON.stringify(body);
+            if (serialized === undefined) {
+                throw new Error("Invalid Request");
+            }
+            if (Buffer.byteLength(serialized, "utf8") > options.maxBytes) {
+                throw new Error("Payload too large");
+            }
+        }
+        return body;
     }
     const raw = await readStreamBody(req, options.maxBytes);
     try {

package/node_modules/tiny-http-mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-http-mcp-server",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Minimal MCP server over HTTP built on tiny-stdio-mcp-server",
   "type": "module",
   "main": "dist/index.js",

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.199",
+      "version": "0.0.201",
       "license": "MIT"
     }
   ]

package/node_modules/tiny-stdio-mcp-server/dist/server.js

@@ -5,6 +5,7 @@ import { parseMessage, formatSuccessResponse, formatErrorResponse } from "./json
 import { parseUriTemplate } from "./uri-template.js";
 import { toContentBlocks } from "./content/convert.js";
 import { ToolCallAdmission } from "./tool-call-admission.js";
+import { StdioOutput } from "./stdio-output.js";
 const PROTOCOL_VERSION = "2025-11-25";
 const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2025-03-26", "2025-06-18", PROTOCOL_VERSION]);
 function compileToolSchema(schema) {
@@ -23,9 +24,13 @@ export function createServer(options) {
     }
     const maxConcurrentToolCalls = options.maxConcurrentToolCalls ?? 4;
     const maxQueuedToolCalls = options.maxQueuedToolCalls ?? 64;
+    const maxStdioOutputBytes = options.maxStdioOutputBytes ?? 1024 * 1024;
+    const maxPendingStdioMessages = options.maxPendingStdioMessages ?? 128;
     for (const [name, value, minimum] of [
         ["maxConcurrentToolCalls", maxConcurrentToolCalls, 1],
-        ["maxQueuedToolCalls", maxQueuedToolCalls, 0]
+        ["maxQueuedToolCalls", maxQueuedToolCalls, 0],
+        ["maxStdioOutputBytes", maxStdioOutputBytes, 1],
+        ["maxPendingStdioMessages", maxPendingStdioMessages, 1]
     ]) {
         if (!Number.isSafeInteger(value) || value < minimum) {
             throw new Error(`${name} must be a safe integer greater than or equal to ${minimum}.`);
@@ -361,7 +366,7 @@ export function createServer(options) {
     const processLine = async (line, write, messageHandler) => {
         const parsed = parseMessage(line);
         if (!parsed.success) {
-            write(formatErrorResponse(parsed.id, parsed.error) + "\n");
+            await write(formatErrorResponse(parsed.id, parsed.error) + "\n");
             return;
         }
         const { request, isNotification } = parsed;
@@ -370,7 +375,7 @@ export function createServer(options) {
         }
         if (!isNotification && request.method === "notifications/initialized") {
             const requestWithId = request;
-            write(formatErrorResponse(requestWithId.id, {
+            await write(formatErrorResponse(requestWithId.id, {
                 code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
                 message: "Invalid Request"
             }) + "\n");
@@ -383,7 +388,7 @@ export function createServer(options) {
         catch {
             if (!isNotification) {
                 const requestWithId = request;
-                write(formatErrorResponse(requestWithId.id, {
+                await write(formatErrorResponse(requestWithId.id, {
                     code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
                     message: "Internal error"
                 }) + "\n");
@@ -396,10 +401,10 @@ export function createServer(options) {
         }
         const requestWithId = request;
         if (error) {
-            write(formatErrorResponse(requestWithId.id, error) + "\n");
+            await write(formatErrorResponse(requestWithId.id, error) + "\n");
         }
         else if (result !== undefined) {
-            write(formatSuccessResponse(requestWithId.id, result) + "\n");
+            await write(formatSuccessResponse(requestWithId.id, result) + "\n");
         }
     };
     const broadcastNotification = async (method, params, canSend = () => true) => {
@@ -541,27 +546,58 @@ export function createServer(options) {
             });
         },
         async connect(transport) {
-            return new Promise((resolve) => {
-                const listener = (notification) => {
-                    transport.writable.write(`${JSON.stringify(notification)}\n`);
-                };
+            return new Promise((resolve, reject) => {
+                let inputClosed = false;
+                let settled = false;
+                const pendingMessages = new Set();
+                const output = new StdioOutput(transport.writable, maxStdioOutputBytes, fail, finish);
+                const listener = (notification) => output.write(`${JSON.stringify(notification)}\n`);
                 const session = server.createMessageSession(listener);
                 const rl = readline.createInterface({
                     input: transport.readable,
                     crlfDelay: Infinity
                 });
-                const pendingMessages = new Set();
+                function fail(error) {
+                    if (settled)
+                        return;
+                    settled = true;
+                    session.close();
+                    rl.close();
+                    transport.readable.pause();
+                    transport.readable.off("error", fail);
+                    output.abort(error);
+                    pendingMessages.clear();
+                    reject(error);
+                }
+                function finish() {
+                    if (settled || !inputClosed || pendingMessages.size > 0 || output.pending > 0)
+                        return;
+                    settled = true;
+                    session.close();
+                    transport.readable.off("error", fail);
+                    output.close();
+                    resolve();
+                }
+                transport.readable.on("error", fail);
+                rl.on("error", fail);
                 rl.on("line", (line) => {
-                    const message = processLine(line, (data) => transport.writable.write(data), session.handleMessage);
-                    pendingMessages.add(message);
-                    void message.finally(() => {
+                    if (settled)
+                        return;
+                    if (pendingMessages.size >= maxPendingStdioMessages) {
+                        fail(new Error("Stdio pending message limit exceeded"));
+                        return;
+                    }
+                    const message = processLine(line, data => output.write(data), session.handleMessage);
+                    if (!settled)
+                        pendingMessages.add(message);
+                    void message.then(() => {
                         pendingMessages.delete(message);
-                    });
+                        finish();
+                    }, fail);
                 });
-                rl.on("close", async () => {
-                    await Promise.all([...pendingMessages]);
-                    session.close();
-                    resolve();
+                rl.on("close", () => {
+                    inputClosed = true;
+                    finish();
                 });
             });
         },

package/node_modules/tiny-stdio-mcp-server/dist/stdio-output.d.ts

@@ -0,0 +1,24 @@
+/** One connection's admitted frames, including its submitted, unsettled write. */
+export declare class StdioOutput {
+    private readonly writable;
+    private readonly maxBytes;
+    private readonly onFailure;
+    private readonly onIdle;
+    private readonly queue;
+    private active;
+    private bytes;
+    private stopped;
+    private failure;
+    private awaitingError;
+    constructor(writable: NodeJS.WritableStream, maxBytes: number, onFailure: (error: unknown) => void, onIdle: () => void);
+    get pending(): number;
+    write(data: string): Promise<void>;
+    abort(error: unknown): void;
+    close(): void;
+    private pump;
+    private advance;
+    private readonly onDrain;
+    private readonly onError;
+    private readonly onClose;
+    private detach;
+}

package/node_modules/tiny-stdio-mcp-server/dist/stdio-output.js

@@ -0,0 +1,131 @@
+/** One connection's admitted frames, including its submitted, unsettled write. */
+export class StdioOutput {
+    writable;
+    maxBytes;
+    onFailure;
+    onIdle;
+    queue = [];
+    active;
+    bytes = 0;
+    stopped = false;
+    failure;
+    awaitingError = false;
+    constructor(writable, maxBytes, onFailure, onIdle) {
+        this.writable = writable;
+        this.maxBytes = maxBytes;
+        this.onFailure = onFailure;
+        this.onIdle = onIdle;
+        writable.on("drain", this.onDrain);
+        writable.on("error", this.onError);
+        writable.on("close", this.onClose);
+    }
+    get pending() { return this.queue.length + (this.active === undefined ? 0 : 1); }
+    write(data) {
+        if (this.stopped)
+            return Promise.reject(this.failure);
+        const bytes = Buffer.byteLength(data);
+        if (bytes > this.maxBytes - this.bytes) {
+            const error = new Error("Stdio output byte limit exceeded");
+            this.abort(error);
+            return Promise.reject(error);
+        }
+        this.bytes += bytes;
+        const promise = new Promise((resolve, reject) => {
+            this.queue.push({ data, bytes, resolve, reject });
+        });
+        this.pump();
+        return promise;
+    }
+    abort(error) {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.failure = error;
+            this.active?.frame.reject(error);
+            if (this.active?.completed)
+                this.active = undefined;
+            for (const frame of this.queue.splice(0))
+                frame.reject(error);
+            this.bytes = 0;
+            this.onFailure(error);
+        }
+        // A submitted write can still fail after connection settlement. Keep its
+        // observation until callback/error/close; never destroy a caller's stream.
+        if (this.active === undefined && !this.awaitingError)
+            this.detach();
+    }
+    close() {
+        this.stopped = true;
+        this.failure = new Error("Stdio output is closed");
+        this.detach();
+    }
+    pump() {
+        if (this.stopped || this.active !== undefined)
+            return;
+        const frame = this.queue.shift();
+        if (frame === undefined) {
+            this.onIdle();
+            return;
+        }
+        const active = { frame, completed: false, returned: false, drained: false, needsDrain: false };
+        this.active = active;
+        try {
+            const accepted = this.writable.write(frame.data, "utf8", (error) => {
+                if (error != null) {
+                    this.awaitingError = true;
+                    this.active = undefined;
+                    frame.reject(error);
+                    this.abort(error);
+                    return;
+                }
+                active.completed = true;
+                if (this.stopped) {
+                    this.active = undefined;
+                    this.detach();
+                }
+                else {
+                    this.advance();
+                }
+            });
+            active.returned = true;
+            active.needsDrain = !accepted;
+            this.advance();
+        }
+        catch (error) {
+            this.active = undefined;
+            frame.reject(error);
+            this.abort(error);
+        }
+    }
+    advance() {
+        const active = this.active;
+        if (this.stopped || active === undefined || !active.returned || !active.completed ||
+            (active.needsDrain && !active.drained))
+            return;
+        this.active = undefined;
+        this.bytes -= active.frame.bytes;
+        active.frame.resolve();
+        this.pump();
+    }
+    onDrain = () => {
+        if (this.active !== undefined)
+            this.active.drained = true;
+        this.advance();
+    };
+    onError = (error) => {
+        this.awaitingError = false;
+        this.abort(error);
+        this.active = undefined;
+        this.detach();
+    };
+    onClose = () => {
+        this.awaitingError = false;
+        this.abort(new Error("Stdio output closed before connection completion"));
+        this.active = undefined;
+        this.detach();
+    };
+    detach() {
+        this.writable.off("drain", this.onDrain);
+        this.writable.off("error", this.onError);
+        this.writable.off("close", this.onClose);
+    }
+}

package/node_modules/tiny-stdio-mcp-server/dist/types.d.ts

@@ -213,6 +213,10 @@ export interface ServerOptions {
     maxConcurrentToolCalls?: number;
     /** Maximum tool calls waiting for capacity; defaults to 64. Zero disables waiting. */
     maxQueuedToolCalls?: number;
+    /** Per-stdio-connection UTF-8 bytes queued or submitted but unsettled; defaults to 1 MiB. */
+    maxStdioOutputBytes?: number;
+    /** Per-stdio-connection messages awaiting handler/output settlement; defaults to 128. */
+    maxPendingStdioMessages?: number;
     validateToolArguments?: boolean;
     supportNotifications?: boolean;
     supportResourceSubscriptions?: boolean;

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.199",
+  "version": "0.0.201",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.199",
+  "version": "0.0.201",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -158,7 +158,7 @@
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.199",
+    "toolcraft-schema": "0.0.201",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",