poe-code 8.0.1 → 9.0.1

package/packages/safejs/dist/interp/host-bridge.js

@@ -29,18 +29,19 @@ export function readHostOperationPolicy(operation) {
     return hostOperationPolicies.get(operation);
 }
 export function wrapCallerInjectedBindings(bindings, options) {
+    options = { ...options, registerCapabilities: true };
     const state = { seen: new WeakMap() };
     const copied = Object.fromEntries(Object.entries(bindings).map(([name, value]) => [
         name,
         typeof value === "function"
-            ? wrapCallerInjectedFunction(name, value, options, state)
-            : copyHostValueToSandbox(value, [], { ...options, operation: name }, state, "<root>")
+            ? wrapCallerInjectedFunction(name, value, { ...options, capabilityPath: [name] }, state)
+            : copyHostValueToSandbox(value, [], { ...options, operation: name, capabilityPath: [name] }, state, "<root>")
     ]));
     options.budget.provisionDataUsage(measureSandboxData(Object.values(copied)));
     return copied;
 }
 function wrapCallerInjectedFunction(name, value, options, state) {
-    const existing = state.seen.get(value);
+    const existing = state.seen.get(value) ?? options.hostCalls?.nativeClosures.get(value);
     if (existing !== undefined)
         return existing;
     const bindingName = name === "default" && value.name.length > 0 ? value.name : name;
@@ -132,6 +133,12 @@ function wrapCallerInjectedFunction(name, value, options, state) {
         name: bindingName,
         properties: (closure) => {
             state.seen.set(value, closure);
+            if (options.registerCapabilities) {
+                options.hostCalls?.registerHostCapability(JSON.stringify([
+                    options.moduleId ?? "<bindings>",
+                    ...(options.capabilityPath ?? [bindingName])
+                ]), closure, value);
+            }
             return (copyFunctionProperties(callable, [], options, state, options.operation ?? bindingName) ?? {});
         }
     });
@@ -316,7 +323,7 @@ function isAbortReason(reason) {
             ("code" in reason && reason.code === "aborted")));
 }
 function copyHostResultToSandbox(result, stackFrames, options) {
-    const value = copyHostValueToSandbox(result, stackFrames, options, {
+    const value = copyHostValueToSandbox(result, stackFrames, { ...options, registerCapabilities: false }, {
         seen: new WeakMap()
     }, "<root>");
     options.budget.provisionDataUsage(measureSandboxData([value]));
@@ -603,7 +610,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
             if (!("value" in descriptor)) {
                 throw new TypeError(`Unsupported sandbox value at ${path}[${index}]: accessor property`);
             }
-            copy[index] = copyHostValueToSandbox(descriptor.value, stackFrames, options, state, `${path}[${index}]`);
+            copy[index] = copyHostValueToSandbox(descriptor.value, stackFrames, { ...options, capabilityPath: [...(options.capabilityPath ?? []), String(index)] }, state, `${path}[${index}]`);
         }
         return copy;
     }
@@ -616,7 +623,8 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
         state.seen.set(value, copy);
         budget.allocateCollectionEntries(value.size);
         for (const [key, entry] of value) {
-            copy.entries.set(copyHostValueToSandbox(key, stackFrames, options, state, `${path}.<key>`), copyHostValueToSandbox(entry, stackFrames, options, state, `${path}.<value>`));
+            const ordinal = copy.entries.size;
+            copy.entries.set(copyHostValueToSandbox(key, stackFrames, { ...options, capabilityPath: [...(options.capabilityPath ?? []), `key:${ordinal}`] }, state, `${path}.<key>`), copyHostValueToSandbox(entry, stackFrames, { ...options, capabilityPath: [...(options.capabilityPath ?? []), `value:${ordinal}`] }, state, `${path}.<value>`));
         }
         return copy;
     }
@@ -629,7 +637,10 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
         state.seen.set(value, copy);
         budget.allocateCollectionEntries(value.size);
         for (const entry of value) {
-            copy.values.add(copyHostValueToSandbox(entry, stackFrames, options, state, `${path}.<value>`));
+            copy.values.add(copyHostValueToSandbox(entry, stackFrames, {
+                ...options,
+                capabilityPath: [...(options.capabilityPath ?? []), String(copy.values.size)]
+            }, state, `${path}.<value>`));
         }
         return copy;
     }
@@ -653,7 +664,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
                 enumerable: true,
                 configurable: true,
                 writable: true,
-                value: copyHostValueToSandbox(descriptor.value, stackFrames, options, state, joinPath(path, key))
+                value: copyHostValueToSandbox(descriptor.value, stackFrames, { ...options, capabilityPath: [...(options.capabilityPath ?? []), key] }, state, joinPath(path, key))
             });
         }
         return copy;
@@ -725,7 +736,7 @@ function copyFunctionProperties(callable, stackFrames, options, state, path) {
         if (typeof descriptor.value !== "function") {
             continue;
         }
-        properties[key] = copyHostValueToSandbox(descriptor.value, stackFrames, options, state, joinPath(path, key));
+        properties[key] = copyHostValueToSandbox(descriptor.value, stackFrames, { ...options, capabilityPath: [...(options.capabilityPath ?? []), key] }, state, joinPath(path, key));
     }
     return Object.keys(properties).length > 0 ? properties : undefined;
 }

package/packages/safejs/dist/interp/host-call.d.ts

@@ -83,8 +83,10 @@ export declare class HostCallJournal {
     private retainedSize;
     private readonly outcomeSizes;
     private readonly capabilities;
+    private readonly requiredHostCapabilities;
     private readonly capabilityIds;
     readonly nativeClosures: WeakMap<object, SandboxClosure>;
+    private readonly hostSources;
     private readonly encodedOutcomes;
     private readonly callbackSizes;
     private readonly completedCallbackOwners;
@@ -110,6 +112,9 @@ export declare class HostCallJournal {
     snapshot(): HostCallRecord[];
     dispose(): void;
     registerCallbackFunction(record: HostCallRecord, id: number, closure: SandboxClosure, native: object): void;
+    registerHostCapability(path: string, closure: SandboxClosure, native: object): void;
+    rebindHostCapability(original: SandboxClosure, restored: SandboxClosure): void;
+    validateHostCapabilities(): void;
     waitForCapability(id: string): Promise<void>;
     trackCallbackCompletion(record: HostCallRecord, callbacks: readonly Promise<unknown>[]): void;
     recordCallback(record: HostCallRecord, id: number, args: SandboxValue[], step: number): string;

package/packages/safejs/dist/interp/host-call.js

@@ -36,8 +36,10 @@ export class HostCallJournal {
     retainedSize = 0;
     outcomeSizes = new Map();
     capabilities = new Map();
+    requiredHostCapabilities = new Set();
     capabilityIds = new WeakMap();
     nativeClosures = new WeakMap();
+    hostSources = new WeakMap();
     encodedOutcomes = new Map();
     callbackSizes = new Map();
     completedCallbackOwners = new Set();
@@ -55,7 +57,7 @@ export class HostCallJournal {
         this.budget = budget;
         this.recordedReplay = replay !== undefined;
         if (replay !== undefined) {
-            const replayRecords = restoreReplayCalls(replay, this.encodedOutcomes, this.callbackSizes);
+            const replayRecords = restoreReplayCalls(replay, this.encodedOutcomes, this.callbackSizes, this.requiredHostCapabilities);
             const restoredRunId = replayRecords[0]?.runId ?? records[0]?.runId ?? randomUUID();
             validateRestoredRecords(records, restoredRunId, sourceHash);
             for (const record of records) {
@@ -221,6 +223,34 @@ export class HostCallJournal {
             this.capabilityIds.set(closure, identity);
         this.nativeClosures.set(native, closure);
     }
+    registerHostCapability(path, closure, native) {
+        const identity = `host:${path}`;
+        const existing = this.capabilities.get(identity);
+        if (existing !== undefined && existing !== closure)
+            throw new TypeError(`Conflicting replay capability '${identity}'.`);
+        this.capabilities.set(identity, closure);
+        if (!this.capabilityIds.has(closure))
+            this.capabilityIds.set(closure, identity);
+        if (!this.nativeClosures.has(native))
+            this.nativeClosures.set(native, closure);
+        this.hostSources.set(closure, native);
+    }
+    rebindHostCapability(original, restored) {
+        const identity = this.capabilityIds.get(original);
+        const source = this.hostSources.get(original);
+        if (identity === undefined || source === undefined)
+            return;
+        this.capabilities.set(identity, restored);
+        this.capabilityIds.set(restored, identity);
+        this.nativeClosures.set(source, restored);
+        this.hostSources.set(restored, source);
+    }
+    validateHostCapabilities() {
+        for (const identity of this.requiredHostCapabilities) {
+            if (!this.capabilities.has(identity))
+                throw new UnresolvedReplayCapabilityError(identity);
+        }
+    }
     waitForCapability(id) {
         if (this.capabilities.has(id))
             return Promise.resolve();
@@ -338,7 +368,7 @@ function copyOutcome(outcome) {
         ? { status: "fulfilled", value: deepCopyToSandbox(outcome.value) }
         : { status: "rejected", reason: deepCopyToSandbox(outcome.reason) };
 }
-function restoreReplayCalls(input, encodedOutcomes, callbackSizes) {
+function restoreReplayCalls(input, encodedOutcomes, callbackSizes, requiredHostCapabilities = new Set()) {
     validateSnapshotData(input);
     if (input === null ||
         typeof input !== "object" ||
@@ -364,7 +394,22 @@ function restoreReplayCalls(input, encodedOutcomes, callbackSizes) {
             }));
         }
     }
-    const resolveCapability = (id) => capabilities.get(id);
+    const resolveCapability = (id) => {
+        if (!capabilities.has(id) && id.startsWith("host:")) {
+            const path = JSON.parse(id.slice(5));
+            if (!Array.isArray(path) ||
+                path.length < 2 ||
+                path.some((value) => typeof value !== "string"))
+                throw new TypeError("Invalid host capability identity.");
+            requiredHostCapabilities.add(id);
+            capabilities.set(id, createSandboxClosure({
+                call: () => {
+                    throw new TypeError("Host capability has not been reconstructed.");
+                }
+            }));
+        }
+        return capabilities.get(id);
+    };
     return input.calls.map((entry, index) => {
         if (entry === null || typeof entry !== "object" || Array.isArray(entry))
             throw new TypeError("Invalid replay call.");

package/packages/safejs/dist/interp/resources.d.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export type RunResources = {
+    signal: AbortSignal;
+    add(close: () => Promise<void>): void;
+};
+export declare const runResources: AsyncLocalStorage<RunResources>;
+export declare function withRunResources<Result>(signal: AbortSignal | undefined, execute: () => Promise<Result>): Promise<Result>;

package/packages/safejs/dist/interp/resources.js

@@ -0,0 +1,36 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export const runResources = new AsyncLocalStorage();
+export async function withRunResources(signal, execute) {
+    const controller = new AbortController();
+    const cancel = () => controller.abort(signal?.reason);
+    const cleanups = new Set();
+    const resources = {
+        signal: controller.signal,
+        add(close) {
+            cleanups.add(close);
+        }
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted)
+        cancel();
+    let result;
+    let failure;
+    let errors = [];
+    try {
+        result = await runResources.run(resources, execute);
+    }
+    catch (error) {
+        failure = { reason: error };
+    }
+    finally {
+        signal?.removeEventListener("abort", cancel);
+        controller.abort(new Error("SafeJS run finished."));
+        const outcomes = await Promise.allSettled([...cleanups].map((close) => Promise.resolve().then(close)));
+        errors = outcomes.flatMap((outcome) => (outcome.status === "rejected" ? [outcome.reason] : []));
+    }
+    if (failure !== undefined)
+        throw failure.reason;
+    if (errors.length > 0)
+        throw new AggregateError(errors, "SafeJS resource cleanup failed.");
+    return result;
+}

package/packages/safejs/dist/modules/mcp-transport.d.ts

@@ -0,0 +1,26 @@
+import { McpClient, type HttpTransportFetch, type StdioSpawn } from "../../../tiny-mcp-client/dist/index.js";
+export type McpServerConfig = {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+} | {
+    url: string;
+    headers?: Record<string, string>;
+};
+export type McpModuleOptions = {
+    servers: Record<string, McpServerConfig>;
+    requestTimeoutMs?: number;
+    closeTimeoutMs?: number;
+    maxToolPages?: number;
+    signal?: AbortSignal;
+    fetch?: HttpTransportFetch;
+    spawn?: StdioSpawn;
+};
+export type ManagedMcpConnection = {
+    ready: Promise<McpClient>;
+    close(): Promise<void>;
+};
+export declare function parseMcpConfig(source: string, directory: string): McpModuleOptions;
+export declare function normalizeMcpOptions(value: unknown, keys?: string[]): McpModuleOptions;
+export declare function connectMcpTransport(server: McpServerConfig, options: McpModuleOptions, signal?: AbortSignal): ManagedMcpConnection;

package/packages/safejs/dist/modules/mcp-transport.js

@@ -0,0 +1,259 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { HttpTransport, McpClient, StdioTransport } from "tiny-mcp-client";
+export function parseMcpConfig(source, directory) {
+    const parsed = JSON.parse(source);
+    const options = normalizeMcpOptions(parsed, [
+        "servers",
+        "requestTimeoutMs",
+        "closeTimeoutMs",
+        "maxToolPages"
+    ]);
+    for (const server of Object.values(options.servers)) {
+        if ("command" in server) {
+            server.cwd = path.resolve(directory, server.cwd ?? ".");
+            if (server.command.includes("/") || server.command.includes("\\")) {
+                server.command = path.resolve(directory, server.command);
+            }
+        }
+    }
+    return options;
+}
+export function normalizeMcpOptions(value, keys = [
+    "servers",
+    "requestTimeoutMs",
+    "closeTimeoutMs",
+    "maxToolPages",
+    "signal",
+    "fetch",
+    "spawn"
+]) {
+    const options = readRecord(value, "MCP options", keys);
+    const servers = readRecord(options.servers, "MCP servers");
+    const normalized = Object.create(null);
+    for (const [name, input] of Object.entries(servers)) {
+        if (name.length === 0 || name.trim() !== name)
+            throw new TypeError("MCP server names must be non-empty without surrounding whitespace.");
+        const server = readRecord(input, `MCP server ${name}`);
+        if (Object.hasOwn(server, "command")) {
+            readRecord(server, `MCP server ${name}`, ["command", "args", "cwd", "env"]);
+            const command = readText(server.command, "MCP command");
+            if (server.args !== undefined &&
+                (!Array.isArray(server.args) ||
+                    server.args.some((argument) => typeof argument !== "string")))
+                throw new TypeError("MCP args must be an array of strings.");
+            normalized[name] = {
+                command,
+                ...(server.args === undefined ? {} : { args: [...server.args] }),
+                ...(server.cwd === undefined ? {} : { cwd: readText(server.cwd, "MCP cwd") }),
+                env: readStrings(server.env ?? {}, "MCP environment")
+            };
+        }
+        else {
+            readRecord(server, `MCP server ${name}`, ["url", "headers"]);
+            const url = new URL(readText(server.url, "MCP URL"));
+            if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash)
+                throw new TypeError("MCP URL must use HTTP or HTTPS without credentials or a fragment.");
+            const headers = readStrings(server.headers ?? {}, "MCP headers");
+            new Headers(headers);
+            normalized[name] = { url: url.href, headers };
+        }
+    }
+    for (const name of ["fetch", "spawn"])
+        if (options[name] !== undefined && typeof options[name] !== "function")
+            throw new TypeError(`MCP ${name} must be a function.`);
+    if (options.signal !== undefined && !(options.signal instanceof AbortSignal))
+        throw new TypeError("MCP signal must be an AbortSignal.");
+    return {
+        servers: normalized,
+        requestTimeoutMs: readTimeout(options.requestTimeoutMs, 30_000),
+        closeTimeoutMs: readTimeout(options.closeTimeoutMs, 1_000),
+        maxToolPages: readTimeout(options.maxToolPages, 100),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+        ...(options.spawn === undefined ? {} : { spawn: options.spawn })
+    };
+}
+function readRecord(value, label, keys) {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value) ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        throw new TypeError(`${label} must be a plain object.`);
+    const result = Object.create(null);
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        if (!("value" in descriptor) || (keys !== undefined && !keys.includes(key)))
+            throw new TypeError(`${label} contains unsupported field ${key}.`);
+        result[key] = descriptor.value;
+    }
+    return result;
+}
+function readText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0"))
+        throw new TypeError(`${label} must be a non-empty string without NUL characters.`);
+    return value;
+}
+function readStrings(value, label) {
+    const entries = readRecord(value, label);
+    for (const [name, entry] of Object.entries(entries))
+        if (typeof entry !== "string" || name.includes("\0") || entry.includes("\0"))
+            throw new TypeError(`${label} must contain strings without NUL characters.`);
+    return entries;
+}
+function readTimeout(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value <= 0 ||
+        value > 2_147_483_647)
+        throw new TypeError("MCP timeouts must be positive 32-bit integers.");
+    return value;
+}
+export function connectMcpTransport(server, options, signal) {
+    signal?.throwIfAborted();
+    options.signal?.throwIfAborted();
+    const client = new McpClient({
+        clientInfo: { name: "safejs", version: "1" },
+        requestTimeoutMs: options.requestTimeoutMs
+    });
+    let child;
+    const activeRequests = new Set();
+    const transport = "command" in server
+        ? new StdioTransport({
+            ...server,
+            spawn(command, args, spawnOptions) {
+                child =
+                    options.spawn === undefined
+                        ? spawn(command, args, spawnOptions)
+                        : options.spawn(command, args, spawnOptions);
+                return child;
+            }
+        })
+        : new HttpTransport({
+            ...server,
+            async fetch(input, init) {
+                const controller = new AbortController();
+                activeRequests.add(controller);
+                const cancel = () => controller.abort(init?.signal?.reason);
+                init?.signal?.addEventListener("abort", cancel, { once: true });
+                if (init?.signal?.aborted)
+                    cancel();
+                const timeout = setTimeout(() => controller.abort(new Error("MCP HTTP request timed out.")), init?.method === "DELETE" ? options.closeTimeoutMs : options.requestTimeoutMs);
+                const finish = () => {
+                    clearTimeout(timeout);
+                    activeRequests.delete(controller);
+                    init?.signal?.removeEventListener("abort", cancel);
+                };
+                try {
+                    const response = await (options.fetch ?? fetch)(input, {
+                        ...init,
+                        signal: controller.signal,
+                        redirect: "error"
+                    });
+                    if (response.body === null) {
+                        finish();
+                        return response;
+                    }
+                    const reader = response.body.getReader();
+                    let stopReading;
+                    const release = () => {
+                        finish();
+                        if (stopReading !== undefined)
+                            controller.signal.removeEventListener("abort", stopReading);
+                    };
+                    const body = new ReadableStream({
+                        start(stream) {
+                            stopReading = () => {
+                                void reader.cancel(controller.signal.reason).catch(() => undefined);
+                                stream.error(controller.signal.reason);
+                                release();
+                            };
+                            controller.signal.addEventListener("abort", stopReading, { once: true });
+                            if (controller.signal.aborted)
+                                stopReading();
+                        },
+                        async pull(stream) {
+                            try {
+                                const result = await reader.read();
+                                if (controller.signal.aborted)
+                                    return;
+                                if (result.done) {
+                                    release();
+                                    stream.close();
+                                }
+                                else
+                                    stream.enqueue(result.value);
+                            }
+                            catch (error) {
+                                release();
+                                stream.error(error);
+                            }
+                        },
+                        async cancel(reason) {
+                            release();
+                            await reader.cancel(reason);
+                        }
+                    });
+                    return new Response(body, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: response.headers
+                    });
+                }
+                catch (error) {
+                    finish();
+                    throw error;
+                }
+            }
+        });
+    let closing;
+    const cancel = () => {
+        void close().catch(() => undefined);
+    };
+    function close() {
+        closing ??= (async () => {
+            signal?.removeEventListener("abort", cancel);
+            options.signal?.removeEventListener("abort", cancel);
+            for (const request of activeRequests)
+                request.abort(new Error("MCP connection closed."));
+            await client.close();
+            transport.dispose();
+            await new Promise((resolve, reject) => {
+                let forced;
+                const timeout = setTimeout(() => {
+                    if (child !== undefined && child.exitCode === null && child.signalCode === null)
+                        child.kill("SIGKILL");
+                    forced = setTimeout(() => reject(new Error("MCP transport did not close.")), options.closeTimeoutMs);
+                }, options.closeTimeoutMs);
+                void transport.closed.then(() => {
+                    clearTimeout(timeout);
+                    clearTimeout(forced);
+                    resolve();
+                }, (error) => {
+                    clearTimeout(timeout);
+                    clearTimeout(forced);
+                    reject(error);
+                });
+            });
+        })();
+        return closing;
+    }
+    signal?.addEventListener("abort", cancel, { once: true });
+    options.signal?.addEventListener("abort", cancel, { once: true });
+    const aborted = signal?.aborted || options.signal?.aborted;
+    if (aborted)
+        cancel();
+    const connecting = aborted
+        ? Promise.reject(signal?.aborted ? signal.reason : options.signal?.reason)
+        : client.connect(transport);
+    const ready = connecting.then(() => client, async (error) => {
+        await close().catch(() => undefined);
+        throw signal?.aborted
+            ? signal.reason
+            : options.signal?.aborted
+                ? options.signal.reason
+                : error;
+    });
+    return { ready, close };
+}

package/packages/safejs/dist/modules/mcp.d.ts

@@ -1,3 +1,4 @@
+import { type McpModuleOptions } from "./mcp-transport.js";
 export type McpModuleServerHandle = {
     command: string;
     args?: string[];
@@ -42,8 +43,21 @@ type McpConnection = {
     }>): Promise<McpModuleToolBatchResult[]>;
 };
 export type ConnectMcp = (server: McpModuleServerHandle) => Promise<McpConnection> | McpConnection;
-export declare function makeMcpModule(connectMcp: ConnectMcp): {
+export type McpNamedServerHandle = {
+    name: string;
+};
+export type ManagedMcpClient = McpModuleClient & {
+    close(): Promise<void>;
+};
+export type ManagedMcpModule = {
+    servers: Record<string, ManagedMcpClient>;
+    server(name: string): McpNamedServerHandle;
+    client(handle: McpNamedServerHandle | string): Promise<ManagedMcpClient>;
+};
+type CustomMcpModule = {
     server(server: McpModuleServerHandle): McpModuleServerHandle;
     client(handle: McpModuleServerHandle): Promise<McpModuleClient>;
 };
+export declare function makeMcpModule(options: McpModuleOptions): ManagedMcpModule;
+export declare function makeMcpModule(connectMcp: ConnectMcp): CustomMcpModule;
 export {};

package/packages/safejs/dist/modules/mcp.js

@@ -1,5 +1,112 @@
+import { McpError } from "tiny-mcp-client";
+import { hostErrorData } from "../error/shape.js";
+import { declareHostOperation } from "../interp/host-bridge.js";
+import { runResources } from "../interp/resources.js";
+import { connectMcpTransport, normalizeMcpOptions } from "./mcp-transport.js";
 const DEFAULT_TOOL_BATCH_CONCURRENCY = 4;
 export function makeMcpModule(connectMcp) {
+    if (typeof connectMcp !== "function") {
+        const options = normalizeMcpOptions(connectMcp);
+        const servers = Object.create(null);
+        for (const [name, config] of Object.entries(options.servers)) {
+            const connections = new WeakMap();
+            const directScope = {};
+            const connection = () => {
+                const scope = runResources.getStore();
+                scope?.signal.throwIfAborted();
+                options.signal?.throwIfAborted();
+                const owner = scope ?? directScope;
+                let current = connections.get(owner);
+                if (current === undefined) {
+                    current = connectMcpTransport(config, options, scope?.signal);
+                    connections.set(owner, current);
+                    scope?.add(current.close);
+                }
+                return current.ready;
+            };
+            const invoke = async (operation) => {
+                try {
+                    const result = await operation(await connection());
+                    runResources.getStore()?.signal.throwIfAborted();
+                    options.signal?.throwIfAborted();
+                    return result;
+                }
+                catch (error) {
+                    runResources.getStore()?.signal.throwIfAborted();
+                    options.signal?.throwIfAborted();
+                    if (error instanceof McpError) {
+                        hostErrorData.set(error, {
+                            code: error.code,
+                            ...(error.data === undefined ? {} : { data: error.data })
+                        });
+                    }
+                    throw error;
+                }
+            };
+            servers[name] = {
+                tools: declareHostOperation(async () => invoke(async (client) => {
+                    const tools = [];
+                    const cursors = new Set();
+                    let pages = 0;
+                    let cursor;
+                    do {
+                        const result = await client.listTools(cursor === undefined ? undefined : { cursor });
+                        pages += 1;
+                        tools.push(...normalizeToolsResult(result));
+                        cursor = result.nextCursor;
+                        if (cursor !== undefined) {
+                            if (typeof cursor !== "string" || cursors.has(cursor))
+                                throw new Error("MCP tools pagination did not advance.");
+                            cursors.add(cursor);
+                            if (pages >= options.maxToolPages)
+                                throw new Error("MCP tools page limit exceeded.");
+                        }
+                    } while (cursor !== undefined);
+                    return tools;
+                }), "re-issue"),
+                tool: declareHostOperation(async (toolName, args) => {
+                    const request = createNullRecord({
+                        name: readNonEmptyTrimmedString(toolName, "MCP tool name"),
+                        ...(args === undefined ? {} : { arguments: readToolArguments(args) })
+                    });
+                    return invoke((client) => client.callTool(request));
+                }, "read-side-effect"),
+                toolBatch: declareHostOperation(async (calls) => {
+                    const normalized = readToolBatchCalls(calls);
+                    if (normalized.length === 0)
+                        return [];
+                    return invoke((client) => executeToolBatch(client, normalized));
+                }, "read-side-effect"),
+                close: declareHostOperation(async () => {
+                    const owner = runResources.getStore() ?? directScope;
+                    const current = connections.get(owner);
+                    if (current !== undefined) {
+                        await current.close();
+                        connections.delete(owner);
+                    }
+                }, "re-issue")
+            };
+        }
+        const readName = (value) => {
+            const name = readNonEmptyString(value, "MCP server name");
+            if (!Object.hasOwn(servers, name))
+                throw new Error(`MCP server '${name}' is not configured.`);
+            return name;
+        };
+        return {
+            servers,
+            server(name) {
+                return createNullRecord({ name: readName(name) });
+            },
+            async client(handle) {
+                if (typeof handle === "string")
+                    return servers[readName(handle)];
+                if (!isRecord(handle) || Object.keys(handle).length !== 1 || !Object.hasOwn(handle, "name"))
+                    throw new TypeError("MCP client requires a named server handle.");
+                return servers[readName(getOwnProperty(handle, "name"))];
+            }
+        };
+    }
     return {
         server(server) {
             return normalizeServerHandle(server);