functionalscript 0.38.0 → 0.40.0

package/fjs/protocol/mcp/module.f.d.ts

@@ -0,0 +1,239 @@
+import { unknown, type Unknown } from '../../media/json/module.f.ts';
+import type { Ts } from '../../types/rtti/ts/module.f.ts';
+import { type Operation, type Effect } from '../../effects/module.f.ts';
+import { type Key, type MemOp } from '../../effects/memory/module.f.ts';
+import { type Response } from '../json_rpc/module.f.ts';
+import type { Type } from '../../types/rtti/module.f.ts';
+/** Name + version pair sent in `initialize` requests and responses. */
+export declare const implementation: {
+    readonly name: import("../../types/rtti/module.f.ts").String;
+    readonly version: import("../../types/rtti/module.f.ts").String;
+};
+export type Implementation = Ts<typeof implementation>;
+/** Server capabilities advertised in the `initialize` response. */
+export declare const serverCapabilities: {
+    readonly tools: import("../../types/rtti/module.f.ts").Or<readonly [{
+        readonly listChanged: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Boolean, undefined]>;
+    }, undefined]>;
+};
+export type ServerCapabilities = Ts<typeof serverCapabilities>;
+/** Params for the `initialize` request. */
+export declare const initializeParams: {
+    readonly protocolVersion: import("../../types/rtti/module.f.ts").String;
+    readonly capabilities: typeof unknown;
+    readonly clientInfo: {
+        readonly name: import("../../types/rtti/module.f.ts").String;
+        readonly version: import("../../types/rtti/module.f.ts").String;
+    };
+};
+export type InitializeParams = Ts<typeof initializeParams>;
+/** Result for the `initialize` request. */
+export declare const initializeResult: {
+    readonly protocolVersion: import("../../types/rtti/module.f.ts").String;
+    readonly capabilities: {
+        readonly tools: import("../../types/rtti/module.f.ts").Or<readonly [{
+            readonly listChanged: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Boolean, undefined]>;
+        }, undefined]>;
+    };
+    readonly serverInfo: {
+        readonly name: import("../../types/rtti/module.f.ts").String;
+        readonly version: import("../../types/rtti/module.f.ts").String;
+    };
+    readonly instructions: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+};
+export type InitializeResult = Ts<typeof initializeResult>;
+/** Plain-text content item returned by a tool call. */
+export declare const textContent: {
+    readonly type: 'text';
+    readonly text: import("../../types/rtti/module.f.ts").String;
+};
+export type TextContent = Ts<typeof textContent>;
+/**
+ * A binary resource carried inside an {@link embeddedResource}: a base64
+ * `blob`, an addressing `uri`, and an optional `mimeType`. This is MCP's
+ * `BlobResource` shape — the idiomatic way to return typed binary content so a
+ * `mimeType` travels alongside the bytes and clients know how to route them.
+ */
+export declare const blobResource: {
+    readonly uri: import("../../types/rtti/module.f.ts").String;
+    readonly mimeType: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly blob: import("../../types/rtti/module.f.ts").String;
+};
+export type BlobResource = Ts<typeof blobResource>;
+/** An `EmbeddedResource` content item wrapping a {@link blobResource}. */
+export declare const embeddedResource: {
+    readonly type: 'resource';
+    readonly resource: {
+        readonly uri: import("../../types/rtti/module.f.ts").String;
+        readonly mimeType: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly blob: import("../../types/rtti/module.f.ts").String;
+    };
+};
+export type EmbeddedResource = Ts<typeof embeddedResource>;
+/**
+ * A single item in a `tools/call` result's `content` array: either plain
+ * {@link textContent} or an {@link embeddedResource} for typed binary. The
+ * `image` and `audio` variants are not modelled yet.
+ */
+export declare const contentItem: import("../../types/rtti/module.f.ts").Or<[{
+    readonly type: 'text';
+    readonly text: import("../../types/rtti/module.f.ts").String;
+}, {
+    readonly type: 'resource';
+    readonly resource: {
+        readonly uri: import("../../types/rtti/module.f.ts").String;
+        readonly mimeType: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly blob: import("../../types/rtti/module.f.ts").String;
+    };
+}]>;
+export type ContentItem = Ts<typeof contentItem>;
+/**
+ * A tool descriptor returned by `tools/list`.
+ * `inputSchema` is a JSON Schema object — use `toJsonSchema` to derive it from
+ * an rtti schema.
+ */
+export declare const tool: {
+    readonly name: import("../../types/rtti/module.f.ts").String;
+    readonly description: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly inputSchema: typeof unknown;
+};
+export type Tool = Ts<typeof tool>;
+/**
+ * Params for the `tools/list` request. `cursor` is an opaque pagination token
+ * from a previous `ToolsListResult.nextCursor`.
+ */
+export declare const toolsListParams: {
+    readonly cursor: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+};
+export type ToolsListParams = Ts<typeof toolsListParams>;
+export declare const toolsListResult: {
+    readonly tools: import("../../types/rtti/module.f.ts").Type1<"array", {
+        readonly name: import("../../types/rtti/module.f.ts").String;
+        readonly description: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly inputSchema: typeof unknown;
+    }>;
+    readonly nextCursor: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+};
+export type ToolsListResult = Ts<typeof toolsListResult>;
+export declare const toolsCallParams: {
+    readonly name: import("../../types/rtti/module.f.ts").String;
+    readonly arguments: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", typeof unknown>, undefined]>;
+};
+export type ToolsCallParams = Ts<typeof toolsCallParams>;
+export declare const toolsCallResult: {
+    readonly content: import("../../types/rtti/module.f.ts").Type1<"array", import("../../types/rtti/module.f.ts").Or<[{
+        readonly type: 'text';
+        readonly text: import("../../types/rtti/module.f.ts").String;
+    }, {
+        readonly type: 'resource';
+        readonly resource: {
+            readonly uri: import("../../types/rtti/module.f.ts").String;
+            readonly mimeType: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+            readonly blob: import("../../types/rtti/module.f.ts").String;
+        };
+    }]>>;
+    readonly isError: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Boolean, undefined]>;
+};
+export type ToolsCallResult = Ts<typeof toolsCallResult>;
+/** Per-method handlers for a hello-world MCP tool server. */
+export type McpHandlers<O extends Operation> = {
+    readonly toolsList: (params: ToolsListParams) => Effect<O, ToolsListResult>;
+    readonly toolsCall: (params: ToolsCallParams) => Effect<O, ToolsCallResult>;
+};
+/**
+ * A single declarative tool entry combining metadata, input schema, and type-safe handler.
+ *
+ * The handler receives pre-validated arguments of type `Ts<inputRtti>`, eliminating the need
+ * for manual validation or type casting. All validation is encapsulated in the entry.
+ */
+export type ToolEntry<O extends Operation> = {
+    readonly name: string;
+    readonly description: string;
+    readonly inputRtti: Type;
+    readonly handle: (args: Unknown) => Effect<O, ToolsCallResult>;
+};
+/**
+ * Creates a type-safe tool entry that binds an RTTI schema with a handler.
+ *
+ * The builder validates arguments at runtime using the RTTI and passes pre-validated
+ * arguments (typed as `Ts<T>`) to the handler. This eliminates manual validation
+ * boilerplate and type assertions.
+ *
+ * @param name - The tool name (used in `tools/call` requests)
+ * @param description - Human-readable description for `tools/list`
+ * @param inputRtti - Runtime type info for input validation
+ * @param handle - Handler receiving validated arguments of type `Ts<inputRtti>`
+ * @returns A `ToolEntry` ready to be added to a registry
+ */
+export declare const toolEntry: <T extends Type, O extends Operation>(name: string, description: string, inputRtti: T, handle: (args: Ts<T>) => Effect<O, ToolsCallResult>) => ToolEntry<O>;
+/**
+ * Helper to create a successful single-text-block tool result.
+ *
+ * @param text - The text to return to the client
+ * @returns A `ToolsCallResult` with the text content
+ */
+export declare const okResult: (text: string) => ToolsCallResult;
+/**
+ * Helper to create a tool-level error result with plain text explanation.
+ *
+ * @param text - The error message to return to the client
+ * @returns A `ToolsCallResult` with `isError: true` and the text explanation
+ */
+export declare const errorResult: (text: string) => ToolsCallResult;
+/**
+ * Builds `McpHandlers` from a registry of tool entries.
+ *
+ * This factory generates `toolsList` and `toolsCall` handlers that work with a
+ * declarative registry, eliminating boilerplate. The `toolsList` handler converts
+ * entries into MCP `Tool` descriptors, and `toolsCall` dispatches by name and
+ * delegates to the appropriate handler.
+ *
+ * @param registry - Array of tool entries
+ * @returns Complete `McpHandlers` ready for use with `mcpStep`
+ */
+export declare const fromRegistry: <O extends Operation>(registry: readonly ToolEntry<O>[]) => McpHandlers<O>;
+/** Top-level handler: maps a raw JSON value to a JSON-RPC response (or `null` for notifications). */
+export type Handle<O extends Operation> = (value: Unknown) => Effect<O, Response | null>;
+/** MCP error -32002: the client called a method before `initialize`. */
+export declare const notInitialized: import("../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+}>;
+/** State carried before the peer sends `initialize`. */
+export type Uninitialized = readonly ['uninitialized'];
+/** State after `initialize` response was sent but before `notifications/initialized` arrives. */
+export type Initializing = readonly ['initializing'];
+/** State carried after a successful `initialize` exchange. */
+export type InitializedState = true;
+/** The three phases of an MCP session. */
+export type McpSessionState = Uninitialized | Initializing | readonly ['initialized', InitializedState];
+/** Initial session state — always start here. */
+export declare const uninitializedState: McpSessionState;
+/** Static configuration supplied by the server implementer. */
+export type McpConfig = {
+    readonly serverInfo: Implementation;
+    readonly capabilities: ServerCapabilities;
+    readonly protocolVersion: string;
+};
+/**
+ * State-machine step for an MCP session using memory effects.
+ *
+ * Given configuration, handlers, and a memory key holding the session state,
+ * returns a function `(value) => Effect<MemOp | O, Response | null>`.
+ *
+ * Rules:
+ * - `ping` returns an empty success regardless of session state; non-object
+ *   params → -32602.
+ * - `initialize` is accepted only while uninitialized; a second call returns -32600.
+ *   On success the state moves to `initializing`, not `initialized`.
+ * - `notifications/initialized` (no `id`) transitions `initializing` → `initialized`;
+ *   a malformed one (non-object params) is ignored and the session stays gated;
+ *   other notifications are silently ignored in any state.
+ * - Any other method before `notifications/initialized` → error -32002 (not initialized).
+ * - Methods gated by a capability (e.g. `tools/list`) → -32601 when the capability
+ *   is absent.
+ * - `tools/list` params (an optional pagination `cursor`) are validated and passed
+ *   to the handler; invalid params → -32602.
+ */
+export declare const mcpStep: ({ protocolVersion, capabilities, serverInfo, }: McpConfig) => <O extends Operation>(handlers: McpHandlers<O>) => (stateKey: Key<McpSessionState>) => (value: Unknown) => Effect<MemOp | O, Response | null>;

package/fjs/protocol/mcp/module.f.js

@@ -0,0 +1,272 @@
+/**
+ * MCP (Model Context Protocol) message schemas — minimal subset for a
+ * hello-world tool server.
+ *
+ * Covers the three exchanges a minimal server must handle:
+ * - `initialize` / `notifications/initialized` lifecycle
+ * - `tools/list` — advertise available tools
+ * - `tools/call` — invoke a tool and return text content
+ *
+ * Each schema is both a runtime decoder (`validate(schema)`) and a static
+ * TypeScript type (`Ts<typeof schema>`). Transport framing (stdio) and the
+ * JSON-RPC dispatcher are in `fjs/protocol/json_rpc/module.f.ts`.
+ *
+ * @module
+ */
+import { boolean, string, option, array, record, or } from '../../types/rtti/module.f.js';
+import { unknown } from '../../media/json/module.f.js';
+import { pure, step } from '../../effects/module.f.js';
+import { read, write } from '../../effects/memory/module.f.js';
+import { decodeRequest, rpcError, invalidRequest, invalidParams, methodNotFound, jsonrpc, } from '../json_rpc/module.f.js';
+import { validate } from '../../types/rtti/validate/module.f.js';
+import { toJsonSchema } from '../../media/json/schema/module.f.js';
+// ── Shared ─────────────────────────────────────────────────────────────────────
+/** Name + version pair sent in `initialize` requests and responses. */
+export const implementation = {
+    name: string,
+    version: string,
+};
+// ── Capabilities ───────────────────────────────────────────────────────────────
+const toolsCapability = { listChanged: option(boolean) };
+/** Server capabilities advertised in the `initialize` response. */
+export const serverCapabilities = {
+    tools: option(toolsCapability),
+};
+// ── Lifecycle ──────────────────────────────────────────────────────────────────
+/** Params for the `initialize` request. */
+export const initializeParams = {
+    protocolVersion: string,
+    capabilities: unknown,
+    clientInfo: implementation,
+};
+/** Result for the `initialize` request. */
+export const initializeResult = {
+    protocolVersion: string,
+    capabilities: serverCapabilities,
+    serverInfo: implementation,
+    instructions: option(string),
+};
+// ── Content ────────────────────────────────────────────────────────────────────
+/** Plain-text content item returned by a tool call. */
+export const textContent = { type: 'text', text: string };
+/**
+ * A binary resource carried inside an {@link embeddedResource}: a base64
+ * `blob`, an addressing `uri`, and an optional `mimeType`. This is MCP's
+ * `BlobResource` shape — the idiomatic way to return typed binary content so a
+ * `mimeType` travels alongside the bytes and clients know how to route them.
+ */
+export const blobResource = {
+    uri: string,
+    mimeType: option(string),
+    blob: string,
+};
+/** An `EmbeddedResource` content item wrapping a {@link blobResource}. */
+export const embeddedResource = {
+    type: 'resource',
+    resource: blobResource,
+};
+/**
+ * A single item in a `tools/call` result's `content` array: either plain
+ * {@link textContent} or an {@link embeddedResource} for typed binary. The
+ * `image` and `audio` variants are not modelled yet.
+ */
+export const contentItem = or(textContent, embeddedResource);
+// ── Tools ──────────────────────────────────────────────────────────────────────
+/**
+ * A tool descriptor returned by `tools/list`.
+ * `inputSchema` is a JSON Schema object — use `toJsonSchema` to derive it from
+ * an rtti schema.
+ */
+export const tool = {
+    name: string,
+    description: option(string),
+    inputSchema: unknown,
+};
+/**
+ * Params for the `tools/list` request. `cursor` is an opaque pagination token
+ * from a previous `ToolsListResult.nextCursor`.
+ */
+export const toolsListParams = {
+    cursor: option(string),
+};
+export const toolsListResult = {
+    tools: array(tool),
+    nextCursor: option(string),
+};
+export const toolsCallParams = {
+    name: string,
+    arguments: option(record(unknown)),
+};
+export const toolsCallResult = {
+    content: array(contentItem),
+    isError: option(boolean),
+};
+/**
+ * Creates a type-safe tool entry that binds an RTTI schema with a handler.
+ *
+ * The builder validates arguments at runtime using the RTTI and passes pre-validated
+ * arguments (typed as `Ts<T>`) to the handler. This eliminates manual validation
+ * boilerplate and type assertions.
+ *
+ * @param name - The tool name (used in `tools/call` requests)
+ * @param description - Human-readable description for `tools/list`
+ * @param inputRtti - Runtime type info for input validation
+ * @param handle - Handler receiving validated arguments of type `Ts<inputRtti>`
+ * @returns A `ToolEntry` ready to be added to a registry
+ */
+export const toolEntry = (name, description, inputRtti, handle) => ({
+    name,
+    description,
+    inputRtti,
+    handle: (a) => {
+        const [t, r] = validate(inputRtti)(a);
+        return t === 'error'
+            ? pure(errorResult(`invalid arguments: ${r.message}`))
+            : handle(r);
+    }
+});
+/**
+ * Helper to create a successful single-text-block tool result.
+ *
+ * @param text - The text to return to the client
+ * @returns A `ToolsCallResult` with the text content
+ */
+export const okResult = (text) => ({ content: [{ type: 'text', text }] });
+/**
+ * Helper to create a tool-level error result with plain text explanation.
+ *
+ * @param text - The error message to return to the client
+ * @returns A `ToolsCallResult` with `isError: true` and the text explanation
+ */
+export const errorResult = (text) => ({ ...okResult(text), isError: true });
+/**
+ * Builds `McpHandlers` from a registry of tool entries.
+ *
+ * This factory generates `toolsList` and `toolsCall` handlers that work with a
+ * declarative registry, eliminating boilerplate. The `toolsList` handler converts
+ * entries into MCP `Tool` descriptors, and `toolsCall` dispatches by name and
+ * delegates to the appropriate handler.
+ *
+ * @param registry - Array of tool entries
+ * @returns Complete `McpHandlers` ready for use with `mcpStep`
+ */
+export const fromRegistry = (registry) => ({
+    toolsList: () => {
+        const tools = registry.map(entry => ({
+            name: entry.name,
+            description: entry.description,
+            inputSchema: toJsonSchema(entry.inputRtti),
+        }));
+        return pure({ tools });
+    },
+    toolsCall: ({ name, arguments: args }) => {
+        const entry = registry.find(e => e.name === name);
+        return entry === undefined
+            ? pure(errorResult(`unknown tool: ${name}`))
+            : entry.handle(args === undefined ? {} : args);
+    },
+});
+// ── Lifecycle / capability state machine ───────────────────────────────────────
+const _errResponse = (id) => (error) => ({ jsonrpc, error, id });
+const _okResponse = (id) => (result) => ({ jsonrpc, result, id });
+/** MCP error -32002: the client called a method before `initialize`. */
+export const notInitialized = rpcError(-32002)('Server not initialized');
+// Params for methods that take no arguments (`ping`, `notifications/initialized`):
+// absent, or an object (which may carry `_meta`).
+const _noParams = option(record(unknown));
+/** Initial session state — always start here. */
+export const uninitializedState = ['uninitialized'];
+/**
+ * State-machine step for an MCP session using memory effects.
+ *
+ * Given configuration, handlers, and a memory key holding the session state,
+ * returns a function `(value) => Effect<MemOp | O, Response | null>`.
+ *
+ * Rules:
+ * - `ping` returns an empty success regardless of session state; non-object
+ *   params → -32602.
+ * - `initialize` is accepted only while uninitialized; a second call returns -32600.
+ *   On success the state moves to `initializing`, not `initialized`.
+ * - `notifications/initialized` (no `id`) transitions `initializing` → `initialized`;
+ *   a malformed one (non-object params) is ignored and the session stays gated;
+ *   other notifications are silently ignored in any state.
+ * - Any other method before `notifications/initialized` → error -32002 (not initialized).
+ * - Methods gated by a capability (e.g. `tools/list`) → -32601 when the capability
+ *   is absent.
+ * - `tools/list` params (an optional pagination `cursor`) are validated and passed
+ *   to the handler; invalid params → -32602.
+ */
+export const mcpStep = ({ protocolVersion, capabilities, serverInfo, }) => (handlers) => (stateKey) => (value) => {
+    const [t, message] = decodeRequest(value);
+    if (t === 'error') {
+        return pure(_errResponse(null)(invalidRequest));
+    }
+    const { id, method, params } = message;
+    // Notifications (no `id`) never receive a response.
+    // `notifications/initialized` transitions the session from initializing → initialized.
+    if (id === undefined) {
+        if (method === 'notifications/initialized') {
+            const [pt] = validate(_noParams)(params);
+            if (pt === 'error') {
+                // Malformed handshake — ignore it; the session stays gated.
+                return pure(null);
+            }
+            return step(read(stateKey), ([t]) => t === 'initializing'
+                ? step(write(stateKey, ['initialized', true]), () => pure(null))
+                : pure(null));
+        }
+        return pure(null);
+    }
+    // `ping` is always valid regardless of session state, but its params
+    // (if present) must be an object.
+    if (method === 'ping') {
+        const [pt] = validate(_noParams)(params);
+        return pt === 'error'
+            ? pure(_errResponse(id)(invalidParams))
+            : pure(_okResponse(id)({}));
+    }
+    // `initialize` transitions uninitialized → initializing; reject if already done.
+    if (method === 'initialize') {
+        return step(read(stateKey), ([t]) => {
+            if (t !== 'uninitialized') {
+                return pure(_errResponse(id)(invalidRequest));
+            }
+            const [pr] = validate(initializeParams)(params);
+            if (pr === 'error') {
+                return pure(_errResponse(id)(invalidParams));
+            }
+            const result = {
+                protocolVersion,
+                capabilities,
+                serverInfo,
+            };
+            return step(write(stateKey, ['initializing']), () => pure(_okResponse(id)(result)));
+        });
+    }
+    // All other methods require fully initialized state — read it first.
+    return step(read(stateKey), ([t]) => {
+        if (t !== 'initialized') {
+            return pure(_errResponse(id)(notInitialized));
+        }
+        if (method === 'tools/list') {
+            if (capabilities.tools === undefined) {
+                return pure(_errResponse(id)(methodNotFound));
+            }
+            // `params` may be absent — `tools/list` without a cursor.
+            const [t, pr] = validate(toolsListParams)(params === undefined ? {} : params);
+            return t === 'error'
+                ? pure(_errResponse(id)(invalidParams))
+                : step(handlers.toolsList(pr), r => pure(_okResponse(id)(r)));
+        }
+        if (method === 'tools/call') {
+            if (capabilities.tools === undefined) {
+                return pure(_errResponse(id)(methodNotFound));
+            }
+            const [t, pr] = validate(toolsCallParams)(params);
+            return t === 'error'
+                ? pure(_errResponse(id)(invalidParams))
+                : step(handlers.toolsCall(pr), r => pure(_okResponse(id)(r)));
+        }
+        return pure(_errResponse(id)(methodNotFound));
+    });
+};

package/fjs/protocol/mcp/proof.f.d.ts

@@ -0,0 +1,34 @@
+export declare const proof: {
+    lifecycle: {
+        initialStateIsUninitialized: () => void;
+        initializeTransitionsToInitializing: () => void;
+        initializedNotificationTransitionsToInitialized: () => void;
+        initializeReturnsResult: () => void;
+        initializeWithBadParamsReturnsInvalidParams: () => void;
+        notificationBeforeInitReturnNull: () => void;
+        unknownNotificationReturnNull: () => void;
+        doubleInitializeReturnsInvalidRequest: () => void;
+        pingBeforeInitSucceeds: () => void;
+        pingDuringInitializingSucceeds: () => void;
+        pingAfterInitSucceeds: () => void;
+        pingWithObjectParamsSucceeds: () => void;
+        pingInvalidParamsReturnsInvalidParams: () => void;
+        initializedNotificationObjectParamsTransitions: () => void;
+        initializedNotificationBadParamsIgnored: () => void;
+        methodBeforeInitReturnsNotInitialized: () => void;
+        methodDuringInitializingReturnsNotInitialized: () => void;
+        invalidEnvelopeReturnsInvalidRequest: () => void;
+    };
+    tools: {
+        toolsListSucceeds: () => void;
+        toolsListPassesCursorToHandler: () => void;
+        toolsListInvalidCursorReturnsInvalidParams: () => void;
+        toolsCallSucceeds: () => void;
+        toolsCallBadParamsReturnsInvalidParams: () => void;
+        toolsCallAbsentArgumentsSucceeds: () => void;
+        toolsCallNullArgumentsReturnsInvalidParams: () => void;
+        toolsListWithoutCapabilityReturnsMethodNotFound: () => void;
+        toolsCallWithoutCapabilityReturnsMethodNotFound: () => void;
+        unknownMethodReturnsMethodNotFound: () => void;
+    };
+};