@mcpcloud/runtime 0.15.0 → 0.17.2

package/dist/tool-errors.d.ts

@@ -97,6 +97,10 @@ export declare function mustRethrow(error: unknown): boolean;
  * clients reading `content[0].text` see exactly what they saw before.
  */
 export declare function toToolErrorResult(error: unknown): CallToolResult;
+/** What the client declared it can do, when the era makes that knowable. */
+export interface ClientCapabilitySnapshot {
+    elicitation?: unknown;
+}
 /**
  * Run a tool handler, converting a throw into a classified error result.
  *
@@ -110,4 +114,10 @@ export declare function toToolErrorResult(error: unknown): CallToolResult;
 export declare function runToolHandler(invoke: () => Promise<CallToolResult>, options?: {
     era?: 'legacy' | 'modern';
     inputRequired?: InputRequiredBuilder;
+    /**
+     * The client's declared capabilities, read at call time. A function
+     * because the value is per-request on the 2026-07-28 era, and `undefined`
+     * means "not knowable here" rather than "declared nothing".
+     */
+    clientCapabilities?: () => ClientCapabilitySnapshot | null | undefined;
 }): Promise<CallToolResult>;

package/dist/tool-input-schema.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The bridge between a tool's stored JSON Schema and the MCP SDK.
+ *
+ * WHY THIS EXISTS — the schema an agent reads used to be a translation.
+ *
+ * `registerTool` takes a Standard Schema, and the only one we had was Zod, so
+ * the runtime compiled each tool's stored JSON Schema into a Zod object and
+ * handed that over. The SDK then serialized the Zod object back to JSON Schema
+ * to answer `tools/list`. Nothing needed the round trip, and it was lossy in
+ * both directions:
+ *
+ *   - `z.number().int()` serializes with JavaScript's safe-integer range, so a
+ *     `limit` whose real ceiling is 100 advertised a floor of
+ *     -9007199254740991. Both integrators reported this as noise their agents
+ *     had to read past; neither contract contained such a bound.
+ *   - `default`, `examples`, `format`, `title` and every other annotation the
+ *     compiler has no Zod equivalent for were dropped. A contract's
+ *     `default: 50` never reached the client.
+ *
+ * So the tool now advertises the stored schema VERBATIM, and validates with
+ * the runtime's own validator — the same `describeInputIssues` the generated
+ * handler calls. One schema, one validator, no translation layer between the
+ * contract and the agent.
+ *
+ * `jsonSchemaToZodObject` stays exported for callers that genuinely want a Zod
+ * object; it is simply no longer in the path between a tool and its client.
+ */
+/**
+ * The shape `registerTool` accepts: Standard Schema's validate half plus the
+ * JSON Schema half the SDK reads to fill in `tools/list`.
+ *
+ * Declared structurally rather than imported. The SDK exports these as types
+ * only, and typing them here keeps this module readable without pinning it to
+ * one SDK entry point's type layout.
+ */
+export interface ToolInputStandardSchema {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => {
+            readonly value: unknown;
+            readonly issues?: undefined;
+        } | {
+            readonly issues: ReadonlyArray<{
+                readonly message: string;
+            }>;
+        };
+        readonly jsonSchema: {
+            readonly input: () => Record<string, unknown>;
+            readonly output: () => Record<string, unknown>;
+        };
+    };
+}
+/**
+ * Wrap a tool's stored JSON Schema for `registerTool`.
+ *
+ * `toolName` is carried only so a rejection reads the same whether the SDK
+ * caught it or the handler did.
+ */
+export declare function toolInputStandardSchema(toolName: string, schema: unknown): ToolInputStandardSchema;

package/dist/validation.d.ts

@@ -14,4 +14,13 @@ export declare function rankClosestNames(unknownName: string, knownNames: readon
     suggestion: string | null;
     nearest: string[];
 };
+/**
+ * Every way this input fails the schema, as `"/path message"` lines — the same
+ * strings `assertValidInput` puts in a `ToolInputError`, and empty when the
+ * input is valid.
+ *
+ * Exported for `toolInputStandardSchema`, so the check the MCP SDK runs before
+ * a handler is reached is THIS check and not a second opinion.
+ */
+export declare function describeInputIssues(schema: Record<string, unknown>, input: unknown): string[];
 export declare function assertValidInput<T>(toolName: string, schema: Record<string, unknown>, input: unknown): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpcloud/runtime",
-  "version": "0.15.0",
+  "version": "0.17.2",
   "description": "MCPCloud generated-server runtime: transports, config, upstream auth/HTTP, validation, projection, and discovery for MCP servers built on MCPCloud.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",