toolcraft 0.0.430 → 0.0.432

package/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.93",
+      "version": "0.1.94",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.430",
+      "version": "0.0.432",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.430",
+      "version": "0.0.432",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.93",
+      "version": "0.1.94",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.430",
+      "version": "0.0.432",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.430",
+      "version": "0.0.432",
       "license": "MIT"
     },
     {

package/dist/index.d.ts

@@ -247,7 +247,7 @@ export declare function cloneCommandNode<TNode extends CommandNode<any>>(node: T
 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";
+export { S, toJsonSchema, withStandardSchema } from "./schema.js";
 export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, ServiceUnavailableError, UnprocessableEntityError, createHttpError } from "./http-errors.js";
 export type { HttpErrorRequest, HttpErrorResponse } from "./http-errors.js";
 export { ApprovalDeclinedError, ToolcraftBugError, UserError, isUserError };
@@ -260,5 +260,5 @@ 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, ValidationOptions, ValidationResult } from "./schema.js";
+export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonSchemaOptions, Input, Output, StandardSchema, Standardized, StandardIssue, StandardResult, StandardJsonSchemaOptions, 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

@@ -564,7 +564,7 @@ export function hasMcpProxyConfig(group) {
     const children = config?.children ?? group.children;
     return children.some((child) => child.kind === "group" && hasMcpProxyConfig(child));
 }
-export { S, toJsonSchema } from "./schema.js";
+export { S, toJsonSchema, withStandardSchema } from "./schema.js";
 export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, ServiceUnavailableError, UnprocessableEntityError, createHttpError } from "./http-errors.js";
 export { ApprovalDeclinedError, ToolcraftBugError, UserError, isUserError };
 export { suggest } from "./suggest.js";

package/dist/schema-standard.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema-standard.compile-check.js

@@ -0,0 +1,4 @@
+import { S } from "./index.js";
+import { withStandardSchema } from "./schema.js";
+const ignoredSchema = S.Object({ limit: S.Optional(S.Number({ default: 10 })) });
+withStandardSchema(structuredClone(ignoredSchema));

package/dist/schema.d.ts

@@ -1,2 +1,2 @@
-export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate } from "toolcraft-schema";
-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 "toolcraft-schema";
+export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate, withStandardSchema } from "toolcraft-schema";
+export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonSchemaOptions, Input, Output, StandardSchema, Standardized, StandardIssue, StandardResult, StandardJsonSchemaOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult } from "toolcraft-schema";

package/dist/schema.js

@@ -1 +1 @@
-export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate } from "toolcraft-schema";
+export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate, withStandardSchema } from "toolcraft-schema";

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

@@ -73,6 +73,13 @@ By default, programmatic `listenHttp()` uses:
 
 `path` is normalized, so `"mcp"` and `"/mcp"` serve the same endpoint.
 
+The same `.tool()` and `.registerTool()` APIs accept Toolcraft schemas and
+Zod 4.5.4 schemas directly through Standard Schema and Standard JSON Schema.
+No adapter or Zod dependency is added by this package. Handlers receive inferred,
+parsed arguments with defaults and transforms applied; asynchronous refinements
+are awaited. This also works with `createFetchServer` from
+`tiny-http-mcp-server/fetch`.
+
 ### CLI
 
 The package ships a `tiny-http-mcp-server` binary:

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

@@ -18,7 +18,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.93",
+      "version": "0.1.94",
       "license": "MIT"
     },
     {
@@ -28,7 +28,7 @@
     },
     {
       "name": "tiny-stdio-mcp-server",
-      "version": "0.1.27",
+      "version": "0.1.29",
       "license": "MIT"
     },
     {

package/node_modules/tiny-http-mcp-server/dist/fetch.d.ts

@@ -1,6 +1,6 @@
-import { type CallToolResult, type HandlerRequestContext, type InputRequiredResult, type ServerOptions, type ToolDefinition, type ToolReturn, type TypedSchema, type TypedOutputSchema } from "tiny-stdio-mcp-server/core";
+import { type CallToolResult, type HandlerRequestContext, type InputRequiredResult, type ServerOptions, type ToolDefinition, type ToolReturn, type ToolInputSchema, type ToolOutputSchema } from "tiny-stdio-mcp-server/core";
 export { defineSchema, ToolError } from "tiny-stdio-mcp-server/core";
-export type { CallToolResult, TypedSchema, TypedOutputSchema } from "tiny-stdio-mcp-server/core";
+export type { CallToolResult, TypedSchema, TypedOutputSchema, ToolInputSchema, ToolOutputSchema } from "tiny-stdio-mcp-server/core";
 export interface FetchServerOptions extends ServerOptions {
     /** Defaults to 1 MiB. Enforced while reading the stream. */
     maxRequestBytes?: number;
@@ -15,7 +15,7 @@ export interface FetchToolContext<TContext> extends HandlerRequestContext {
 }
 export type FetchToolHandler<TIn, TContext, TOut = ToolReturn> = (input: TIn, context: FetchToolContext<TContext>) => TOut | CallToolResult | InputRequiredResult | Promise<TOut | CallToolResult | InputRequiredResult>;
 export interface FetchServer<TContext = undefined> {
-    tool<TIn, TOut = never>(name: string, description: string, schema: TypedSchema<TIn>, handler: FetchToolHandler<TIn, TContext, TOut>, outputSchema?: TypedOutputSchema<TOut>): FetchServer<TContext>;
+    tool<TIn, TOut = never>(name: string, description: string, schema: ToolInputSchema<TIn>, handler: FetchToolHandler<TIn, TContext, TOut>, outputSchema?: ToolOutputSchema<TOut>): FetchServer<TContext>;
     registerTool<TIn, TOut = never>(definition: Omit<ToolDefinition<TIn, TOut>, "handler">, handler: FetchToolHandler<TIn, TContext, TOut>): FetchServer<TContext>;
     fetch(request: Request, ...context: undefined extends TContext ? [context?: TContext] : [context: TContext]): Promise<Response>;
 }

package/node_modules/tiny-http-mcp-server/dist/http-server.d.ts

@@ -1,5 +1,5 @@
 import { type IncomingMessage, type ServerResponse } from "node:http";
-import { type Server, type ServerOptions, type ToolDefinition, type CallToolResult, type InputRequiredResult, type HandlerRequestContext, type ToolReturn, type TypedSchema, type TypedOutputSchema } from "tiny-stdio-mcp-server";
+import { type Server, type ServerOptions, type ToolDefinition, type CallToolResult, type InputRequiredResult, type HandlerRequestContext, type ToolReturn, type ToolInputSchema, type ToolOutputSchema } from "tiny-stdio-mcp-server";
 import { type AuthenticatedIncomingMessage, type TokenVerifier, type VerifiedAccessToken, type RequestAuthInfo } from "./auth.js";
 import { type HttpObservabilityEvent, type StreamableHttpTransportOptions } from "./http-transport.js";
 export interface ProtectedResourceMetadataOptions {
@@ -33,7 +33,7 @@ export interface HttpServerHandle {
     closeAllConnections(): void;
 }
 export interface HttpServer extends Omit<Server, "tool" | "registerTool"> {
-    tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: HttpToolHandler<TIn, TOut>, outputSchema?: TypedOutputSchema<TOut>): HttpServer;
+    tool<TIn, TOut = never>(name: string, description: string, inputSchema: ToolInputSchema<TIn>, handler: HttpToolHandler<TIn, TOut>, outputSchema?: ToolOutputSchema<TOut>): HttpServer;
     registerTool<TIn, TOut = never>(definition: Omit<ToolDefinition<TIn, TOut>, "handler">, handler: HttpToolHandler<TIn, TOut>): HttpServer;
     listenHttp(options?: HttpListenOptions): Promise<HttpServerHandle>;
     handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void>;

package/node_modules/tiny-http-mcp-server/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { createServer, defineSchema, Image, Audio, File, toContentBlocks, fileTypeFromBuffer, JSON_RPC_ERROR_CODES, ToolError } from "tiny-stdio-mcp-server";
-export type { Server, MessageRequestContext, MessageSession, MessageSessionContext, TypedSchema, TypedOutputSchema, ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, ToolReturn, ServerOptions, ToolHandler, HandlerRequestContext, InputRequiredResult, ToolDefinition, Tool, ToolAnnotations, ToolExecution, Icon, ContentAnnotations, ResourceLink, CallToolResult, PromptContentItem, PromptArgument, Prompt, PromptMessage, GetPromptResult, PromptHandler, PromptDefinition, Resource, ResourceTemplate, ResourceContents, ReadResourceResult, ResourceHandler, ResourceDefinition, ResourceTemplateDefinition, HandleResult, ContentItem, JSONSchema, OutputSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult, DiscoverResult } from "tiny-stdio-mcp-server";
+export type { Server, MessageRequestContext, MessageSession, MessageSessionContext, TypedSchema, TypedOutputSchema, ToolInputSchema, ToolOutputSchema, ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, ToolReturn, ServerOptions, ToolHandler, HandlerRequestContext, InputRequiredResult, ToolDefinition, Tool, ToolAnnotations, ToolExecution, Icon, ContentAnnotations, ResourceLink, CallToolResult, PromptContentItem, PromptArgument, Prompt, PromptMessage, GetPromptResult, PromptHandler, PromptDefinition, Resource, ResourceTemplate, ResourceContents, ReadResourceResult, ResourceHandler, ResourceDefinition, ResourceTemplateDefinition, HandleResult, ContentItem, JSONSchema, OutputSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult, DiscoverResult } from "tiny-stdio-mcp-server";
 export { createExpressMiddleware, createExpressOAuthHandlers, createProtectedResourceMetadataRouter } from "./express-middleware.js";
 export type { CreateExpressOAuthHandlersOptions } from "./express-middleware.js";
 export { createHttpServer, createProtectedResourceMetadataDocument } from "./http-server.js";

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

@@ -1,6 +1,6 @@
 {
   "name": "tiny-http-mcp-server",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Minimal MCP server over HTTP built on tiny-stdio-mcp-server",
   "type": "module",
   "main": "dist/index.js",

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

@@ -1,6 +1,6 @@
 # tiny-stdio-mcp-server
 
-Minimal [Model Context Protocol](https://modelcontextprotocol.io) server for Node.js. Zero runtime dependencies, type-safe tool definitions, rich content helpers for images/audio/files.
+Minimal [Model Context Protocol](https://modelcontextprotocol.io) server for Node.js. Type-safe tool definitions, rich content helpers for images/audio/files.
 
 ## Install
 
@@ -89,14 +89,52 @@ server.tool(
 );
 ```
 
-Output schemas must have `type: "object"` at the root because MCP structured content is an object. Otherwise, any schema accepted by Ajv is supported, including composition keywords, nullable type unions, and local `$defs`/`$ref` references. Input and output schemas compile synchronously during `.tool()` or `.registerTool()` registration, so malformed schemas throw immediately instead of failing on the first tool call.
+Object output schemas work across MCP versions; modern MCP also supports other JSON output types. Otherwise, supported JSON Schema keywords are accepted, including composition keywords, nullable type unions, and local `$defs`/`$ref` references. Input and output schemas compile synchronously during `.tool()` or `.registerTool()` registration, so malformed schemas throw immediately instead of failing on the first tool call.
 
-Successful structured results must satisfy `outputSchema`. Validation failures use JSON-RPC `-32602` for inputs and `-32603` for outputs, with Ajv's formatted error text in the message and the raw Ajv error array in `error.data`. Explicit handler results with `isError: true` are passed through unchanged and are exempt from structured-content and output-schema validation.
+Successful structured results must satisfy `outputSchema`. Validation failures use JSON-RPC `-32602` for inputs and `-32603` for outputs, with formatted validation details in the message and the issue array in `error.data`. Explicit handler results with `isError: true` are passed through unchanged and are exempt from structured-content and output-schema validation.
 
 Tools whose natural result is prose, images, audio, files, or other content blocks should omit `outputSchema` and keep returning content.
 
 Handlers can throw `ToolError` to return a JSON-RPC tool error with a specific code, message, and optional structured `data` payload. The server forwards that `data` field in the JSON-RPC error response so clients can inspect machine-readable failure details.
 
+### Standard schemas, including Zod
+
+Pass schemas implementing Standard Schema v1 and Standard JSON Schema v1
+straight to `.tool()` or `.registerTool()`. Toolcraft schemas and Zod 4.5.4
+support both interfaces. Existing `defineSchema` and raw JSON Schema inputs
+continue to work on the same server.
+
+```ts
+import { z } from "zod"; // Your application's existing dependency
+import { createServer } from "tiny-stdio-mcp-server";
+
+createServer({ name: "search", version: "1" }).tool(
+  "search",
+  "Search",
+  z.object({ query: z.string(), limit: z.number().default(10) }),
+  ({ query, limit }) => `${query}: ${limit}`
+);
+```
+
+Tiny MCP has no Zod dependency, peer dependency, imports, or adapter setup.
+Detection uses the standard interfaces. Older libraries exposing validation
+without JSON Schema conversion fail clearly during registration.
+
+Discovery uses the schema's input JSON Schema and, when supplied, its output
+JSON Schema. Runtime parsing uses the original library, preserving defaults,
+coercions, transforms, refinements, and asynchronous validation. Handler arguments
+are inferred from parsed output; a handler's return value is checked against the
+output schema's accepted input. Output parsing runs once before structured content
+and fallback text are produced. Explicit error results skip output parsing.
+
+Input wire schemas must describe objects. Output schemas may describe any JSON
+value for modern MCP; older clients receive object structured content or text
+fallbacks for other values. Conversion failures occur at registration. Custom
+refinements remain runtime checks and cannot always appear in discovery JSON
+Schema. Async parsing shares the tool timeout and concurrency limits.
+`validateToolArguments: false` disables input parsing, including defaults and
+transforms; handlers then receive the original arguments.
+
 ### `.listen()`
 
 Start listening on stdin/stdout (standard MCP stdio transport).

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

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.430",
+      "version": "0.0.432",
       "license": "MIT"
     }
   ]

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

@@ -2,7 +2,7 @@
 export { createProtocolServer } from "./protocol-server.js";
 export type { Server, MessageRequestContext, MessageSession } from "./protocol-server.js";
 export { defineSchema } from "./schema.js";
-export type { TypedSchema, TypedOutputSchema } from "./schema.js";
+export type { TypedSchema, TypedOutputSchema, ToolInputSchema, ToolOutputSchema } from "./schema.js";
 export { ToolError } from "./types.js";
 export type { CallToolResult, HandlerRequestContext, InputRequiredResult, ServerOptions, ToolDefinition } from "./types.js";
 export type { ToolReturn } from "./content/convert.js";

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

@@ -1,7 +1,7 @@
 export { createServer } from "./server.js";
 export type { CustomMethodHandler, MessageHandler, MessageRequestContext, MessageSession, MessageSessionContext, Server } from "./server.js";
 export { defineSchema } from "./schema.js";
-export type { TypedSchema, TypedOutputSchema } from "./schema.js";
+export type { TypedSchema, TypedOutputSchema, ToolInputSchema, ToolOutputSchema } from "./schema.js";
 export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, DEFAULT_FROM_URL_MAX_BYTES } from "./content/index.js";
 export type { ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, FromUrlOptions } from "./content/index.js";
 export type { ToolReturn } from "./content/index.js";

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

@@ -1,12 +1,12 @@
 import type { ServerOptions, ToolDefinition, ToolHandler, HandleResult, Prompt, PromptHandler, Resource, ResourceHandler, ResourceTemplate, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
-import type { TypedSchema, TypedOutputSchema } from "./schema.js";
+import type { ToolInputSchema, ToolOutputSchema } from "./schema.js";
 interface StdioRuntime {
     readline: typeof import("node:readline");
     StdioInput: typeof import("./stdio-input.js").StdioInput;
     StdioOutput: typeof import("./stdio-output.js").StdioOutput;
 }
 export interface Server {
-    tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: ToolHandler<TIn, TOut>, outputSchema?: TypedOutputSchema<TOut>): Server;
+    tool<TIn, TOut = never>(name: string, description: string, inputSchema: ToolInputSchema<TIn>, handler: ToolHandler<TIn, TOut>, outputSchema?: ToolOutputSchema<TOut>): Server;
     registerTool<TIn, TOut = never>(definition: Omit<ToolDefinition<TIn, TOut>, "handler">, handler: ToolHandler<TIn, TOut>): Server;
     prompt(definition: Prompt, handler: PromptHandler): Server;
     resource(definition: Resource, handler: ResourceHandler): Server;

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

@@ -1,4 +1,4 @@
-import { compileJsonSchema, formatIssues, normalizeLegacyNullability } from "toolcraft-schema";
+import { prepareToolSchema, formatToolIssues } from "./tool-schema.js";
 import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
 import { parseMessage, formatSuccessResponse, formatErrorResponse, isRequestId } from "./jsonrpc.js";
 import { parseUriTemplate } from "./uri-template.js";
@@ -38,15 +38,6 @@ function createLifecycleState(listener, supportNotifications, supportResourceSub
         listener
     };
 }
-function compileToolSchema(schema) {
-    try {
-        return compileJsonSchema(schema);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`schema is invalid: ${message}`, { cause: error });
-    }
-}
 export function createProtocolServer(options, stdio) {
     if (options.toolCallTimeoutMs !== undefined &&
         (!Number.isInteger(options.toolCallTimeoutMs) || options.toolCallTimeoutMs <= 0)) {
@@ -215,15 +206,15 @@ export function createProtocolServer(options, stdio) {
                 if (headerError !== undefined)
                     return { error: { code: -32020, message: headerError } };
             }
-            const inputValidation = tool.inputValidator.validate(toolArgs);
-            if (options.validateToolArguments !== false && !inputValidation.ok) {
-                return {
-                    error: {
-                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-                        message: `Invalid tool arguments: ${formatIssues(inputValidation.issues)}`,
-                        data: inputValidation.issues
-                    }
-                };
+            // Raw JSON Schema validation is synchronous and can reject before taking a queue slot.
+            if (options.validateToolArguments !== false && !tool.inputValidator.standard) {
+                const validation = tool.inputValidator.validate(toolArgs);
+                if (validation.issues !== undefined)
+                    return { error: {
+                            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                            message: `Invalid tool arguments: ${formatToolIssues(validation.issues)}`,
+                            data: validation.issues
+                        } };
             }
             try {
                 let handlerResult;
@@ -242,7 +233,20 @@ export function createProtocolServer(options, stdio) {
                     const release = await toolAdmission.acquire(admissionSignal);
                     try {
                         admissionSignal.throwIfAborted();
-                        return await tool.handler(toolArgs, { ...handlerContext, signal: admissionSignal });
+                        let parsedArgs = toolArgs;
+                        if (options.validateToolArguments !== false && tool.inputValidator.standard) {
+                            const inputValidation = await tool.inputValidator.validate(toolArgs);
+                            if (inputValidation.issues !== undefined) {
+                                throw new ToolError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, `Invalid tool arguments: ${formatToolIssues(inputValidation.issues)}`, inputValidation.issues);
+                            }
+                            parsedArgs = inputValidation.value;
+                        }
+                        admissionSignal.throwIfAborted();
+                        const returned = await tool.handler(parsedArgs, { ...handlerContext, signal: admissionSignal });
+                        admissionSignal.throwIfAborted();
+                        if (modern && isInputRequiredResult(returned))
+                            return returned;
+                        return await normalizeValidatedToolResult(returned, tool, modern);
                     }
                     finally {
                         release();
@@ -274,15 +278,7 @@ export function createProtocolServer(options, stdio) {
                     lifecycle.admissions.delete(admissionController);
                     sessionSignal.removeEventListener("abort", cancelAdmission);
                 }
-                if (modern && isInputRequiredResult(handlerResult))
-                    return { result: handlerResult };
-                const outputSchema = modern || tool.outputSchema?.type === "object" ? tool.outputSchema : undefined;
-                const result = normalizeToolResult(handlerResult, tool.outputSchema, modern);
-                const outputValidation = outputSchema === undefined ? undefined : tool.outputValidator?.validate(result.structuredContent);
-                if (result.isError !== true && outputValidation !== undefined && !outputValidation.ok) {
-                    throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Invalid structured tool result: ${formatIssues(outputValidation.issues)}`, outputValidation.issues);
-                }
-                return { result };
+                return { result: handlerResult };
             }
             catch (err) {
                 if (err instanceof ToolError) {
@@ -614,15 +610,13 @@ export function createProtocolServer(options, stdio) {
             if (tools.has(name)) {
                 throw new Error(`Tool already registered: ${name}`);
             }
-            const inputSchemaSnapshot = normalizeLegacyNullability(inputSchema);
-            const outputSchemaSnapshot = outputSchema === undefined ? undefined : normalizeLegacyNullability(outputSchema);
-            const inputValidator = compileToolSchema(inputSchemaSnapshot);
+            const inputValidator = prepareToolSchema(inputSchema, "input");
+            const inputSchemaSnapshot = inputValidator.schema;
             assertObjectRootSchema(inputSchemaSnapshot, "inputSchema");
-            let outputValidator;
-            if (outputSchemaSnapshot !== undefined) {
+            const outputValidator = outputSchema === undefined ? undefined : prepareToolSchema(outputSchema, "output");
+            const outputSchemaSnapshot = outputValidator?.schema;
+            if (outputSchemaSnapshot !== undefined)
                 assertOutputSchema(outputSchemaSnapshot);
-                outputValidator = compileToolSchema(outputSchemaSnapshot);
-            }
             tools.set(name, {
                 name,
                 description,
@@ -640,19 +634,18 @@ export function createProtocolServer(options, stdio) {
             if (tools.has(definition.name)) {
                 throw new Error(`Tool already registered: ${definition.name}`);
             }
-            const descriptor = structuredClone(definition);
-            const inputSchema = normalizeLegacyNullability(descriptor.inputSchema);
-            const inputValidator = compileToolSchema(inputSchema);
+            const { inputSchema: sourceInput, outputSchema: sourceOutput, ...metadata } = definition;
+            const descriptor = structuredClone(metadata);
+            const inputValidator = prepareToolSchema(sourceInput, "input");
+            const inputSchema = inputValidator.schema;
             assertObjectRootSchema(inputSchema, "inputSchema");
-            let outputValidator;
-            if (descriptor.outputSchema !== undefined) {
-                descriptor.outputSchema = normalizeLegacyNullability(descriptor.outputSchema);
-                assertOutputSchema(descriptor.outputSchema);
-                outputValidator = compileToolSchema(descriptor.outputSchema);
-            }
+            const outputValidator = sourceOutput === undefined ? undefined : prepareToolSchema(sourceOutput, "output");
+            if (outputValidator !== undefined)
+                assertOutputSchema(outputValidator.schema);
             tools.set(definition.name, {
                 ...descriptor,
                 inputSchema,
+                ...(outputValidator === undefined ? {} : { outputSchema: outputValidator.schema }),
                 handler: handler,
                 inputValidator,
                 parameterHeaders: getParameterHeaders(inputSchema),
@@ -987,6 +980,26 @@ function isCallToolResult(value, modern) {
         value.isError !== undefined &&
         typeof value.isError !== "boolean");
 }
+async function normalizeValidatedToolResult(returned, tool, modern) {
+    const validator = tool.outputValidator;
+    if (validator?.standard && !(isCallToolResult(returned, modern) && returned.isError === true)) {
+        const envelope = isCallToolResult(returned, modern) ? returned : undefined;
+        const parsed = await validator.validate(envelope === undefined ? returned : envelope.structuredContent);
+        if (parsed.issues !== undefined) {
+            throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Invalid structured tool result: ${formatToolIssues(parsed.issues)}`, parsed.issues);
+        }
+        returned = envelope === undefined ? parsed.value : { ...envelope, structuredContent: parsed.value };
+    }
+    const result = normalizeToolResult(returned, tool.outputSchema, modern);
+    if (result.isError !== true && validator !== undefined && !validator.standard &&
+        (modern || tool.outputSchema?.type === "object")) {
+        const validation = await validator.validate(result.structuredContent);
+        if (validation.issues !== undefined) {
+            throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Invalid structured tool result: ${formatToolIssues(validation.issues)}`, validation.issues);
+        }
+    }
+    return result;
+}
 function normalizeToolResult(handlerResult, outputSchema, modern) {
     if (!modern && outputSchema !== undefined && outputSchema.type !== "object") {
         const result = normalizeToolResult(handlerResult, outputSchema, true);

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

@@ -1,4 +1,7 @@
 import type { JSONSchema, OutputSchema } from "./types.js";
+import type { StandardSchema } from "toolcraft-schema";
+export type ToolInputSchema<T> = TypedSchema<T> | StandardSchema<unknown, T>;
+export type ToolOutputSchema<T> = TypedOutputSchema<T> | StandardSchema<T, unknown>;
 type SchemaPropertyType = "string" | "number" | "integer" | "boolean" | "object" | "array";
 interface SchemaPropertyDef {
     type: SchemaPropertyType;

package/node_modules/tiny-stdio-mcp-server/dist/standard-schema.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/tiny-stdio-mcp-server/dist/standard-schema.compile-check.js

@@ -0,0 +1,15 @@
+import { S } from "toolcraft-schema";
+import { createServer, defineSchema } from "./index.js";
+const server = createServer({ name: "inference", version: "1" });
+const schema = S.Object({ count: S.Optional(S.Number({ default: 10 })) });
+server.tool("count", "Count", schema, ({ count }) => {
+    const result = count;
+    // @ts-expect-error The default produces a number, not a string.
+    const ignoredWrong = count;
+    return { count: result };
+}, S.Object({ count: S.Number() }));
+server.registerTool({ name: "registered", inputSchema: schema }, ({ count }) => String(count + 1));
+server.tool("transform", "Transform", transformed, ({ count }) => count.toFixed());
+server.tool("output", "Output", defineSchema({}), () => ({ count: "1" }), transformed);
+// @ts-expect-error The output parser requires a string before transformation.
+server.tool("invalid", "Invalid", defineSchema({}), () => ({ count: false }), transformed);

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

@@ -0,0 +1,13 @@
+import { type StandardIssue, type StandardResult } from "toolcraft-schema";
+import { type OutputSchema } from "./types.js";
+export type PreparedToolSchema = {
+    schema: OutputSchema;
+} & ({
+    standard: false;
+    validate(value: unknown): StandardResult<unknown>;
+} | {
+    standard: true;
+    validate(value: unknown): StandardResult<unknown> | Promise<StandardResult<unknown>>;
+});
+export declare function prepareToolSchema(source: unknown, io: "input" | "output"): PreparedToolSchema;
+export declare function formatToolIssues(issues: readonly StandardIssue[]): string;

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

@@ -0,0 +1,53 @@
+import { compileJsonSchema, normalizeLegacyNullability } from "toolcraft-schema";
+import { ToolError, JSON_RPC_ERROR_CODES } from "./types.js";
+export function prepareToolSchema(source, io) {
+    try {
+        let standard;
+        if (((typeof source === "object" && source !== null) || typeof source === "function") && "~standard" in source) {
+            standard = source["~standard"];
+            if (standard?.version !== 1 || typeof standard.validate !== "function") {
+                throw new Error("Expected Standard Schema v1 validation");
+            }
+            if (typeof standard.jsonSchema?.[io] !== "function") {
+                throw new Error("Expected Standard JSON Schema v1 conversion; upgrade the schema library or provide a JSON Schema");
+            }
+        }
+        const document = standard === undefined ? source : standard.jsonSchema[io]({ target: "draft-2020-12" });
+        if (typeof document !== "object" || document === null || Array.isArray(document)) {
+            throw new Error(`${io}Schema must be a JSON Schema object`);
+        }
+        const schema = normalizeLegacyNullability(document);
+        const compiled = compileJsonSchema(schema);
+        if (standard !== undefined)
+            return {
+                schema,
+                standard: true,
+                async validate(value) {
+                    try {
+                        return await standard.validate(value);
+                    }
+                    catch {
+                        throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, "Tool schema validation failed");
+                    }
+                }
+            };
+        return {
+            schema,
+            standard: false,
+            validate(value) {
+                const result = compiled.validate(value);
+                return result.ok ? { value: result.value } : { issues: result.issues };
+            }
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${io} schema is invalid: ${message}`, { cause: error });
+    }
+}
+export function formatToolIssues(issues) {
+    return issues.map((issue) => {
+        const path = issue.path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join("/");
+        return `${path ? `data/${path}` : "data"} ${issue.message}`;
+    }).join(", ");
+}

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

@@ -1,3 +1,4 @@
+import type { ToolInputSchema, ToolOutputSchema } from "./schema.js";
 export interface JSONRPCRequest {
     jsonrpc: "2.0";
     id: string | number | null;
@@ -270,8 +271,8 @@ export interface ToolDefinition<T = Record<string, unknown>, TOut = ToolReturn>
     name: string;
     title?: string;
     description?: string;
-    inputSchema: JSONSchema;
-    outputSchema?: OutputSchema;
+    inputSchema: ToolInputSchema<T>;
+    outputSchema?: ToolOutputSchema<TOut>;
     annotations?: ToolAnnotations;
     execution?: ToolExecution;
     icons?: Icon[];