holon-sh 0.0.1-dev.3 → 0.0.1-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holon-sh",
-  "version": "0.0.1-dev.3",
+  "version": "0.0.1-dev.4",
   "description": "Typed MCP clients and app view resources for Node.js.",
   "repository": {
     "type": "git",

package/protocol.d.ts

@@ -1,9 +1,11 @@
-import type { CallToolRequest, CallToolResult, InputRequiredResult, InputResponses, ListToolsResult, RequestOptions } from "@modelcontextprotocol/client";
+import type { CallToolRequest, CallToolResult, ClientCapabilities as McpClientCapabilities, InputRequiredResult, InputResponses, ListToolsResult, RequestOptions } from "@modelcontextprotocol/client";
 
 /** Bearer-token or OAuth provider accepted by the MCP transport. */
 export type AuthProvider =
   | { token(): Promise<string | undefined>; onUnauthorized?(context: unknown): Promise<void> }
   | { tokens(): unknown; redirectUrl: unknown; clientMetadata: unknown };
+/** MCP client capabilities, such as `{ elicitation: { form: {} } }`. */
+export type ClientCapabilities = McpClientCapabilities;
 
 /** MCP request options, including AbortSignal and timeout in milliseconds. Input-required responses are enabled by the runtime. */
 export type CallOptions = Omit<RequestOptions, "allowInputRequired">;
@@ -11,9 +13,11 @@ export type CallOptions = Omit<RequestOptions, "allowInputRequired">;
 export type CallMetadata = Omit<CallToolRequest["params"], "name" | "arguments"> & { inputResponses?: InputResponses; requestState?: string };
 /** @internal */
 type Fields<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+/** Successful tool result with contract-typed structured content. */
+export type CompleteResult<Output> = Omit<Fields<CallToolResult>, "structuredContent" | "isError"> & { resultType: "complete"; isError?: false; structuredContent: Output };
 /** Full tool result: successful typed output, an application error, or an input-required continuation. */
 export type ToolResult<Output> =
-  | (Omit<Fields<CallToolResult>, "structuredContent" | "isError"> & { resultType: "complete"; isError?: false; structuredContent: Output })
+  | CompleteResult<Output>
   | (Omit<Fields<CallToolResult>, "structuredContent" | "isError"> & { resultType: "complete"; isError: true; structuredContent?: unknown })
   | InputRequiredResult;
 
@@ -37,8 +41,8 @@ export interface ToolClient<I, O, R> {
     readonly read: (options?: CallOptions) => Promise<R[U]>;
     readonly watch: (onChange: (value: R[U]) => void | Promise<void>, options?: { signal?: AbortSignal }) => Promise<void>;
   } };
-  /** Convenience methods returning structured output. Error or input-required results throw ToolCallError. Reserved object method names remain callable through callTool. */
-  readonly tools: { readonly [K in Exclude<keyof I, "then" | "toJSON" | "toString" | "valueOf" | "toLocaleString">]: (input: I[K], options?: CallOptions) => Promise<K extends keyof O ? O[K] : unknown> };
+  /** Convenience methods returning structured output, or the complete result for a tool without an output schema. Error or input-required results throw ToolCallError. Reserved object method names remain callable through callTool. */
+  readonly tools: { readonly [K in Exclude<keyof I, "then" | "toJSON" | "toString" | "valueOf" | "toLocaleString">]: (input: I[K], options?: CallOptions) => Promise<K extends keyof O ? O[K] : CompleteResult<unknown>> };
   /** Return the full MCP result, preserving error and input-required results. Arguments and successful output are contract-validated. */
   readonly callTool: <K extends keyof I & string>(request: CallMetadata & { name: K; arguments: I[K] }, options?: CallOptions) => Promise<ToolResult<K extends keyof O ? O[K] : unknown>>;
 }

package/runtime.d.ts

@@ -1,6 +1,6 @@
-import type { AuthProvider, CallOptions, ToolClient } from "./protocol.js";
+import type { AuthProvider, CallOptions, ClientCapabilities, ToolClient } from "./protocol.js";
 export { ToolCallError } from "./protocol.js";
-export type { AuthProvider, CallOptions, CallMetadata, ToolResult, ToolClient } from "./protocol.js";
+export type { AuthProvider, CallOptions, CallMetadata, ClientCapabilities, ToolResult, ToolClient } from "./protocol.js";
 
 /** Connection settings for an MCP endpoint. */
 export interface Binding {
@@ -14,6 +14,8 @@ export interface Binding {
   installationUID?: string;
   /** Close the session after every call instead of keeping one connection open. */
   scoped?: boolean;
+  /** Client capabilities declared to the server. On protocol 2026-07-28 every request carries them in `_meta["io.modelcontextprotocol/clientCapabilities"]` ([spec](https://modelcontextprotocol.io/specification/2026-07-28/client/elicitation#capabilities)); declare `{ elicitation: { form: {} } }` to receive form elicitations in input-required results. */
+  capabilities?: ClientCapabilities;
 }
 /** Alias for an endpoint binding. */
 export type EndpointBinding = Binding;

package/runtime.mjs

@@ -71,7 +71,8 @@ export function createApps(identity, contracts, bindings, options) {
     const current = () => binding ?? (bindings ? undefined : resolve(name));
     let connection;
     const connect = resolved => {
-      const client = new Client({ name: identity.name, version: identity.version }, { versionNegotiation: { mode: "auto" } });
+      // On 2026-07-28 the client sends these capabilities in every request's _meta: https://github.com/modelcontextprotocol/typescript-sdk/blob/fcef852f6cdafea07f36cf6fae69b37c8adf85be/packages/client/src/client/client.ts#L700-L711
+      const client = new Client({ name: identity.name, version: identity.version }, { capabilities: resolved.capabilities, versionNegotiation: { mode: "auto" } });
       const transport = new StreamableHTTPClientTransport(new URL(resolved.endpoint), { authProvider: resolved.authProvider, fetch: resolved.fetch, requestInit: { credentials: "include", redirect: "error", headers: resolved.installationUID ? { "X-Holon-Installation-UID": resolved.installationUID } : {} } });
       const current = { client, close: async () => {
         await transport.close();
@@ -131,7 +132,7 @@ export function createApps(identity, contracts, bindings, options) {
       tools[tool.name] = async (input, options) => {
         const result = await callTool({ name: tool.name, arguments: input }, options);
         if (result.resultType === "input_required" || result.isError) throw new ToolCallError(name, tool.name, result);
-        return result.structuredContent;
+        return tool.outputSchema ? result.structuredContent : result;
       };
     }
     const resources = Object.create(null);