@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/dist/json-schema-converter.js

@@ -1,13 +1,110 @@
-import { S } from "toolcraft-schema";
+import { S, withJsonSchema, normalizeLegacyNullability } from "toolcraft-schema";
 export function convertJsonSchema(schema) {
-    if (hasSelfReferencingRef(schema, schema)) {
-        return applyMetadata(S.Json(), schema, {
-            nullable: schema.nullable === true
-        });
+    const recursive = hasSelfReferencingRef(schema, schema);
+    if (recursive || needsNativeValidation(schema)) {
+        const resolved = resolveReferencedSchema(schema, schema, []);
+        const projection = resolved.type === "object"
+            ? createNativeObjectProjection(schema)
+            : recursive || schema.allOf !== undefined ? S.Json() : createNativeProjection(schema, schema, []);
+        return withJsonSchema(applyMetadata(projection, schema, {}), normalizeLegacyNullability(schema));
     }
     return convertSchema(schema, schema, []);
 }
+function needsNativeValidation(schema) {
+    if (typeof schema === "boolean" || Array.isArray(schema.type) ||
+        (schema.type === "array" && schema.items === undefined) ||
+        (schema.type === undefined && schema.enum === undefined && schema.const === undefined))
+        return true;
+    if (schema.$ref !== undefined || getComposition(schema) !== undefined)
+        return true;
+    if (schema.type !== undefined && (schema.enum !== undefined || schema.const !== undefined))
+        return true;
+    if (schema.type === "object" && schema.additionalProperties !== false)
+        return true;
+    if (Object.keys(schema).some((key) => !projectionKeywords.has(key)))
+        return true;
+    if ((schema.enum !== undefined || schema.const !== undefined) && Object.keys(schema).some((key) => !literalProjectionKeywords.has(key)))
+        return true;
+    return [...Object.values(schema.properties ?? {}), ...Object.values(schema.$defs ?? {}),
+        ...(schema.items === undefined ? [] : Array.isArray(schema.items) ? schema.items : [schema.items]),
+        ...(typeof schema.additionalProperties === "object" ? [schema.additionalProperties] : [])]
+        .some(needsNativeValidation);
+}
+const projectionKeywords = new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "const", "default", "description", "minLength", "maxLength", "minimum", "maximum", "minItems", "maxItems", "nullable", "pattern"]);
+const literalProjectionKeywords = new Set(["type", "enum", "const", "default", "description", "nullable"]);
+function createNativeProjection(schema, root, path) {
+    if (typeof schema === "boolean")
+        return S.Json();
+    if (schema.$ref !== undefined && (resolveLocalRef(root, schema.$ref) === undefined || typeof resolveLocalRef(root, schema.$ref) === "boolean"))
+        return applyMetadata(S.Json(), schema, {});
+    if (Array.isArray(schema.type)) {
+        const types = schema.type.filter(type => type !== "null");
+        return types.length === 1
+            ? convertSchema({ ...schema, type: types[0], nullable: schema.type.includes("null") || schema.nullable }, root, path)
+            : applyMetadata(S.Json(), schema, {});
+    }
+    if (hasSelfReferencingRef(schema, root) ||
+        (schema.type === "array" && (schema.items === undefined || Array.isArray(schema.items))) ||
+        (schema.type === undefined && schema.enum === undefined && schema.const === undefined && schema.$ref === undefined && getComposition(schema) === undefined)) {
+        return applyMetadata(S.Json(), schema, {});
+    }
+    return convertSchema(schema, root, path);
+}
+function createNativeObjectProjection(root) {
+    const properties = Object.create(null);
+    const required = new Set();
+    const unconditionalProperties = Object.create(null);
+    const conditionalProperties = new Map();
+    const visited = new Set();
+    const collect = (source, includeRequired = true) => {
+        if (visited.has(source))
+            return;
+        visited.add(source);
+        const resolved = resolveReferencedSchema(source, root, []);
+        Object.assign(properties, resolved.properties ?? {});
+        if (includeRequired)
+            Object.assign(unconditionalProperties, resolved.properties ?? {});
+        else
+            for (const [key, property] of Object.entries(resolved.properties ?? {})) {
+                const candidates = conditionalProperties.get(key) ?? [];
+                candidates.push(property);
+                conditionalProperties.set(key, candidates);
+            }
+        if (includeRequired)
+            for (const key of resolved.required ?? [])
+                required.add(key);
+        for (const branch of resolved.allOf ?? [])
+            collect(branch, includeRequired);
+        for (const branch of [...(resolved.anyOf ?? []), ...(resolved.oneOf ?? [])])
+            collect(branch, false);
+    };
+    collect(root);
+    const shape = {};
+    for (const [key, property] of Object.entries(properties)) {
+        const unconditional = Object.hasOwn(unconditionalProperties, key);
+        const projected = unconditional
+            ? createNativeProjection(unconditionalProperties[key], root, ["properties", key])
+            : createConditionalPropertyProjection(root, key, conditionalProperties.get(key) ?? [property]);
+        const field = unconditional ? projected : { ...projected, default: undefined };
+        setOwnShapeProperty(shape, key, required.has(key) ? field : S.Optional(field));
+    }
+    return S.Object(shape, { additionalProperties: root.additionalProperties !== false });
+}
+function createConditionalPropertyProjection(root, key, candidates) {
+    const branches = root.oneOf ?? root.anyOf ?? [];
+    if (branches.length > 1 && branches.every((branch) => Object.hasOwn(resolveReferencedSchema(branch, root, []).properties ?? {}, key))) {
+        const projected = candidates.map((candidate) => createNativeProjection(candidate, root, ["properties", key]));
+        if (projected.every((field) => field.kind === "enum")) {
+            const values = [...new Set(projected.flatMap((field) => field.kind === "enum" ? field.values : []))];
+            if (values.length > 0)
+                return S.Enum(values);
+        }
+    }
+    return S.Json();
+}
 function convertSchema(schema, root, path) {
+    if (typeof schema === "boolean")
+        return S.Json();
     const resolvedSchema = resolveReferencedSchema(schema, root, path);
     const normalizedSchema = normalizeNullability(resolvedSchema);
     const composition = getComposition(normalizedSchema.schema);
@@ -37,29 +134,43 @@ function convertSchema(schema, root, path) {
                 ...createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getStringDefault(normalizedSchema.schema.default)),
                 ...(normalizedSchema.schema.pattern === undefined
                     ? {}
-                    : { pattern: normalizedSchema.schema.pattern })
+                    : { pattern: normalizedSchema.schema.pattern }),
+                minLength: normalizedSchema.schema.minLength,
+                maxLength: normalizedSchema.schema.maxLength
             });
         case "number":
-            return S.Number(createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getNumberDefault(normalizedSchema.schema.default)));
+            return S.Number({
+                ...createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getNumberDefault(normalizedSchema.schema.default)),
+                minimum: normalizedSchema.schema.minimum,
+                maximum: normalizedSchema.schema.maximum
+            });
         case "integer":
             return S.Number({
                 ...createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getIntegerDefault(normalizedSchema.schema.default)),
-                jsonType: "integer"
+                jsonType: "integer",
+                minimum: normalizedSchema.schema.minimum,
+                maximum: normalizedSchema.schema.maximum
             });
         case "boolean":
             return S.Boolean(createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getBooleanDefault(normalizedSchema.schema.default)));
         case "array":
+            if (Array.isArray(normalizedSchema.schema.items))
+                return applyMetadata(S.Json(), normalizedSchema.schema, {});
             if (normalizedSchema.schema.items === undefined) {
                 throw new Error(`JSON Schema "${formatJsonSchemaPath(path)}" is an array but is missing the "items" field. Add "items": { ... } to declare the element type.`);
             }
-            return S.Array(convertSchema(normalizedSchema.schema.items, root, [...path, "items"]), createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getArrayDefault(normalizedSchema.schema.default)));
+            return S.Array(convertSchema(normalizedSchema.schema.items, root, [...path, "items"]), {
+                ...createCommonOptions(normalizedSchema.schema, normalizedSchema.nullable, getArrayDefault(normalizedSchema.schema.default)),
+                minItems: normalizedSchema.schema.minItems,
+                maxItems: normalizedSchema.schema.maxItems
+            });
         case "object":
             return convertObjectSchema(normalizedSchema.schema, root, {
                 nullable: normalizedSchema.nullable,
                 path
             });
         case "null":
-            return applyMetadata(S.Json(), normalizedSchema.schema, {
+            return applyMetadata(S.Enum([null]), normalizedSchema.schema, {
                 default: getJsonDefault(normalizedSchema.schema.default) ?? null,
                 nullable: true
             });
@@ -83,7 +194,7 @@ function convertConstSchema(schema, nullable) {
                 : {})
         });
     }
-    return applyMetadata(S.Json(), schema, {
+    return applyMetadata(S.Json({ const: schema.const }), schema, {
         default: schema.const,
         nullable: nullable || schema.const === null,
         description: appendDescription(schema.description, `Constant JSON value: ${JSON.stringify(schema.const)}.`)
@@ -91,6 +202,9 @@ function convertConstSchema(schema, nullable) {
 }
 function convertEnumSchema(schema, nullable) {
     const values = schema.enum ?? [];
+    if (values.length === 1 && values[0] === null) {
+        return S.Enum([null], createCommonOptions(schema, nullable, schema.default === null ? null : undefined));
+    }
     const nonNullValues = values.filter((value) => value !== null);
     const hasNull = nonNullValues.length !== values.length;
     if (nonNullValues.every(isPrimitiveEnumValue) && nonNullValues.length > 0) {
@@ -101,7 +215,7 @@ function convertEnumSchema(schema, nullable) {
                 : {})
         });
     }
-    return applyMetadata(S.Json(), schema, {
+    return applyMetadata(S.Json({ enum: values }), schema, {
         nullable: nullable || hasNull,
         description: appendDescription(schema.description, `Allowed JSON values: ${values.map((value) => JSON.stringify(value)).join(", ")}.`)
     });
@@ -111,6 +225,9 @@ function convertCompositionSchema(schema, root, nullable, path) {
     const branchSchemas = composition?.branches ?? [];
     const keyword = composition?.keyword ?? "oneOf";
     const branches = branchSchemas.map((branch, index) => resolveReferencedSchema(branch, root, [...path, keyword, String(index)]));
+    if (branches.some((branch) => branch.type !== "object" && branch.properties === undefined)) {
+        return applyMetadata(S.Json(), schema, { nullable });
+    }
     const discriminator = findDiscriminator(branches, root, path);
     if (discriminator !== undefined) {
         const convertedBranches = Object.fromEntries(branches.map((branch, index) => [
@@ -127,6 +244,10 @@ function convertCompositionSchema(schema, root, nullable, path) {
             nullable
         });
     }
+    const fingerprints = branches.map((branch) => JSON.stringify([...(branch.required ?? [])].sort()));
+    if (new Set(fingerprints).size !== fingerprints.length) {
+        return applyMetadata(S.Json(), schema, { nullable });
+    }
     return applyMetadata(S.Union(branches.map((branch, index) => convertObjectSchema(branch, root, {
         path: [...path, keyword, String(index)]
     }))), schema, {
@@ -295,17 +416,22 @@ function getDiscriminatorLiteral(branch, key, root) {
     }
     return undefined;
 }
-function resolveReferencedSchema(schema, root, path) {
+function resolveReferencedSchema(schema, root, path, activeReferences = new Set()) {
+    if (typeof schema === "boolean")
+        return {};
     if (schema.$ref === undefined) {
         return schema;
     }
+    if (activeReferences.has(schema))
+        return schema;
+    activeReferences.add(schema);
     const resolvedTarget = resolveLocalRef(root, schema.$ref);
-    if (resolvedTarget === undefined) {
-        throw new Error(`JSON Schema "${formatJsonSchemaPath(path)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`);
-    }
     const { $ref: ignoredRef, ...siblingKeywords } = schema;
     void ignoredRef;
-    const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path);
+    // The native compiler owns anchors, resource identifiers and unresolved-reference errors.
+    if (resolvedTarget === undefined || typeof resolvedTarget === "boolean")
+        return siblingKeywords;
+    const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path, activeReferences);
     if (Object.keys(siblingKeywords).length === 0) {
         return resolvedSchema;
     }
@@ -336,6 +462,8 @@ function mergeJsonSchemas(base, overlay) {
     };
 }
 function hasSelfReferencingRef(schema, root, path = "#", activePaths = new Set()) {
+    if (typeof schema === "boolean")
+        return false;
     const nextActivePaths = new Set(activePaths);
     nextActivePaths.add(path);
     const localRefPath = getLocalRefPath(schema.$ref);
@@ -350,7 +478,9 @@ function hasSelfReferencingRef(schema, root, path = "#", activePaths = new Set()
         }
     }
     if (schema.items !== undefined &&
-        hasSelfReferencingRef(schema.items, root, `${path}/items`, nextActivePaths)) {
+        (Array.isArray(schema.items)
+            ? schema.items.some((item, index) => hasSelfReferencingRef(item, root, `${path}/items/${index}`, nextActivePaths))
+            : hasSelfReferencingRef(schema.items, root, `${path}/items`, nextActivePaths))) {
         return true;
     }
     if (typeof schema.additionalProperties === "object" &&
@@ -421,7 +551,7 @@ function resolveLocalRef(root, ref) {
         }
         current = current[segment];
     }
-    return isPlainObject(current) ? current : undefined;
+    return typeof current === "boolean" || isPlainObject(current) ? current : undefined;
 }
 function appendDescription(description, addition) {
     if (addition === undefined || addition.length === 0) {
@@ -433,7 +563,7 @@ function appendDescription(description, addition) {
     return `${description} ${addition}`;
 }
 function isPrimitiveEnumValue(value) {
-    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+    return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
 function getStringDefault(value) {
     return typeof value === "string" ? value : undefined;

package/node_modules/toolcraft/dist/mcp-proxy-metadata.d.ts

@@ -0,0 +1,2 @@
+export declare function isProxyNode(node: object): boolean;
+export declare function markProxyNode<TNode extends object>(node: TNode): TNode;

package/node_modules/toolcraft/dist/mcp-proxy-metadata.js

@@ -0,0 +1,13 @@
+const proxyNodeSymbol = Symbol("toolcraft.mcpProxyNode");
+export function isProxyNode(node) {
+    return Object.getOwnPropertySymbols(node).some((symbol) => symbol.description === proxyNodeSymbol.description && Reflect.get(node, symbol) === true);
+}
+export function markProxyNode(node) {
+    Object.defineProperty(node, proxyNodeSymbol, {
+        configurable: false,
+        enumerable: false,
+        value: true,
+        writable: false
+    });
+    return node;
+}

package/node_modules/toolcraft/dist/mcp-proxy.d.ts

@@ -1,12 +1,13 @@
 import type { McpServerConfig } from "@poe-code/agent-mcp-config";
 import { McpClient } from "tiny-mcp-client";
 import type { Group } from "./index.js";
+export { findProjectRoot } from "./project-root.js";
 export interface ResolveMcpProxyOptions {
     projectRoot?: string;
 }
 export declare function hasMcpProxyGroups(root: Group<any>): boolean;
-export declare function findProjectRoot(from?: string): string | undefined;
 export declare function resolveCachePath(name: string, projectRoot?: string): string;
 export declare function parseRefreshEnv(value: string | undefined): "all" | Set<string> | undefined;
 export declare function dialUpstream(name: string, config: McpServerConfig): Promise<McpClient>;
 export declare function resolveMcpProxies(root: Group<any>, options?: ResolveMcpProxyOptions): Promise<void>;
+export declare function disposeMcpProxies(root: Group<any>): Promise<void>;

package/node_modules/toolcraft/dist/mcp-proxy.js

@@ -1,4 +1,3 @@
-import { existsSync } from "node:fs";
 import { lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
@@ -6,15 +5,18 @@ import { createLogger } from "toolcraft-design";
 import { HttpTransport, McpClient, StdioTransport } from "tiny-mcp-client";
 import { hasOwnErrorCode } from "./error-codes.js";
 import { convertJsonSchema } from "./json-schema-converter.js";
+import { asMCPResult } from "./mcp-result.js";
+import { isProxyNode, markProxyNode } from "./mcp-proxy-metadata.js";
+import { findProjectRoot } from "./project-root.js";
+import { formatIssues, validate } from "toolcraft-schema";
+export { findProjectRoot } from "./project-root.js";
 const GROUP_CONFIG_SYMBOL_DESCRIPTION = "toolcraft.group.config";
 const MCP_PROXY_SCHEMA_URL = "https://poe-platform.github.io/poe-code/schemas/toolcraft/mcp-proxy.schema.json";
 const DEFAULT_CLIENT_INFO = {
     name: "toolcraft",
     version: "0.0.1",
 };
-const proxyNodeSymbol = Symbol("toolcraft.mcpProxyNode");
 const proxyConnectionSymbol = Symbol("toolcraft.mcpProxyConnection");
-const shutdownDisposers = new Set();
 function getInternalGroupConfig(group) {
     const symbol = Object.getOwnPropertySymbols(group).find((candidate) => candidate.description === GROUP_CONFIG_SYMBOL_DESCRIPTION);
     if (symbol === undefined) {
@@ -23,27 +25,12 @@ function getInternalGroupConfig(group) {
     return (group[symbol] ??
         {});
 }
-function isProxyNode(node) {
-    return node[proxyNodeSymbol] === true;
-}
-function markProxyNode(node) {
-    Object.defineProperty(node, proxyNodeSymbol, {
-        configurable: false,
-        enumerable: false,
-        value: true,
-        writable: false,
-    });
-    return node;
-}
 function cloneSecrets(secrets) {
     return { ...secrets };
 }
 function cloneScope(scope) {
     return scope === undefined ? undefined : [...scope];
 }
-function registerShutdownDispose(dispose) {
-    shutdownDisposers.add(dispose);
-}
 function getProxyConnection(group) {
     return group[proxyConnectionSymbol];
 }
@@ -71,13 +58,12 @@ function createProxyCommand(parent, tool, commandName, connection) {
     const result = tool.outputSchema === undefined
         ? undefined
         : convertJsonSchema(tool.outputSchema);
-    if (result !== undefined && result.kind !== "object") {
-        throw new Error(`upstream tool "${tool.name}" must define an object output schema`);
-    }
     return markProxyNode({
         kind: "command",
         name: commandName,
+        title: tool.title,
         description: tool.description,
+        annotations: tool.annotations === undefined ? undefined : { ...tool.annotations },
         hidden: false,
         examples: [],
         aliases: [],
@@ -89,17 +75,33 @@ function createProxyCommand(parent, tool, commandName, connection) {
         confirm: false,
         requires: parent.requires,
         handler: async (ctx) => {
-            const client = await ensureConnected(connection);
+            ctx.signal?.throwIfAborted();
+            const connecting = ensureConnected(connection);
+            const client = ctx.signal === undefined ? await connecting : await new Promise((resolve, reject) => {
+                const signal = ctx.signal;
+                const abort = () => {
+                    signal.removeEventListener("abort", abort);
+                    reject(signal.reason);
+                };
+                signal.addEventListener("abort", abort, { once: true });
+                connecting.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+                if (signal.aborted)
+                    abort();
+            });
+            ctx.signal?.throwIfAborted();
             const toolResult = await client.callTool({
                 name: tool.name,
                 arguments: ctx.params,
-            });
-            if (result === undefined) {
-                return toolResult;
+            }, { signal: ctx.signal });
+            if (result === undefined || toolResult.isError === true) {
+                return asMCPResult(toolResult);
             }
             if (toolResult.structuredContent === undefined) {
                 throw new Error(`upstream tool "${tool.name}" declared outputSchema but returned no structuredContent`);
             }
+            const validation = validate(result, toolResult.structuredContent);
+            if (!validation.ok)
+                throw new Error(`upstream tool "${tool.name}" returned invalid structuredContent: ${formatIssues(validation.issues)}`);
             return toolResult.structuredContent;
         },
         render: undefined,
@@ -138,21 +140,26 @@ function createConnection(name, config) {
     const connection = {
         name,
         config,
-        async dispose() {
-            shutdownDisposers.delete(connection.dispose);
-            connection.connecting = undefined;
-            if (connection.client === undefined) {
-                return;
-            }
-            const client = connection.client;
-            connection.client = undefined;
-            await client.close();
+        dispose() {
+            if (connection.closing !== undefined)
+                return connection.closing;
+            connection.closing = (async () => {
+                await connection.connecting?.catch(() => undefined);
+                const client = connection.client;
+                connection.client = undefined;
+                if (client !== undefined)
+                    await client.close();
+            })().finally(() => {
+                connection.closing = undefined;
+            });
+            return connection.closing;
         },
     };
-    registerShutdownDispose(connection.dispose);
     return connection;
 }
 async function ensureConnected(connection) {
+    if (connection.closing !== undefined)
+        await connection.closing;
     if (connection.client !== undefined && connection.client.state === "ready") {
         return connection.client;
     }
@@ -236,11 +243,22 @@ async function fetchCache(name, config) {
     try {
         logger.info(`MCP ${name}: listing tools`);
         const tools = [];
+        const seenCursors = new Set();
         let cursor;
+        let pages = 0;
         do {
             const page = await client.listTools(cursor === undefined ? {} : { cursor });
+            pages++;
             tools.push(...page.tools);
             cursor = page.nextCursor;
+            if (cursor !== undefined) {
+                if (seenCursors.has(cursor)) {
+                    throw new Error("upstream tools/list returned a repeated pagination cursor");
+                }
+                seenCursors.add(cursor);
+                if (pages >= 128)
+                    throw new Error("upstream exceeded the tool pagination limit (128 pages)");
+            }
         } while (cursor !== undefined);
         logger.info(`MCP ${name}: found ${tools.length} tools`);
         const upstream = client.serverInfo ?? {
@@ -292,18 +310,6 @@ function populateGroupFromTools(group, tools, rename, connection) {
         parent.children.push(createProxyCommand(parent, tool, commandName, connection));
     }
 }
-function replaceProxyChildrenSafely(group, tools, rename, connection) {
-    const previousChildren = snapshotGroupChildren(group);
-    try {
-        populateGroupFromTools(group, tools, rename, connection);
-    }
-    catch (error) {
-        for (const [capturedGroup, children] of previousChildren) {
-            capturedGroup.children = children;
-        }
-        throw error;
-    }
-}
 function snapshotGroupChildren(group) {
     const snapshot = new Map();
     const visit = (current) => {
@@ -353,8 +359,9 @@ async function resolveSingleProxy(group, options) {
         validateRenameMap(name, tools, internal.rename);
         const previousConnection = getProxyConnection(group);
         const nextConnection = createConnection(name, config);
+        const previousChildren = snapshotGroupChildren(group);
         try {
-            replaceProxyChildrenSafely(group, tools, internal.rename, nextConnection);
+            populateGroupFromTools(group, tools, internal.rename, nextConnection);
             if (shouldWriteCache) {
                 await writeCache(cachePath, cache);
                 createLogger((message) => process.stderr.write(`${message}\n`)).info(`MCP ${name}: wrote ${cachePath}`);
@@ -362,6 +369,9 @@ async function resolveSingleProxy(group, options) {
             setProxyConnection(group, nextConnection);
         }
         catch (error) {
+            for (const [capturedGroup, children] of previousChildren) {
+                capturedGroup.children = children;
+            }
             await nextConnection.dispose();
             throw error;
         }
@@ -400,22 +410,6 @@ function collectProxyGroups(root) {
 export function hasMcpProxyGroups(root) {
     return collectProxyGroups(root).length > 0;
 }
-export function findProjectRoot(from = process.cwd()) {
-    let current = process.cwd();
-    if (from !== current) {
-        current = path.resolve(from);
-    }
-    while (true) {
-        if (existsSync(path.join(current, "package.json"))) {
-            return current;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return undefined;
-        }
-        current = parent;
-    }
-}
 export function resolveCachePath(name, projectRoot) {
     const resolvedProjectRoot = projectRoot ?? findProjectRoot();
     if (resolvedProjectRoot === undefined) {
@@ -487,3 +481,14 @@ export async function resolveMcpProxies(root, options = {}) {
     const groups = collectProxyGroups(root);
     await Promise.all(groups.map((group) => resolveSingleProxy(group, options)));
 }
+export async function disposeMcpProxies(root) {
+    const connections = new Set(collectProxyGroups(root).flatMap((group) => {
+        const connection = getProxyConnection(group);
+        return connection === undefined ? [] : [connection];
+    }));
+    const outcomes = await Promise.allSettled([...connections].map((connection) => connection.dispose()));
+    const failures = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+    if (failures.length > 0) {
+        throw new AggregateError(failures, failures.map((error) => error instanceof Error ? error.message : String(error)).join("; "));
+    }
+}

package/node_modules/toolcraft/dist/mcp-result.d.ts

@@ -0,0 +1,3 @@
+import type { CallToolResult } from "tiny-stdio-mcp-server";
+export declare function asMCPResult<TResult extends CallToolResult>(result: TResult): TResult;
+export declare function isMCPResult(value: unknown): value is CallToolResult;

package/node_modules/toolcraft/dist/mcp-result.js

@@ -0,0 +1,10 @@
+const mcpResultSymbol = Symbol.for("toolcraft.mcp-result");
+export function asMCPResult(result) {
+    if (result === null || typeof result !== "object" || Array.isArray(result) || !Array.isArray(result.content)) {
+        throw new TypeError("MCP results must contain a content array.");
+    }
+    return Object.defineProperty({ ...result }, mcpResultSymbol, { value: true });
+}
+export function isMCPResult(value) {
+    return value !== null && typeof value === "object" && Reflect.get(value, mcpResultSymbol) === true;
+}

package/node_modules/toolcraft/dist/mcp.compile-check.js

@@ -21,7 +21,10 @@ const ignoredOptions = {
     fetch: globalThis.fetch,
     tools: ["usage"],
     casing: "snake",
-    humanInLoop: {},
+    humanInLoop: {
+        invoke: async (node, ctx) => node.handler(ctx),
+        mergeApprovalsGroup: (root) => root,
+    },
 };
 const ignoredServer = createMCPServer(ignoredRoot, ignoredOptions);
 const ignoredServerArray = createMCPServer([ignoredRoot], ignoredOptions);

package/node_modules/toolcraft/dist/mcp.d.ts

@@ -1,17 +1,27 @@
+import "./node-require-shim.js";
 import { type SDKTransport, type Server as TinyServer } from "tiny-stdio-mcp-server";
-import type { Group, LogLevel, RuntimeLoggerInput } from "./index.js";
+import type { Group, HandlerFs, LogLevel, RuntimeLoggerInput } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
-import { type HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
+import { type HumanInLoopRuntime } from "./human-in-loop/types.js";
 type Casing = "snake" | "camel";
 type CmdkitServer = Omit<TinyServer, "connect"> & {
     connect(transport: SDKTransport): Promise<void>;
 };
+export declare const MCP_STREAM_METHODS: {
+    readonly list: "toolcraft/streams/list";
+    readonly subscribe: "toolcraft/streams/subscribe";
+    readonly unsubscribe: "toolcraft/streams/unsubscribe";
+    readonly notification: "notifications/toolcraft/stream";
+};
 export interface RunMCPOptions<TServices extends object = Record<string, unknown>> {
+    apiVersion?: string;
     approvals?: boolean;
+    env?: Record<string, string>;
     fetch?: typeof globalThis.fetch;
+    fs?: HandlerFs;
     name: string;
     version?: string;
-    humanInLoop?: HumanInLoopRuntimeOptions;
+    humanInLoop?: HumanInLoopRuntime;
     projectRoot?: string;
     logLevel?: LogLevel;
     logger?: RuntimeLoggerInput;