toolcraft 0.0.198 → 0.0.199

package/composition.json

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

package/dist/composition.json

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

package/node_modules/tiny-http-mcp-server/README.md

@@ -436,7 +436,7 @@ Returned `HttpServer` instances support:
 | `maxStreamBufferBytes`   | `number`                                     | `1048576`                        | End a GET SSE stream before a live write when its buffered bytes exceed this limit.           |
 | `maxSseEventHistory`     | `number`                                     | `100`                            | Number of server-sent events retained for `Last-Event-ID` replay.                             |
 | `sseKeepAliveMs`         | `number`                                     | `30000`                          | GET SSE keepalive interval in milliseconds. Set to `0` to disable keepalive comments.         |
-| `maxConcurrentToolCalls` | `number`                                     | unlimited                        | Maximum concurrent tool calls across sessions.                                                |
+| `maxConcurrentToolCalls` | `number`                                     | `4`                              | Maximum concurrent tool calls across sessions.                                                |
 | `sessionStore`           | `SessionStore`                               | in-memory store                  | Pluggable session-record storage; SSE streams and replay history remain instance-local.       |
 | `requestIdGenerator`     | `() => string`                               | incrementing ids                 | Generates request ids when `X-Request-Id` is absent.                                          |
 | `observability`          | `HttpObservabilityOptions`                   | none                             | Emits request, auth, session, stream, and tool lifecycle events.                              |
@@ -622,7 +622,7 @@ tiny-http-mcp-server [options]
 | `--max-stream-buffer-bytes <bytes>`          | `1048576`    | End a GET SSE stream before a live notification or keepalive write when buffered bytes exceed this limit.                            |
 | `--max-sse-event-history <count>`            | `100`        | Number of SSE events retained for `Last-Event-ID` replay.                                                                            |
 | `--sse-keep-alive-ms <ms>`                   | `30000`      | GET SSE keepalive interval in milliseconds. Set to `0` to disable keepalive comments.                                                |
-| `--max-concurrent-tool-calls <count>`        | unlimited    | Maximum concurrent tool calls across sessions.                                                                                       |
+| `--max-concurrent-tool-calls <count>`        | `4`          | Maximum concurrent tool calls across sessions.                                                                                       |
 | `--trusted-proxy`                            | off          | Trust `X-Forwarded-Proto` and `X-Forwarded-Host` for metadata challenge URLs.                                                        |
 | `--request-timeout-ms <ms>`                  | Node default | Node HTTP request timeout.                                                                                                           |
 | `--headers-timeout-ms <ms>`                  | Node default | Node HTTP headers timeout.                                                                                                           |

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

@@ -44,7 +44,9 @@ const HELP_TEXT = [
     "  --sse-keep-alive-ms <ms>",
     "                        GET SSE keepalive interval (default: 30000; 0 disables)",
     "  --max-concurrent-tool-calls <count>",
-    "                        Maximum concurrent tool calls across sessions",
+    "                        Maximum concurrent tool calls across sessions (default: 4)",
+    "  --max-queued-tool-calls <count>",
+    "                        Maximum waiting tool calls (default: 64; 0 disables waiting)",
     "  --trusted-proxy        Trust X-Forwarded-Proto and X-Forwarded-Host",
     "  --request-timeout-ms <ms>",
     "                        Node HTTP request timeout",
@@ -201,6 +203,7 @@ function parseCliOptions(args) {
             "max-sse-event-history": { type: "string" },
             "sse-keep-alive-ms": { type: "string" },
             "max-concurrent-tool-calls": { type: "string" },
+            "max-queued-tool-calls": { type: "string" },
             "trusted-proxy": { type: "boolean" },
             "request-timeout-ms": { type: "string" },
             "headers-timeout-ms": { type: "string" },
@@ -227,6 +230,7 @@ function parseCliOptions(args) {
     const maxSseEventHistory = parseOptionalInteger(values["max-sse-event-history"], "--max-sse-event-history", 0);
     const sseKeepAliveMs = parseOptionalInteger(values["sse-keep-alive-ms"], "--sse-keep-alive-ms", 0);
     const maxConcurrentToolCalls = parseOptionalInteger(values["max-concurrent-tool-calls"], "--max-concurrent-tool-calls", 1);
+    const maxQueuedToolCalls = parseOptionalInteger(values["max-queued-tool-calls"], "--max-queued-tool-calls", 0);
     const requestTimeoutMs = parseOptionalInteger(values["request-timeout-ms"], "--request-timeout-ms", 0);
     const headersTimeoutMs = parseOptionalInteger(values["headers-timeout-ms"], "--headers-timeout-ms", 0);
     const keepAliveTimeoutMs = parseOptionalInteger(values["keep-alive-timeout-ms"], "--keep-alive-timeout-ms", 0);
@@ -257,6 +261,7 @@ function parseCliOptions(args) {
         ...(maxSseEventHistory === undefined ? {} : { maxSseEventHistory }),
         ...(sseKeepAliveMs === undefined ? {} : { sseKeepAliveMs }),
         ...(maxConcurrentToolCalls === undefined ? {} : { maxConcurrentToolCalls }),
+        ...(maxQueuedToolCalls === undefined ? {} : { maxQueuedToolCalls }),
         trustedProxy: values["trusted-proxy"] ?? false,
         ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
         ...(headersTimeoutMs === undefined ? {} : { headersTimeoutMs }),
@@ -412,6 +417,7 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
             ...(options.maxConcurrentToolCalls === undefined
                 ? {}
                 : { maxConcurrentToolCalls: options.maxConcurrentToolCalls }),
+            ...(options.maxQueuedToolCalls === undefined ? {} : { maxQueuedToolCalls: options.maxQueuedToolCalls }),
             ...(options.trustedProxy ? { trustedProxy: true } : {}),
             ...(oauth === undefined ? {} : { oauth })
         });

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "tiny-http-mcp-server",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "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.198",
+      "version": "0.0.199",
       "license": "MIT"
     }
   ]

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

@@ -4,6 +4,7 @@ import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
 import { parseMessage, formatSuccessResponse, formatErrorResponse } from "./jsonrpc.js";
 import { parseUriTemplate } from "./uri-template.js";
 import { toContentBlocks } from "./content/convert.js";
+import { ToolCallAdmission } from "./tool-call-admission.js";
 const PROTOCOL_VERSION = "2025-11-25";
 const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2025-03-26", "2025-06-18", PROTOCOL_VERSION]);
 function compileToolSchema(schema) {
@@ -20,6 +21,17 @@ export function createServer(options) {
         (!Number.isInteger(options.toolCallTimeoutMs) || options.toolCallTimeoutMs <= 0)) {
         throw new Error("toolCallTimeoutMs must be a positive integer.");
     }
+    const maxConcurrentToolCalls = options.maxConcurrentToolCalls ?? 4;
+    const maxQueuedToolCalls = options.maxQueuedToolCalls ?? 64;
+    for (const [name, value, minimum] of [
+        ["maxConcurrentToolCalls", maxConcurrentToolCalls, 1],
+        ["maxQueuedToolCalls", maxQueuedToolCalls, 0]
+    ]) {
+        if (!Number.isSafeInteger(value) || value < minimum) {
+            throw new Error(`${name} must be a safe integer greater than or equal to ${minimum}.`);
+        }
+    }
+    const toolAdmission = new ToolCallAdmission(maxConcurrentToolCalls, maxQueuedToolCalls);
     const supportNotifications = options.supportNotifications !== false;
     const supportResourceSubscriptions = options.supportResourceSubscriptions !== false;
     const tools = new Map();
@@ -142,17 +154,33 @@ export function createServer(options) {
             }
             try {
                 let handlerResult;
+                const admissionTimeout = options.toolCallTimeoutMs === undefined ? undefined : new AbortController();
+                const admissionSignal = AbortSignal.any([
+                    lifecycle.abortController.signal,
+                    ...(admissionTimeout === undefined ? [] : [admissionTimeout.signal])
+                ]);
+                const handlerPromise = (async () => {
+                    const release = await toolAdmission.acquire(admissionSignal);
+                    try {
+                        admissionSignal.throwIfAborted();
+                        return await tool.handler(toolArgs);
+                    }
+                    finally {
+                        release();
+                    }
+                })();
                 if (options.toolCallTimeoutMs === undefined) {
-                    handlerResult = await tool.handler(toolArgs);
+                    handlerResult = await handlerPromise;
                 }
                 else {
                     let timeout;
-                    const handlerPromise = Promise.resolve().then(() => tool.handler(toolArgs));
                     handlerResult = await Promise.race([
                         handlerPromise,
                         new Promise((_resolve, reject) => {
                             timeout = setTimeout(() => {
-                                reject(new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Tool call timed out: ${toolName}`));
+                                const error = new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Tool call timed out: ${toolName}`);
+                                admissionTimeout.abort(error);
+                                reject(error);
                             }, options.toolCallTimeoutMs);
                         })
                     ]).finally(() => {

package/node_modules/tiny-stdio-mcp-server/dist/tool-call-admission.d.ts

@@ -0,0 +1,9 @@
+export declare class ToolCallAdmission {
+    private readonly maximumActive;
+    private readonly maximumQueued;
+    private active;
+    private readonly waiting;
+    constructor(maximumActive: number, maximumQueued: number);
+    acquire(signal: AbortSignal): Promise<() => void>;
+    private release;
+}

package/node_modules/tiny-stdio-mcp-server/dist/tool-call-admission.js

@@ -0,0 +1,51 @@
+import { ToolError } from "./types.js";
+export class ToolCallAdmission {
+    maximumActive;
+    maximumQueued;
+    active = 0;
+    waiting = [];
+    constructor(maximumActive, maximumQueued) {
+        this.maximumActive = maximumActive;
+        this.maximumQueued = maximumQueued;
+    }
+    acquire(signal) {
+        signal.throwIfAborted();
+        if (this.active < this.maximumActive) {
+            this.active++;
+            return Promise.resolve(this.release());
+        }
+        if (this.waiting.length >= this.maximumQueued) {
+            throw new ToolError(-32000, "Too many queued tool calls");
+        }
+        return new Promise((resolve, reject) => {
+            const waiting = {
+                signal,
+                resolve,
+                abort: () => {
+                    const index = this.waiting.indexOf(waiting);
+                    if (index !== -1)
+                        this.waiting.splice(index, 1);
+                    reject(signal.reason);
+                }
+            };
+            this.waiting.push(waiting);
+            signal.addEventListener("abort", waiting.abort, { once: true });
+        });
+    }
+    release() {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = this.waiting.shift();
+            if (next === undefined) {
+                this.active--;
+            }
+            else {
+                next.signal.removeEventListener("abort", next.abort);
+                next.resolve(this.release());
+            }
+        };
+    }
+}

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

@@ -209,6 +209,10 @@ export interface ServerOptions {
     name: string;
     version: string;
     toolCallTimeoutMs?: number;
+    /** Shared active tool-handler capacity across sessions; defaults to four. */
+    maxConcurrentToolCalls?: number;
+    /** Maximum tool calls waiting for capacity; defaults to 64. Zero disables waiting. */
+    maxQueuedToolCalls?: number;
     validateToolArguments?: boolean;
     supportNotifications?: boolean;
     supportResourceSubscriptions?: boolean;

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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