@mcpmesh/sdk 1.3.4 → 2.0.0-beta.1

package/dist/sse-stream.js

@@ -0,0 +1,173 @@
+/**
+ * SSE streaming helper for Express route handlers.
+ *
+ * Pipes any ``AsyncIterable<string>`` to an Express ``Response`` as
+ * ``text/event-stream``. Designed to be called from inside a ``mesh.route``
+ * handler — for example, to forward chunks from a remote streaming tool to
+ * a browser client via SSE.
+ *
+ * Wire format mirrors the Python ``mesh.route`` SSE adapter:
+ * - ``data: <chunk>\n\n`` per item
+ * - ``data: [DONE]\n\n`` terminator on normal completion
+ * - ``event: error\ndata: <json>\n\n`` on per-chunk error
+ *
+ * @example
+ * ```typescript
+ * import { mesh } from "@mcpmesh/sdk";
+ *
+ * app.post("/plan", mesh.route(["trip_planner"], async (req, res, { trip_planner }) => {
+ *   if (!trip_planner) return res.status(503).end();
+ *   await mesh.sseStream(res, trip_planner.stream(req.body));
+ * }));
+ * ```
+ */
+const SSE_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    // Disable nginx response buffering so chunks reach the browser immediately
+    "X-Accel-Buffering": "no",
+};
+/**
+ * Format a single chunk as SSE ``data:`` lines per spec.
+ *
+ * Each newline in the chunk becomes its own ``data:`` line; the record is
+ * terminated by a blank line. Empty chunks still emit a single ``data:``
+ * line so consumers see a heartbeat-style event (matches Python behavior).
+ */
+function frameChunkAsSSE(chunk) {
+    // splitlines() in Python splits on any line boundary; in JS we normalize
+    // CRLF to LF first then split on \n. An empty chunk still emits one frame.
+    const normalized = chunk.replace(/\r\n/g, "\n");
+    const lines = normalized === "" ? [""] : normalized.split("\n");
+    return lines.map((l) => `data: ${l}\n`).join("") + "\n";
+}
+/**
+ * Pipe an ``AsyncIterable<string>`` to an Express ``Response`` as SSE.
+ *
+ * Sets the standard SSE headers, writes one ``data: <chunk>\n\n`` frame per
+ * item from the iterable, and terminates with ``data: [DONE]\n\n``. On
+ * per-chunk error (e.g. the upstream stream throws), writes
+ * ``event: error\ndata: <json>\n\n`` and ends the response.
+ *
+ * Resolves when the response has been fully written. Callers do not need to
+ * call ``res.end()`` themselves.
+ *
+ * If the consumer disconnects mid-stream (``res.writableEnded``), iteration
+ * stops cleanly via the iterable's ``return()`` method (so the upstream
+ * proxy stream's ``finally`` block can release its underlying reader).
+ *
+ * @param res - Express response object
+ * @param source - Async iterable yielding strings
+ */
+export async function sseStream(res, source) {
+    // Set headers if not already sent. Use writeHead for a single atomic flush
+    // so the browser sees the full set immediately (some proxies buffer until
+    // headers arrive). If the caller already wrote headers we just continue.
+    if (!res.headersSent) {
+        for (const [k, v] of Object.entries(SSE_HEADERS)) {
+            res.setHeader(k, v);
+        }
+        // Some Express versions need an explicit flushHeaders() to commit before
+        // the first data frame; call it if available.
+        if (typeof res.flushHeaders === "function") {
+            res.flushHeaders();
+        }
+    }
+    // Track whether end() has been called so we never double-end (which would
+    // throw "ERR_STREAM_WRITE_AFTER_END" on Node). ``writable`` flips to false
+    // when further writes will fail (e.g. socket closed) but we still want to
+    // call res.end() exactly once for cleanup.
+    let endCalled = false;
+    let writable = true;
+    const safeEnd = () => {
+        if (endCalled)
+            return;
+        endCalled = true;
+        try {
+            res.end();
+        }
+        catch {
+            // ignore — response may already be torn down
+        }
+    };
+    const safeWrite = (data) => {
+        if (!writable)
+            return false;
+        if (res.writableEnded || res.destroyed) {
+            writable = false;
+            return false;
+        }
+        try {
+            return res.write(data);
+        }
+        catch {
+            writable = false;
+            return false;
+        }
+    };
+    const iterator = source[Symbol.asyncIterator]();
+    try {
+        while (true) {
+            const { value, done } = await iterator.next();
+            if (done)
+                break;
+            if (typeof value !== "string") {
+                // v1 supports str only — surface a structured error and stop
+                const errPayload = JSON.stringify({
+                    error: `sseStream: expected string chunk, got ${typeof value}`,
+                    type: "TypeError",
+                });
+                safeWrite(`event: error\ndata: ${errPayload}\n\n`);
+                safeEnd();
+                // best-effort cleanup of upstream
+                if (typeof iterator.return === "function") {
+                    try {
+                        await iterator.return();
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                return;
+            }
+            const wroteOk = safeWrite(frameChunkAsSSE(value));
+            if (!wroteOk) {
+                // Consumer disconnected (or write threw) — clean up upstream and end.
+                if (typeof iterator.return === "function") {
+                    try {
+                        await iterator.return();
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                safeEnd();
+                return;
+            }
+        }
+        safeWrite("data: [DONE]\n\n");
+        safeEnd();
+    }
+    catch (err) {
+        const errPayload = JSON.stringify({
+            error: err instanceof Error ? err.message : String(err),
+            type: err instanceof Error ? err.constructor.name : "Error",
+        });
+        safeWrite(`event: error\ndata: ${errPayload}\n\n`);
+        safeEnd();
+        // Release the upstream iterator if the failure originated outside the
+        // iterator itself (e.g. safeWrite threw). Without this, an upstream
+        // proxy.stream() generator's finally block — which cancels the
+        // OkHttp/fetch reader — never runs until GC, leaking the connection.
+        if (typeof iterator.return === "function") {
+            try {
+                await iterator.return();
+            }
+            catch {
+                /* upstream cleanup is best-effort */
+            }
+        }
+    }
+}
+//# sourceMappingURL=sse-stream.js.map

package/dist/sse-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-stream.js","sourceRoot":"","sources":["../src/sse-stream.ts"],"names":[],"mappings":"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"}

package/dist/tool-worker-entry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Worker entry for the mesh tool worker pool.
+ *
+ * Launched as a `worker_threads.Worker` from `tool-worker-pool.ts`. Each
+ * worker:
+ *
+ * 1. Resolves the user's `tsx` loader from THEIR node_modules (the Worker
+ *    `execArgv` does not propagate the parent process's tsx loader, so .ts
+ *    imports would otherwise throw `ERR_UNKNOWN_FILE_EXTENSION`).
+ * 2. Sets a worker-mode symbol on `globalThis` so the SDK skips main-thread
+ *    init (HTTP server, registry heartbeat, Rust core agent start) when the
+ *    user module imports `mesh()`.
+ * 3. Dynamic-imports the user module — this triggers `agent.addTool(...)` calls
+ *    which the SDK redirects into a worker-local tool map.
+ * 4. Reports `ready` to the parent.
+ * 5. Listens for `{kind: "call"}` messages, executes the tool with
+ *    reconstructed DI proxies + restored ALS scope, and replies with
+ *    `{kind: "result"}` or `{kind: "error"}`.
+ */
+export {};
+//# sourceMappingURL=tool-worker-entry.d.ts.map

package/dist/tool-worker-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-worker-entry.d.ts","sourceRoot":"","sources":["../src/tool-worker-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/tool-worker-entry.js

@@ -0,0 +1,162 @@
+/**
+ * Worker entry for the mesh tool worker pool.
+ *
+ * Launched as a `worker_threads.Worker` from `tool-worker-pool.ts`. Each
+ * worker:
+ *
+ * 1. Resolves the user's `tsx` loader from THEIR node_modules (the Worker
+ *    `execArgv` does not propagate the parent process's tsx loader, so .ts
+ *    imports would otherwise throw `ERR_UNKNOWN_FILE_EXTENSION`).
+ * 2. Sets a worker-mode symbol on `globalThis` so the SDK skips main-thread
+ *    init (HTTP server, registry heartbeat, Rust core agent start) when the
+ *    user module imports `mesh()`.
+ * 3. Dynamic-imports the user module — this triggers `agent.addTool(...)` calls
+ *    which the SDK redirects into a worker-local tool map.
+ * 4. Reports `ready` to the parent.
+ * 5. Listens for `{kind: "call"}` messages, executes the tool with
+ *    reconstructed DI proxies + restored ALS scope, and replies with
+ *    `{kind: "result"}` or `{kind: "error"}`.
+ */
+import { parentPort, workerData, isMainThread } from "node:worker_threads";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+if (isMainThread) {
+    throw new Error("tool-worker-entry.js must be loaded inside a worker thread");
+}
+if (!parentPort) {
+    throw new Error("tool-worker-entry.js requires a parent port");
+}
+const data = workerData;
+const userModulePath = data.userModulePath;
+const sdkEntryPath = data.sdkEntryPath;
+// Mark worker mode BEFORE importing the user module. The SDK checks this
+// symbol in MeshAgent.constructor / addTool to short-circuit main-thread
+// init and stash tool functions in a worker-local map instead.
+const WORKER_MODE_SYMBOL = Symbol.for("@mcpmesh/sdk/worker-mode");
+globalThis[WORKER_MODE_SYMBOL] = true;
+// User-facing in-worker flag. Distinct from the SDK-internal worker-mode flag
+// above. User code can check this to guard their own top-level side effects
+// (custom HTTP servers, OTel init, prometheus registries) that should not
+// run in worker threads. Exported as IN_WORKER_SYMBOL from the SDK index.
+globalThis[Symbol.for("@mcpmesh/sdk/in-worker")] = true;
+async function bootstrap() {
+    // 1. Register tsx loader for the worker if user runs .ts directly.
+    const isTs = userModulePath.endsWith(".ts") ||
+        userModulePath.endsWith(".mts") ||
+        userModulePath.endsWith(".cts") ||
+        userModulePath.endsWith(".tsx");
+    if (isTs) {
+        try {
+            const userRequire = createRequire(userModulePath);
+            const tsxApiPath = userRequire.resolve("tsx/esm/api");
+            const tsxApi = await import(pathToFileURL(tsxApiPath).href);
+            if (typeof tsxApi.register === "function") {
+                tsxApi.register();
+            }
+            else {
+                throw new Error("tsx/esm/api does not export register()");
+            }
+        }
+        catch (e) {
+            const msg = "MCP_MESH_TOOL_ISOLATION requires `tsx` in your dependencies when " +
+                "running .ts directly. Add `tsx` to package.json or set " +
+                "MCP_MESH_TOOL_ISOLATION=false to disable isolation.";
+            parentPort.postMessage({
+                kind: "fatal",
+                error: {
+                    name: "TsxResolutionError",
+                    message: msg,
+                    cause: String(e),
+                },
+            });
+            process.exit(1);
+            return;
+        }
+    }
+    // 2. Import the SDK first so the worker-mode flag takes effect before the
+    //    user's import of mesh() touches MeshAgent.constructor.
+    const sdk = await import(pathToFileURL(sdkEntryPath).href);
+    // 3. Import the user's module — fires addTool() calls.
+    await import(pathToFileURL(userModulePath).href);
+    // 4. Pull the tool map populated during user module init.
+    const tools = typeof sdk.__getWorkerToolMap === "function"
+        ? sdk.__getWorkerToolMap()
+        : new Map();
+    // 5. Get ALS helpers + proxy factory for per-call setup.
+    const { createProxy, runWithTraceContext, runWithPropagatedHeaders } = sdk;
+    parentPort.on("message", (msg) => {
+        handleMessage(msg, tools, createProxy, runWithTraceContext, runWithPropagatedHeaders);
+    });
+    parentPort.postMessage({ kind: "ready" });
+}
+function serializeError(err) {
+    if (!(err instanceof Error)) {
+        return { name: "Error", message: String(err) };
+    }
+    const out = { name: err.name, message: err.message, stack: err.stack };
+    const errAny = err;
+    if (errAny.code !== undefined)
+        out.code = errAny.code;
+    if (errAny.cause !== undefined)
+        out.cause = serializeError(errAny.cause);
+    return out;
+}
+function handleMessage(msg, tools, createProxy, runWithTraceContext, runWithPropagatedHeaders) {
+    if (!msg || typeof msg !== "object")
+        return;
+    const m = msg;
+    if (m.kind !== "call" || typeof m.id !== "number")
+        return;
+    const respond = (payload) => {
+        parentPort.postMessage({ id: m.id, ...payload });
+    };
+    const tool = tools.get(m.toolName);
+    if (!tool) {
+        respond({
+            kind: "error",
+            error: {
+                name: "ToolNotFound",
+                message: `Tool '${m.toolName}' not registered in worker`,
+            },
+        });
+        return;
+    }
+    // Reconstruct DI proxies — workers can't share the main-thread proxies, so
+    // each worker builds its own with its own undici Agent (Python parity).
+    const deps = m.depsConfig.map((cfg) => cfg === null
+        ? null
+        : createProxy(cfg.endpoint, cfg.capability, cfg.functionName, cfg.kwargs));
+    // Restore ALS scopes so user code sees the same trace context + headers as
+    // the main-thread caller, then invoke the tool. When traceContext is null,
+    // skip runWithTraceContext entirely so user's getCurrentTraceContext()
+    // returns null — matching the MCP_MESH_TOOL_ISOLATION=false legacy path.
+    const headers = m.propagatedHeaders ?? {};
+    const invokeUser = () => runWithPropagatedHeaders(headers, () => tool(m.cleanArgs, ...deps));
+    const wrapWithTrace = () => m.traceContext === null
+        ? invokeUser()
+        : runWithTraceContext(m.traceContext, invokeUser);
+    Promise.resolve()
+        .then(wrapWithTrace)
+        .then((value) => respond({ kind: "result", value }))
+        .catch((err) => {
+        respond({ kind: "error", error: serializeError(err) });
+    });
+}
+bootstrap().catch((e) => {
+    const err = e;
+    try {
+        parentPort.postMessage({
+            kind: "fatal",
+            error: {
+                name: err?.name ?? "Error",
+                message: err?.message ?? String(e),
+                stack: err?.stack,
+            },
+        });
+    }
+    catch {
+        // ignore
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=tool-worker-entry.js.map

package/dist/tool-worker-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-worker-entry.js","sourceRoot":"","sources":["../src/tool-worker-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,IAAI,YAAY,EAAE,CAAC;IACjB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;AAChF,CAAC;AACD,IAAI,CAAC,UAAU,EAAE,CAAC;IAChB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;AACjE,CAAC;AAQD,MAAM,IAAI,GAAG,UAAwB,CAAC;AACtC,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;AAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;AAEvC,yEAAyE;AACzE,yEAAyE;AACzE,+DAA+D;AAC/D,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AACjE,UAAiD,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;AAE9E,8EAA8E;AAC9E,4EAA4E;AAC5E,0EAA0E;AAC1E,0EAA0E;AACzE,UAAkB,CAAC,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC,GAAG,IAAI,CAAC;AAEjE,KAAK,UAAU,SAAS;IACtB,mEAAmE;IACnE,MAAM,IAAI,GACR,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC;QAC9B,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC/B,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC/B,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,IAAI,EAAE,CAAC;QACT,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;YAClD,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;YACtD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5D,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;gBAC1C,MAAM,CAAC,QAAQ,EAAE,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;YAC5D,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,GAAG,GACP,mEAAmE;gBACnE,yDAAyD;gBACzD,qDAAqD,CAAC;YACxD,UAAW,CAAC,WAAW,CAAC;gBACtB,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE;oBACL,IAAI,EAAE,oBAAoB;oBAC1B,OAAO,EAAE,GAAG;oBACZ,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;iBACjB;aACF,CAAC,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAChB,OAAO;QACT,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,4DAA4D;IAC5D,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC;IAE3D,uDAAuD;IACvD,MAAM,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC;IAEjD,0DAA0D;IAC1D,MAAM,KAAK,GACT,OAAO,GAAG,CAAC,kBAAkB,KAAK,UAAU;QAC1C,CAAC,CAAC,GAAG,CAAC,kBAAkB,EAAE;QAC1B,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC;IAEhB,yDAAyD;IACzD,MAAM,EAAE,WAAW,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,GAAG,GAAG,CAAC;IAE3E,UAAW,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,GAAY,EAAE,EAAE;QACzC,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,wBAAwB,CAAC,CAAC;IACxF,CAAC,CAAC,CAAC;IAEH,UAAW,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAC7C,CAAC;AAUD,SAAS,cAAc,CAAC,GAAY;IAClC,IAAI,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;IACjD,CAAC;IACD,MAAM,GAAG,GAAoB,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC;IACxF,MAAM,MAAM,GAAG,GAA0D,CAAC;IAC1E,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS;QAAE,GAAG,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACtD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS;QAAE,GAAG,CAAC,KAAK,GAAG,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACzE,OAAO,GAAG,CAAC;AACb,CAAC;AAiBD,SAAS,aAAa,CACpB,GAAY,EACZ,KAAmD,EACnD,WAKY,EACZ,mBAAkF,EAClF,wBAA0G;IAE1G,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO;IAC5C,MAAM,CAAC,GAAG,GAAkB,CAAC;IAC7B,IAAI,CAAC,CAAC,IAAI,KAAK,MAAM,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ;QAAE,OAAO;IAE1D,MAAM,OAAO,GAAG,CAAC,OAAgC,EAAE,EAAE;QACnD,UAAW,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC;IAEF,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACnC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO,CAAC;YACN,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACL,IAAI,EAAE,cAAc;gBACpB,OAAO,EAAE,SAAS,CAAC,CAAC,QAAQ,4BAA4B;aACzD;SACF,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IAED,2EAA2E;IAC3E,wEAAwE;IACxE,MAAM,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACpC,GAAG,KAAK,IAAI;QACV,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAC5E,CAAC;IAEF,2EAA2E;IAC3E,2EAA2E;IAC3E,uEAAuE;IACvE,yEAAyE;IACzE,MAAM,OAAO,GAAG,CAAC,CAAC,iBAAiB,IAAI,EAAE,CAAC;IAE1C,MAAM,UAAU,GAAG,GAAG,EAAE,CACtB,wBAAwB,CAAC,OAAO,EAAE,GAAG,EAAE,CACpC,IAAwC,CAAC,CAAC,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,CAChE,CAAC;IAEJ,MAAM,aAAa,GAAG,GAAG,EAAE,CACzB,CAAC,CAAC,YAAY,KAAK,IAAI;QACrB,CAAC,CAAC,UAAU,EAAE;QACd,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IAEtD,OAAO,CAAC,OAAO,EAAE;SACd,IAAI,CAAC,aAAa,CAAC;SACnB,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;SACnD,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;QACtB,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAU,EAAE,EAAE;IAC/B,MAAM,GAAG,GAAG,CAAU,CAAC;IACvB,IAAI,CAAC;QACH,UAAW,CAAC,WAAW,CAAC;YACtB,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACL,IAAI,EAAE,GAAG,EAAE,IAAI,IAAI,OAAO;gBAC1B,OAAO,EAAE,GAAG,EAAE,OAAO,IAAI,MAAM,CAAC,CAAC,CAAC;gBAClC,KAAK,EAAE,GAAG,EAAE,KAAK;aAClB;SACF,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,SAAS;IACX,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/tool-worker-pool.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Tool worker pool for isolating user tool execution from the main event loop.
+ *
+ * Mirrors the Python `_mcp_mesh.shared.tool_executor` design: spawn N worker
+ * threads (V8 isolates here, since Node has no GIL/asyncio split), each with
+ * its own event loop and undici connection pool, and dispatch tool calls
+ * round-robin across them. A user's blocking call (`execFileSync`, CPU spin,
+ * etc.) blocks one worker thread, NOT the main thread that serves
+ * /health, /ready, FastMCP HTTP, and registry heartbeats.
+ *
+ * Pool size:
+ *   Default `min(8, max(2, os.availableParallelism() ?? 2))`.
+ *   Override via `MCP_MESH_TOOL_WORKERS=<N>`.
+ *
+ * The pool is created lazily on first dispatch (matches Python parity) and
+ * cached for the process lifetime. Workers that crash are respawned on the
+ * next dispatch.
+ */
+export interface DepConfig {
+    endpoint: string;
+    capability: string;
+    functionName: string;
+    kwargs: Record<string, unknown>;
+}
+export interface DispatchPayload {
+    toolName: string;
+    cleanArgs: unknown;
+    depsConfig: (DepConfig | null)[];
+    traceContext: unknown;
+    propagatedHeaders: Record<string, string>;
+}
+/**
+ * Dispatch a tool call to a worker.
+ *
+ * Round-robin selects a worker, awaits its readiness (first call only),
+ * sends the payload, and resolves with the worker's `{result}` or rejects
+ * with its `{error}`. Worker crashes propagate as a rejection.
+ */
+export declare function dispatch(payload: DispatchPayload): Promise<unknown>;
+/**
+ * Drain in-flight calls (up to deadlineMs), then forcefully terminate all
+ * workers. Calls still pending after the deadline are rejected with a
+ * descriptive error.
+ *
+ * Called automatically on `process.exit`; can be invoked explicitly during
+ * shutdown if you want to await completion.
+ */
+export declare function closePool(deadlineMs?: number): Promise<void>;
+//# sourceMappingURL=tool-worker-pool.d.ts.map

package/dist/tool-worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-worker-pool.d.ts","sourceRoot":"","sources":["../src/tool-worker-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAQH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC;IACjC,YAAY,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AA4MD;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAiCzE;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,UAAU,SAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BhE"}