toolcraft 0.0.231 → 0.0.233

package/dist/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.17",
+      "version": "0.1.18",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.231",
+      "version": "0.0.233",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.231",
+      "version": "0.0.233",
       "license": "MIT"
     },
     {

package/dist/discriminator.d.ts

@@ -0,0 +1,9 @@
+import { type AnySchema, type ObjectSchema } from "toolcraft-schema";
+import type { ValidationError } from "./validation-errors.js";
+export declare function resolveDiscriminatedBranch(schema: Extract<AnySchema, {
+    kind: "oneOf";
+}>, value: unknown, discriminatorKey: string, label: string, errors: ValidationError[]): {
+    discriminator: string;
+    branch: ObjectSchema<any>;
+    value: Record<string, unknown>;
+} | undefined;

package/dist/discriminator.js

@@ -0,0 +1,32 @@
+import { isPlainRecord } from "toolcraft-schema";
+export function resolveDiscriminatedBranch(schema, value, discriminatorKey, label, errors) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        errors.push({ path: label, message: `Invalid value for "${label}". Expected an object.` });
+        return undefined;
+    }
+    const record = value;
+    const fieldLabel = label.length === 0 ? discriminatorKey : `${label}.${discriminatorKey}`;
+    const branchNames = Object.keys(schema.branches);
+    const expected = branchNames.length === 0
+        ? "No branches are available."
+        : `Expected one of: ${branchNames.join(", ")}.`;
+    if (!Object.hasOwn(record, discriminatorKey)) {
+        errors.push({ path: fieldLabel, message: `Missing discriminator "${fieldLabel}". ${expected}` });
+        return undefined;
+    }
+    if (!isPlainRecord(record)) {
+        errors.push({ path: label, message: `Invalid value for "${label}". Expected an object, got non-plain object.` });
+        return undefined;
+    }
+    const discriminator = record[discriminatorKey];
+    if (typeof discriminator !== "string" || !Object.hasOwn(schema.branches, discriminator)) {
+        const received = typeof discriminator === "string"
+            ? JSON.stringify(discriminator)
+            : discriminator === null ? "null" : typeof discriminator;
+        errors.push({ path: fieldLabel, message: `Invalid discriminator "${fieldLabel}": ${received}. ${expected}` });
+        return undefined;
+    }
+    const { [discriminatorKey]: ignoredDiscriminator, ...branchValue } = record;
+    void ignoredDiscriminator;
+    return { discriminator, branch: schema.branches[discriminator], value: branchValue };
+}

package/dist/error-report.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from "./index.js";
+import { isHttpErrorLike } from "./api-error-summary.js";
 export type ErrorReportsOption = boolean | {
     dir?: string;
 };
@@ -23,23 +24,6 @@ export interface ErrorReportRenderResult {
     content: string;
     redactedKeys: string[];
 }
-interface HttpErrorLike {
-    name: "HttpError";
-    message: string;
-    request: {
-        method: string;
-        url: string;
-        headers: Record<string, string>;
-        body?: unknown;
-    };
-    response: {
-        status: number;
-        statusText: string;
-        headers: Record<string, string>;
-        body: unknown;
-    };
-}
-declare function hasHttpContext(error: unknown): error is HttpErrorLike;
 /**
  * Renders the exact redacted content used by `writeErrorReport` without checking report enablement
  * or writing to the filesystem. `redactedKeys` lists every environment variable declared by the
@@ -47,4 +31,4 @@ declare function hasHttpContext(error: unknown): error is HttpErrorLike;
  */
 export declare function renderErrorReport(context: ErrorReportRenderContext): ErrorReportRenderResult;
 export declare function writeErrorReport(context: ErrorReportContext): Promise<ErrorReportResult | undefined>;
-export { hasHttpContext };
+export { isHttpErrorLike as hasHttpContext };

package/dist/error-report.js

@@ -6,7 +6,8 @@ import { CommanderError } from "commander";
 import { ApprovalDeclinedError } from "./human-in-loop/types.js";
 import { findPackageMetadata } from "./package-metadata.js";
 import { findProjectRoot } from "./project-root.js";
-import { isSensitiveName, redactHttpBody, redactHttpHeaderValue } from "./redaction.js";
+import { isSensitiveName, redactHttpBody, redactHttpHeaderValue, redactSecretLikeFields } from "./redaction.js";
+import { isHttpErrorLike } from "./api-error-summary.js";
 import { UserError } from "./user-error.js";
 const ERROR_REPORTS_ENV = "TOOLCRAFT_ERROR_REPORTS";
 function isPlainObject(value) {
@@ -18,12 +19,6 @@ function unwrapOptional(schema) {
     }
     return schema;
 }
-function hasHttpContext(error) {
-    return (error instanceof Error &&
-        error.name === "HttpError" &&
-        isPlainObject(error.request) &&
-        isPlainObject(error.response));
-}
 function isSkippedError(error) {
     if (error instanceof ApprovalDeclinedError) {
         return true;
@@ -32,7 +27,7 @@ function isSkippedError(error) {
         (error.code === "commander.helpDisplayed" || error.code === "commander.version")) {
         return true;
     }
-    return error instanceof UserError && error.cause === undefined && !hasHttpContext(error);
+    return error instanceof UserError && error.cause === undefined && !isHttpErrorLike(error);
 }
 function reportsEnabled(option, env) {
     if (env[ERROR_REPORTS_ENV] === "1") {
@@ -274,9 +269,6 @@ function redactStructuredErrorField(name, value, redactString) {
         if (redactedHeaderValue !== value) {
             return redactedHeaderValue;
         }
-        if (isSensitiveName(name)) {
-            return "<redacted>";
-        }
         return redactString(value);
     }
     if (Array.isArray(value)) {
@@ -297,7 +289,7 @@ function ownStructuredFields(error, redactString) {
             continue;
         }
         Object.defineProperty(fields, key, {
-            value: redactStructuredErrorField(key, error[key], redactString),
+            value: redactStructuredErrorField(key, redactSecretLikeFields(error[key], key), redactString),
             enumerable: true,
             configurable: true,
             writable: true
@@ -307,10 +299,16 @@ function ownStructuredFields(error, redactString) {
 }
 function formatStackChain(error, redactString) {
     const lines = [];
+    const seen = new Set();
     let current = error;
     let index = 0;
     while (current !== undefined) {
         if (current instanceof Error) {
+            if (seen.has(current)) {
+                lines.push("Caused by: [Circular]");
+                break;
+            }
+            seen.add(current);
             const stack = current.stack ?? String(current);
             lines.push(redactString(index === 0 ? stack : `Caused by: ${stack}`));
             current = current.cause;
@@ -405,7 +403,7 @@ function buildReport(context) {
         "Stack",
         formatStackChain(error, redactString)
     ];
-    if (hasHttpContext(error)) {
+    if (isHttpErrorLike(error)) {
         lines.push("", "HTTP Transcript", formatHttpTranscript(error, redactString));
     }
     return `${lines.join("\n")}\n`;
@@ -440,4 +438,4 @@ export async function writeErrorReport(context) {
         displayPath: relativeDisplayPath(projectRoot, absolutePath)
     };
 }
-export { hasHttpContext };
+export { isHttpErrorLike as hasHttpContext };

package/dist/http.js

@@ -46,19 +46,24 @@ function createTransportOptions(options, serverOptions) {
     return {
         ...serverOptions,
         toolCallTimeoutMs: options.toolCallTimeoutMs,
-        sessionIdGenerator: options.sessionIdGenerator,
+        ...(Object.prototype.hasOwnProperty.call(options, "sessionIdGenerator")
+            ? { sessionIdGenerator: options.sessionIdGenerator }
+            : {}),
         enableJsonResponse: options.enableJsonResponse,
         allowedOrigins: options.allowedOrigins,
         allowedHosts: options.allowedHosts,
         maxRequestBytes: options.maxRequestBytes,
+        maxResponseBytes: options.maxResponseBytes,
         maxBatchSize: options.maxBatchSize,
         maxSessions: options.maxSessions,
+        maxSessionsPerSubject: options.maxSessionsPerSubject,
         sessionTtlMs: options.sessionTtlMs,
         maxStreamsPerSession: options.maxStreamsPerSession,
         maxStreamBufferBytes: options.maxStreamBufferBytes,
         maxSseEventHistory: options.maxSseEventHistory,
         sseKeepAliveMs: options.sseKeepAliveMs,
         maxConcurrentToolCalls: options.maxConcurrentToolCalls,
+        maxQueuedToolCalls: options.maxQueuedToolCalls,
         sessionStore: options.sessionStore,
         requestIdGenerator: options.requestIdGenerator,
         observability: options.observability,
@@ -111,6 +116,8 @@ export async function createHTTPMCPServer(roots, options) {
     }
     let server;
     await createMCPServerForTransport(roots, resolvedOptions, {
+        supportsStreaming: !Object.prototype.hasOwnProperty.call(resolvedOptions, "sessionIdGenerator") ||
+            resolvedOptions.sessionIdGenerator !== undefined,
         createServer(serverOptions) {
             server = createHttpServer(createTransportOptions(resolvedOptions, serverOptions));
             return server;

package/dist/human-in-loop/gate.js

@@ -3,6 +3,7 @@ import { spawnApprovalRunner } from "./spawn.js";
 import { ApprovalDeclinedError } from "./types.js";
 import { assertApprovalPlanHash, createApprovalPlan, formatApprovalMessage } from "./plan-hash.js";
 export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPath, options = {}) {
+    ctx.signal?.throwIfAborted();
     if (!node.humanInLoop) {
         return node.handler(ctx);
     }
@@ -14,11 +15,13 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
     const approvalPlan = node.humanInLoop.plan === undefined
         ? undefined
         : createApprovalPlan(await node.humanInLoop.plan(planContext));
+    ctx.signal?.throwIfAborted();
     const message = approvalPlan === undefined
         ? baseMessage
         : formatApprovalMessage(baseMessage, approvalPlan);
     if (node.humanInLoop.mode === "async") {
         const { tasks } = await ensureApprovalList(runtimeOptions);
+        ctx.signal?.throwIfAborted();
         const { approvalId, pending } = await (options.enqueueApproval ?? enqueueApproval)({
             tasks,
             payload: {
@@ -30,6 +33,7 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
                 declineInputPrompt: node.humanInLoop.declineInputPrompt
             }
         });
+        ctx.signal?.throwIfAborted();
         if (options.spawnRunner !== false) {
             spawnApprovalRunner(approvalId, runtimeOptions);
         }
@@ -39,6 +43,7 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
         message,
         declineInputPrompt: node.humanInLoop.declineInputPrompt
     });
+    ctx.signal?.throwIfAborted();
     if (result.outcome === "declined") {
         throw new ApprovalDeclinedError({
             reason: result.reason,
@@ -47,6 +52,7 @@ export async function invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPa
     }
     if (approvalPlan !== undefined && node.humanInLoop.plan !== undefined) {
         const executionPlan = createApprovalPlan(await node.humanInLoop.plan(planContext));
+        ctx.signal?.throwIfAborted();
         assertApprovalPlanHash(approvalPlan.hash, executionPlan.hash);
     }
     return node.handler(ctx);

package/dist/index.compile-check.js

@@ -1,6 +1,24 @@
 import { S } from "toolcraft-schema";
-import { defineCommand, defineGroup } from "./index.js";
+import { asMCPResult, cloneCommandNode, defineCommand, defineGroup } from "./index.js";
 import { createFileChangeRenderers } from "./file-change-renderer.js";
+import { validate as validateSchema } from "./schema.js";
+const ignoredValidationOptions = { defaults: "none" };
+const ignoredWithoutDefaults = validateSchema(S.Object({ count: S.Optional(S.Number({ default: 2 })) }), {}, ignoredValidationOptions);
+const ignoredMCPResult = asMCPResult({
+    content: [{ type: "text", text: "upstream message" }],
+    structuredContent: { id: "one" },
+    _meta: { trace: "request" }
+});
+const ignoredMCPResultCommand = defineCommand({
+    name: "upstream",
+    params: S.Object({}),
+    handler: () => ignoredMCPResult,
+    render: { json: (result) => ({ id: result.structuredContent.id, trace: result._meta.trace }) }
+});
+const ignoredClonedCommand = cloneCommandNode(ignoredMCPResultCommand);
+const ignoredExtendedCommand = { ...ignoredMCPResultCommand, extraRuntimeState: 1 };
+const ignoredClonedDefinition = cloneCommandNode(ignoredExtendedCommand);
+const ignoredScopeOverrideClone = cloneCommandNode(ignoredMCPResultCommand, ["cli"]);
 const ignoredScope = ["cli", "sdk"];
 const ignoredSecrets = {
     apiKey: { env: "API_KEY" },
@@ -54,11 +72,10 @@ defineCommand({
     handler: async () => [],
 });
 defineCommand({
-    name: "invalid-scalar-mapped-result",
+    name: "scalar-mapped-result",
     params: S.Object({}),
-    result: S.Object({ data: S.Array(S.String()) }),
-    // @ts-expect-error MCP structured results must have an object root
-    mcpResult: () => "invalid",
+    result: S.String(),
+    mcpResult: () => "ready",
     handler: async () => [],
 });
 const ignoredGroup = defineGroup({

package/dist/index.d.ts

@@ -15,6 +15,7 @@ type ScopeInput = readonly Scope[] | undefined;
 type HumanInLoopMode = "sync" | "async";
 type HumanInLoopModeInput = HumanInLoopMode | null | undefined;
 export type Scope = ScopeValue;
+export type MCPResultValue = Record<string, unknown> | readonly unknown[] | string | number | boolean | null;
 type ResolveOwnHumanInLoopMode<TValue> = TValue extends {
     mode: infer TMode extends HumanInLoopMode;
 } ? TMode : TValue extends null ? null : undefined;
@@ -74,6 +75,7 @@ export type GroupCheckContext<TServices extends object = EmptyServices> = TServi
     fs: HandlerFs;
     env: HandlerEnv;
     diagnostics: RuntimeLogger;
+    signal?: AbortSignal;
     progress(message: string): void;
 };
 export type CommandCheckContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
@@ -122,8 +124,8 @@ export interface CommandConfig<TServices extends object, TParamsSchema extends O
     aliases?: string[];
     positional?: string[];
     params: TParamsSchema;
-    result?: ObjectSchema<any>;
-    mcpResult?: (result: TResult) => Record<string, unknown>;
+    result?: AnySchema;
+    mcpResult?: (result: TResult) => MCPResultValue;
     secrets?: TSecrets;
     scope?: Scope[];
     confirm?: boolean;
@@ -157,8 +159,8 @@ export interface Command<TServices extends object = EmptyServices, TParamsSchema
     aliases: string[];
     positional: string[];
     params: TParamsSchema;
-    result?: ObjectSchema<any>;
-    mcpResult?: (result: TResult) => Record<string, unknown>;
+    result?: AnySchema;
+    mcpResult?: (result: TResult) => MCPResultValue;
     stream?: StreamDefinition<any>;
     secrets: SecretDeclarations;
     scope: Scope[];
@@ -236,6 +238,9 @@ export declare function defineGroup<TServices extends object = EmptyServices, TN
     scope?: TOwnScope;
     humanInLoop?: TOwnHumanInLoop;
 }): Group<TServices> & TypedGroupMetadata<TServices, TName, TChildren, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
+export type ClonedCommandNode<TNode extends CommandNode<any>> = TNode extends Command<infer TServices, infer TParams, infer TSecrets, infer TResult> ? Command<TServices, TParams, TSecrets, TResult> & Pick<TNode, Extract<keyof TNode, "__agentKitCommandTypeInfo">> : TNode extends Group<infer TServices> ? Group<TServices> & Pick<TNode, Extract<keyof TNode, "__agentKitGroupTypeInfo">> : never;
+export declare function cloneCommandNode<TNode extends CommandNode<any>>(node: TNode): ClonedCommandNode<TNode>;
+export declare function cloneCommandNode<TServices extends object>(node: CommandNode<TServices>, scopeOverride: Scope[]): CommandNode<TServices>;
 export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
 export declare function hasMcpProxyConfig(group: Group<any>): boolean;
 export { S, toJsonSchema } from "./schema.js";
@@ -244,10 +249,12 @@ export type { HttpErrorRequest, HttpErrorResponse } from "./http-errors.js";
 export { ApprovalDeclinedError, ToolcraftBugError, UserError, isUserError };
 export { suggest } from "./suggest.js";
 export { createRuntimeLogger, isLogLevel, shouldEmitDiagnostic } from "./runtime-logging.js";
+export { isSensitiveName, redactHttpBody } from "./redaction.js";
 export { findPackageMetadata, packageMetadata } from "./package-metadata.js";
+export { asMCPResult } from "./mcp-result.js";
 export type { PackageMetadata } from "./package-metadata.js";
 export type { FileChangeRendererOptions, FileChangeResult } from "./file-change-renderer.js";
 export type { FileChange, FileChangeDisplayMode, FileChangeKind } from "toolcraft-design";
 export type { DiagnosticLogEvent, LogLevel, RuntimeLogger, RuntimeLoggerInput } from "./runtime-logging.js";
-export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationResult } from "./schema.js";
+export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult } from "./schema.js";
 export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntime };

package/dist/index.js

@@ -3,6 +3,7 @@ import { ApprovalDeclinedError } from "./human-in-loop/types.js";
 import { mergeHumanInLoopFromGroup, validateHumanInLoopOnDefine } from "./human-in-loop/config.js";
 import { ToolcraftBugError, UserError, isUserError } from "./user-error.js";
 import { suggest } from "./suggest.js";
+import { isProxyNode } from "./mcp-proxy-metadata.js";
 export { createManagedStream } from "./stream.js";
 const commandConfigSymbol = Symbol("toolcraft.command.config");
 const groupConfigSymbol = Symbol("toolcraft.group.config");
@@ -502,6 +503,53 @@ export function defineGroup(config) {
         requires: undefined
     });
 }
+export function cloneCommandNode(node, scopeOverride) {
+    function rebuildNode(current, root, withinProxy) {
+        const description = current.kind === "command"
+            ? commandConfigSymbol.description
+            : groupConfigSymbol.description;
+        const symbol = Object.getOwnPropertySymbols(current).find((candidate) => candidate.description === description);
+        const config = symbol === undefined ? undefined : Reflect.get(current, symbol);
+        const inherited = root || config === undefined ? current : config;
+        const metadata = {
+            scope: scopeOverride ?? inherited.scope,
+            humanInLoop: inherited.humanInLoop,
+            secrets: inherited.secrets,
+            requires: inherited.requires
+        };
+        if (current.kind === "command") {
+            const base = createBaseCommand({ ...current, ...metadata });
+            if (config !== undefined) {
+                getInternalCommandConfig(base).sourcePath = config.sourcePath;
+            }
+            base.stream = current.stream === undefined ? undefined : { ...current.stream };
+            return base;
+        }
+        const groupConfig = config;
+        const proxyChildren = withinProxy || groupConfig?.mcp !== undefined;
+        const sourceChildren = current.children.filter((child) => !proxyChildren || !isProxyNode(child));
+        const children = sourceChildren.map((child) => rebuildNode(child, false, proxyChildren));
+        const defaultIndex = current.default === undefined ? -1 : sourceChildren.indexOf(current.default);
+        if (current.default !== undefined && defaultIndex === -1) {
+            throw new ToolcraftBugError(`Default command "${current.default.name}" must be listed in children.`);
+        }
+        return createBaseGroup({
+            ...current,
+            ...metadata,
+            mcp: groupConfig?.mcp,
+            tools: groupConfig?.tools,
+            rename: groupConfig?.rename,
+            children,
+            default: defaultIndex === -1 ? undefined : children[defaultIndex]
+        });
+    }
+    return materializeNode(rebuildNode(node, true, false), {
+        scope: undefined,
+        humanInLoop: undefined,
+        secrets: {},
+        requires: undefined
+    });
+}
 export function getCommandSourcePath(command) {
     return command[commandSourcePathSymbol];
 }
@@ -521,4 +569,6 @@ export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpE
 export { ApprovalDeclinedError, ToolcraftBugError, UserError, isUserError };
 export { suggest } from "./suggest.js";
 export { createRuntimeLogger, isLogLevel, shouldEmitDiagnostic } from "./runtime-logging.js";
+export { isSensitiveName, redactHttpBody } from "./redaction.js";
 export { findPackageMetadata, packageMetadata } from "./package-metadata.js";
+export { asMCPResult } from "./mcp-result.js";

package/dist/json-schema-converter.d.ts

@@ -1,20 +1,28 @@
 import type { AnySchema } from "toolcraft-schema";
 type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
+type JsonSchemaNode = JsonSchema | boolean;
 export interface JsonSchema {
-    $defs?: Record<string, JsonSchema>;
+    [keyword: string]: unknown;
+    $defs?: Record<string, JsonSchemaNode>;
     $ref?: string;
     additionalProperties?: boolean | JsonSchema;
-    allOf?: readonly JsonSchema[];
-    anyOf?: readonly JsonSchema[];
+    allOf?: readonly JsonSchemaNode[];
+    anyOf?: readonly JsonSchemaNode[];
     const?: unknown;
     default?: unknown;
     description?: string;
     enum?: readonly unknown[];
-    items?: JsonSchema;
+    items?: JsonSchemaNode | readonly JsonSchemaNode[];
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    minItems?: number;
+    maxItems?: number;
     nullable?: boolean;
-    oneOf?: readonly JsonSchema[];
+    oneOf?: readonly JsonSchemaNode[];
     pattern?: string;
-    properties?: Record<string, JsonSchema>;
+    properties?: Record<string, JsonSchemaNode>;
     required?: readonly string[];
     type?: JsonSchemaType | readonly JsonSchemaType[];
 }