@revojs/ai 0.2.26 → 0.2.28

package/README.md

@@ -29,7 +29,7 @@ for (const call of result.content) {
 `listTools()` returns AI function-tool definitions. `executeTool()` accepts a
 normalized model tool call and returns a `LanguageModelToolResultPart`, preserving
 the entire tool result as JSON, like the Model Context Protocol client. Use
-`callTool(name, input, { signal })` for the original SDK `CallToolResult` without
+`callTool(name, input, { signal })` for the raw `CallToolResult` without
 a model call. Both execution methods validate arguments before running a handler.
 Unknown tools, invalid arguments and unexpected handler failures throw locally;
 HTTP error responses and thrown responses become error results. The HTTP endpoint
@@ -130,7 +130,7 @@ target when middleware or route parameters are required.
 Choose exactly one of `route` and `execute`. Input schemas must describe an object;
 plain JSON Schema and Standard JSON Schema providers are supported. Arguments are
 validated before execution, and tool names must be unique across sources.
-Handlers can return JSON, text, a `Response`, or an SDK `CallToolResult` for custom
+Handlers can return JSON, text, a `Response`, or a `CallToolResult` for custom
 multimodal content. JSON objects from direct handlers also become structured
 content. HTTP error responses and thrown responses become tool errors; unexpected
 exceptions return a generic tool error without disclosing internal details.
@@ -149,10 +149,9 @@ hosts in your deployment. Model Context Protocol clients without an Origin heade
 
 ### Connect to a server
 
-Connect to a Model Context Protocol server using Streamable HTTP. Headers,
-an SDK OAuth provider, a custom fetch implementation,
-and custom SDK transports are supported. Keep credentials on the server and only
-connect to trusted endpoints.
+Connect to a Model Context Protocol server using Streamable HTTP. Headers and a custom
+fetch implementation are supported; OAuth and stdio transports are not. Keep credentials on
+the server and only connect to trusted endpoints.
 
 ```ts
 import { useAi, useModelContextProtocol } from "@revojs/ai";
@@ -187,17 +186,14 @@ transport/protocol errors throw. Tool execution is explicit: apply authorization
 or approval checks before calling it. The application controls the conversation
 loop, stream consumption, and tool namespacing/routing when combining multiple servers.
 
-Use `modelContextProtocol.client.callTool({ name, arguments })` for the original SDK result.
-Use `modelContextProtocol.client` for SDK
-operations such as `listResources()`, `readResource({ uri })`, `listPrompts()`, and
-`getPrompt({ name, arguments })`. SDK request options support cancellation and
-timeouts; `useModelContextProtocol` accepts them as `requestOptions`, and the tool methods take
-them as their last argument.
-
-For local stdio servers, create a `StdioClientTransport` from the Model Context Protocol SDK in
-Node/Bun application code and pass it as `transport`. The runtime entry itself
-does not import Node process APIs. Always close the connection when finished;
-HTTP sessions are terminated before disconnecting.
+`modelContextProtocol.client` is the underlying `ModelContextProtocolClient`:
+`client.listTools({ cursor })` returns one raw page (including tool annotations),
+`client.callTool({ name, arguments })` the raw result, and `client.request(method, params)`
+sends any other JSON-RPC request such as `resources/list` or `prompts/get`. Request options
+(`{ signal, timeout }`, default timeout 60 seconds) are accepted by `useModelContextProtocol`
+as `requestOptions` and by every method as its last argument; aborted requests send
+`notifications/cancelled`. Always close the connection when finished; HTTP sessions are
+terminated with `DELETE` before disconnecting.
 
 ## OpenCode Go
 

package/dist/index.d.ts

@@ -1,8 +1,3 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { type CallToolResult, type ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import { type HttpMethod, type Route } from "@revojs/server";
 import { type Scope, type Source, type SourceScope, type SourceValue } from "revojs";
 import { type Awaitable, type JSONObject, type JsonSchema, type JSONValue } from "revojs/shared";
@@ -11,7 +6,10 @@ export type Tool<T extends JSONObject = JSONObject> = FunctionTool<T> | RouteToo
 export type ToolHandler<T extends JSONObject = JSONObject> = (scope: Scope, input: T, options: ToolExecutionOptions) => Awaitable<ToolResult>;
 export type ToolRouteResolver<T extends JSONObject = JSONObject> = (scope: Scope, input: T, options: ToolExecutionOptions) => Awaitable<ToolRequest>;
 export type ToolRoute<T extends JSONObject = JSONObject> = string | ToolRequest | Route | ToolRouteResolver<T>;
-export type ModelContextProtocolConnectOptions = ModelContextProtocolHttpConnectOptions | ModelContextProtocolTransportConnectOptions;
+export type ModelContextProtocolContent = ModelContextProtocolTextContent | ModelContextProtocolImageContent | ModelContextProtocolAudioContent | ModelContextProtocolResourceLink | ModelContextProtocolEmbeddedResource;
+export type ModelContextProtocolFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type JsonRpcId = string | number;
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse;
 export type SharedWarning = {
     type: "unsupported" | "compatibility";
     feature: string;
@@ -72,24 +70,105 @@ export interface ToolRequest {
     body?: JSONValue;
     headers?: HeadersInit;
 }
-export interface ModelContextProtocolClientInfo {
+export interface ModelContextProtocolImplementation {
     name: string;
     version: string;
 }
-export interface ModelContextProtocolConnectionOptions {
-    clientInfo?: ModelContextProtocolClientInfo;
-    requestOptions?: RequestOptions;
+export interface ModelContextProtocolRequestOptions {
+    signal?: AbortSignal;
+    timeout?: number;
 }
-export interface ModelContextProtocolHttpConnectOptions extends ModelContextProtocolConnectionOptions {
+export interface ModelContextProtocolConnectOptions {
     endpoint: string | URL;
-    transport?: "http";
     headers?: Record<string, string>;
-    authProvider?: StreamableHTTPClientTransportOptions["authProvider"];
-    fetch?: StreamableHTTPClientTransportOptions["fetch"];
+    fetch?: ModelContextProtocolFetch;
+    clientInfo?: ModelContextProtocolImplementation;
+    requestOptions?: ModelContextProtocolRequestOptions;
+}
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ModelContextProtocolTextContent {
+    type: "text";
+    text: string;
+}
+export interface ModelContextProtocolImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface ModelContextProtocolAudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+}
+export interface ModelContextProtocolResourceLink {
+    type: "resource_link";
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface ModelContextProtocolResourceContents {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+export interface ModelContextProtocolEmbeddedResource {
+    type: "resource";
+    resource: ModelContextProtocolResourceContents;
+}
+export interface CallToolResult {
+    content: Array<ModelContextProtocolContent>;
+    structuredContent?: JSONObject;
+    isError?: boolean;
+}
+export interface CallToolParams {
+    name: string;
+    arguments?: JSONObject;
 }
-export interface ModelContextProtocolTransportConnectOptions extends ModelContextProtocolConnectionOptions {
-    transport: Transport;
-    endpoint?: never;
+export interface ListToolsParams {
+    cursor?: string;
+}
+export interface ModelContextProtocolTool {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JSONObject;
+    outputSchema?: JSONObject;
+    annotations?: ToolAnnotations;
+}
+export interface ListToolsResult {
+    tools: Array<ModelContextProtocolTool>;
+    nextCursor?: string;
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    capabilities: JSONObject;
+    serverInfo: ModelContextProtocolImplementation;
+    instructions?: string;
+}
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: JsonRpcId;
+    method: string;
+    params?: JSONObject;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: JSONValue;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: JsonRpcId | null;
+    result?: unknown;
+    error?: JsonRpcError;
 }
 export interface LanguageModelText {
     type: "text";
@@ -737,12 +816,39 @@ export interface SkillsUploadSkillResult {
 export interface Provider {
     setup: (scope: Scope) => Awaitable<ProviderConnection>;
 }
+export declare class ModelContextProtocolError extends Error {
+    readonly code: number;
+    readonly data?: JSONValue;
+    constructor(code: number, message: string, data?: JSONValue);
+}
+export declare class ModelContextProtocolClient {
+    readonly endpoint: URL;
+    sessionId?: string;
+    protocolVersion?: string;
+    serverInfo?: ModelContextProtocolImplementation;
+    capabilities?: JSONObject;
+    instructions?: string;
+    private readonly headers;
+    private readonly fetch;
+    private readonly clientInfo;
+    private readonly requestOptions;
+    private requests;
+    constructor(options: ModelContextProtocolConnectOptions);
+    connect(options?: ModelContextProtocolRequestOptions): Promise<void>;
+    listTools(params?: ListToolsParams, options?: ModelContextProtocolRequestOptions): Promise<ListToolsResult>;
+    callTool(params: CallToolParams, options?: ModelContextProtocolRequestOptions): Promise<CallToolResult>;
+    request<T>(method: string, params?: JSONObject, options?: ModelContextProtocolRequestOptions): Promise<T>;
+    notify(method: string, params?: JSONObject): Promise<void>;
+    close(): Promise<void>;
+    private send;
+    private receive;
+    private answer;
+}
 export declare class ModelContextProtocolConnection {
-    readonly client: Client;
-    private readonly transport;
-    constructor(client: Client, transport: Transport);
-    listTools(options?: RequestOptions): Promise<Array<LanguageModelFunctionTool>>;
-    executeTool(call: LanguageModelToolCall, options?: RequestOptions): Promise<LanguageModelToolResultPart>;
+    readonly client: ModelContextProtocolClient;
+    constructor(client: ModelContextProtocolClient);
+    listTools(options?: ModelContextProtocolRequestOptions): Promise<Array<LanguageModelFunctionTool>>;
+    executeTool(call: LanguageModelToolCall, options?: ModelContextProtocolRequestOptions): Promise<LanguageModelToolResultPart>;
     close(): Promise<void>;
 }
 export declare function defineTool<T extends JSONObject = JSONObject>(tool: Tool<T>): Tool<T>;
@@ -769,3 +875,12 @@ export declare function postJson(url: string, body: unknown, options?: {
 }): Promise<Response>;
 export declare function readDataFrames(response: Response): AsyncGenerator<string>;
 export declare function toStream<T>(read: () => AsyncGenerator<T>): ReadableStream<T>;
+export declare const MODEL_CONTEXT_PROTOCOL_VERSIONS: string[];
+export declare const MODEL_CONTEXT_PROTOCOL_TIMEOUT = 60000;
+export declare const ModelContextProtocolErrorCode: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+};

package/dist/index.js

@@ -1,22 +1,181 @@
 import config from "#config/ai";
 import providers from "#providers";
 import tools from "#tools";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
-import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker-provider.js";
+import { Validator } from "@cfworker/json-schema";
 import { SERVER_CONTEXT, createServerScope, isResponse, requireSameOrigin, useServer } from "@revojs/server";
 import { useVariables } from "revojs";
 import { toJsonSchema } from "revojs/shared";
 //#region src/index.ts
+var ModelContextProtocolError = class extends Error {
+	code;
+	data;
+	constructor(code, message, data) {
+		super(message);
+		this.name = "ModelContextProtocolError";
+		this.code = code;
+		this.data = data;
+	}
+};
+var ModelContextProtocolClient = class {
+	endpoint;
+	sessionId;
+	protocolVersion;
+	serverInfo;
+	capabilities;
+	instructions;
+	headers;
+	fetch;
+	clientInfo;
+	requestOptions;
+	requests = 0;
+	constructor(options) {
+		this.endpoint = new URL(options.endpoint);
+		this.headers = options.headers ?? {};
+		this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.clientInfo = options.clientInfo ?? {
+			name: "revojs",
+			version: "1.0.0"
+		};
+		this.requestOptions = options.requestOptions ?? {};
+	}
+	async connect(options) {
+		const result = await this.request("initialize", {
+			protocolVersion: MODEL_CONTEXT_PROTOCOL_VERSIONS[0],
+			capabilities: {},
+			clientInfo: {
+				name: this.clientInfo.name,
+				version: this.clientInfo.version
+			}
+		}, options);
+		if (!MODEL_CONTEXT_PROTOCOL_VERSIONS.includes(result.protocolVersion)) throw new Error(`Unsupported Model Context Protocol version "${result.protocolVersion}".`);
+		this.protocolVersion = result.protocolVersion;
+		this.serverInfo = result.serverInfo;
+		this.capabilities = result.capabilities;
+		this.instructions = result.instructions;
+		await this.notify("notifications/initialized");
+	}
+	async listTools(params = {}, options) {
+		const request = {};
+		if (params.cursor !== void 0) request.cursor = params.cursor;
+		return await this.request("tools/list", request, options);
+	}
+	async callTool(params, options) {
+		return await this.request("tools/call", {
+			name: params.name,
+			arguments: params.arguments ?? {}
+		}, options);
+	}
+	async request(method, params = {}, options = this.requestOptions) {
+		this.requests += 1;
+		const id = this.requests;
+		const signals = [AbortSignal.timeout(options.timeout ?? 6e4)];
+		if (options.signal) signals.push(options.signal);
+		const signal = AbortSignal.any(signals);
+		try {
+			const response = await this.send({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			}, signal);
+			const message = await this.receive(response, id);
+			if (message.error) throw new ModelContextProtocolError(message.error.code, message.error.message, message.error.data);
+			return message.result;
+		} catch (error) {
+			if (signal.aborted && this.protocolVersion !== void 0) (async () => {
+				try {
+					await this.notify("notifications/cancelled", {
+						requestId: id,
+						reason: "Request aborted"
+					});
+				} catch {}
+			})();
+			throw error;
+		}
+	}
+	async notify(method, params) {
+		const notification = {
+			jsonrpc: "2.0",
+			method
+		};
+		if (params !== void 0) notification.params = params;
+		await (await this.send(notification)).body?.cancel();
+	}
+	async close() {
+		const sessionId = this.sessionId;
+		this.sessionId = void 0;
+		if (sessionId === void 0) return;
+		const response = await this.fetch(this.endpoint, {
+			method: "DELETE",
+			headers: {
+				...this.headers,
+				"mcp-session-id": sessionId
+			}
+		});
+		await response.body?.cancel();
+		if (!response.ok && response.status !== 405) throw new Error(`Model Context Protocol session termination failed with HTTP ${response.status}.`);
+	}
+	async send(message, signal) {
+		const headers = new Headers(this.headers);
+		headers.set("content-type", "application/json");
+		headers.set("accept", "application/json, text/event-stream");
+		if (this.sessionId !== void 0) headers.set("mcp-session-id", this.sessionId);
+		if (this.protocolVersion !== void 0) headers.set("mcp-protocol-version", this.protocolVersion);
+		const response = await this.fetch(this.endpoint, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(message),
+			signal
+		});
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new Error(`Model Context Protocol request failed with HTTP ${response.status}.`);
+		}
+		const sessionId = response.headers.get("mcp-session-id");
+		if (sessionId !== null) this.sessionId = sessionId;
+		return response;
+	}
+	async receive(response, id) {
+		if (response.headers.get("content-type")?.includes("text/event-stream")) {
+			for await (const data of readDataFrames(response)) {
+				if (data === "") continue;
+				const message = JSON.parse(data);
+				if ("method" in message) {
+					await this.answer(message);
+					continue;
+				}
+				if (message.id === id) return message;
+			}
+			throw new Error("Model Context Protocol stream ended without a response.");
+		}
+		const body = await response.json();
+		const messages = new Array();
+		if (Array.isArray(body)) for (const message of body) messages.push(message);
+		else messages.push(body);
+		for (const message of messages) {
+			if ("method" in message) continue;
+			if (message.id === id) return message;
+		}
+		throw new Error("Model Context Protocol response does not contain the requested result.");
+	}
+	async answer(request) {
+		if (request.id === void 0) return;
+		const reply = {
+			jsonrpc: "2.0",
+			id: request.id
+		};
+		if (request.method === "ping") reply.result = {};
+		else reply.error = {
+			code: ModelContextProtocolErrorCode.MethodNotFound,
+			message: `Method "${request.method}" is not supported by this client.`
+		};
+		await (await this.send(reply)).body?.cancel();
+	}
+};
 var ModelContextProtocolConnection = class {
 	client;
-	transport;
-	constructor(client, transport) {
+	constructor(client) {
 		this.client = client;
-		this.transport = transport;
 	}
 	async listTools(options) {
 		const tools = new Array();
@@ -42,7 +201,7 @@ var ModelContextProtocolConnection = class {
 		const result = await this.client.callTool({
 			name: call.toolName,
 			arguments: input
-		}, void 0, options);
+		}, options);
 		return {
 			type: "tool-result",
 			toolCallId: call.toolCallId,
@@ -54,11 +213,7 @@ var ModelContextProtocolConnection = class {
 		};
 	}
 	async close() {
-		try {
-			if (this.transport instanceof StreamableHTTPClientTransport && this.transport.sessionId !== void 0) await this.transport.terminateSession();
-		} finally {
-			await this.client.close();
-		}
+		await this.client.close();
 	}
 };
 function defineTool(tool) {
@@ -73,13 +228,14 @@ async function toToolResult(output) {
 		isError: !output.ok
 	};
 	if (output !== null && typeof output === "object" && "content" in output && Array.isArray(output.content)) return output;
-	return {
-		content: [{
-			type: "text",
-			text: typeof output === "string" ? output : JSON.stringify(output ?? null)
-		}],
-		...output !== null && typeof output === "object" && !Array.isArray(output) ? { structuredContent: output } : {}
-	};
+	let text = JSON.stringify(output ?? null);
+	if (typeof output === "string") text = output;
+	const result = { content: [{
+		type: "text",
+		text
+	}] };
+	if (output !== null && typeof output === "object" && !Array.isArray(output)) result.structuredContent = output;
+	return result;
 }
 function useTools(scope) {
 	let loading;
@@ -92,17 +248,18 @@ function useTools(scope) {
 		}
 		const definitions = await loading;
 		if (registered) return registered;
-		const validator = new CfWorkerJsonSchemaValidator();
 		const entries = /* @__PURE__ */ new Map();
 		for (const tool of definitions) {
 			if (!/^[A-Za-z0-9_.-]{1,128}$/.test(tool.name)) throw new Error(`Invalid Model Context Protocol tool name "${tool.name}".`);
 			if (entries.has(tool.name)) throw new Error("Model Context Protocol tool names must be unique across all tool sources.");
 			const schema = toJsonSchema(tool.inputSchema);
 			if (schema.type !== "object") throw new Error(`Model Context Protocol tool "${tool.name}" must have an object input schema.`);
+			let draft = "2020-12";
+			if (typeof schema.$schema === "string" && JSON_SCHEMA_DRAFTS[schema.$schema]) draft = JSON_SCHEMA_DRAFTS[schema.$schema];
 			entries.set(tool.name, {
 				tool,
 				schema,
-				validate: validator.getValidator(schema)
+				validator: new Validator(schema, draft, true)
 			});
 		}
 		registered = entries;
@@ -111,14 +268,20 @@ function useTools(scope) {
 	const callTool = async (name, input = {}, options = {}) => {
 		options.signal?.throwIfAborted();
 		const entry = (await resolveTools()).get(name);
-		if (!entry) throw new McpError(ErrorCode.InvalidParams, `Unknown tool "${name}".`);
-		const result = entry.validate(input);
-		if (!result.valid) throw new McpError(ErrorCode.InvalidParams, result.errorMessage ?? "Invalid tool arguments.");
+		if (!entry) throw new ModelContextProtocolError(ModelContextProtocolErrorCode.InvalidParams, `Unknown tool "${name}".`);
+		const validation = entry.validator.validate(input);
+		if (!validation.valid) {
+			const errors = new Array();
+			for (const error of validation.errors) errors.push(`${error.instanceLocation}: ${error.error}`);
+			let message = "Invalid tool arguments.";
+			if (errors.length > 0) message = errors.join("; ");
+			throw new ModelContextProtocolError(ModelContextProtocolErrorCode.InvalidParams, message);
+		}
 		options.signal?.throwIfAborted();
 		try {
 			const { tool } = entry;
 			if (tool.execute) {
-				const output = await tool.execute(scope, result.data, options);
+				const output = await tool.execute(scope, input, options);
 				options.signal?.throwIfAborted();
 				return await toToolResult(output);
 			}
@@ -127,7 +290,7 @@ function useTools(scope) {
 			const signal = options.signal ? AbortSignal.any([request.signal, options.signal]) : request.signal;
 			signal.throwIfAborted();
 			let target = tool.route;
-			if (typeof target === "function") target = await target(scope, result.data, { signal });
+			if (typeof target === "function") target = await target(scope, input, { signal });
 			let direct;
 			let targetOptions;
 			if (typeof target === "string") targetOptions = { path: target };
@@ -140,8 +303,15 @@ function useTools(scope) {
 			if (!direct && (url.pathname === "/v1/model-context-protocol" || url.pathname === "/v1/model-context-protocol/")) throw new Error("A tool cannot call the Model Context Protocol endpoint.");
 			const method = targetOptions.method ?? "POST";
 			const readOnly = method === "GET" || method === "HEAD";
-			const query = targetOptions.query ?? (readOnly ? result.data : {});
-			for (const [name, value] of query instanceof URLSearchParams ? query : Object.entries(query)) if (value !== void 0) url.searchParams.append(name, typeof value === "string" ? value : JSON.stringify(value));
+			let query = targetOptions.query ?? {};
+			if (targetOptions.query === void 0 && readOnly) query = input;
+			let parameters = Object.entries(query);
+			if (query instanceof URLSearchParams) parameters = query;
+			for (const [name, value] of parameters) {
+				if (value === void 0) continue;
+				if (typeof value === "string") url.searchParams.append(name, value);
+				else url.searchParams.append(name, JSON.stringify(value));
+			}
 			const headers = new Headers(targetOptions.headers);
 			for (const name of [
 				"authorization",
@@ -155,7 +325,9 @@ function useTools(scope) {
 			let body;
 			if (!readOnly) {
 				headers.set("content-type", "application/json");
-				body = JSON.stringify("body" in targetOptions ? targetOptions.body : result.data);
+				let payload = input;
+				if ("body" in targetOptions) payload = targetOptions.body;
+				body = JSON.stringify(payload);
 			}
 			const nextRequest = new Request(url, {
 				method,
@@ -192,7 +364,7 @@ function useTools(scope) {
 		callTool,
 		async executeTool(call, options) {
 			const input = JSON.parse(call.input);
-			if (input === null || typeof input !== "object" || Array.isArray(input)) throw new McpError(ErrorCode.InvalidParams, `Tool "${call.toolName}" requires a JSON object as input.`);
+			if (input === null || typeof input !== "object" || Array.isArray(input)) throw new ModelContextProtocolError(ModelContextProtocolErrorCode.InvalidParams, `Tool "${call.toolName}" requires a JSON object as input.`);
 			const result = await callTool(call.toolName, input, options);
 			return {
 				type: "tool-result",
@@ -213,67 +385,149 @@ async function handleModelContextProtocol(scope, options = {}) {
 		status: 405,
 		headers: { Allow: "POST" }
 	});
+	const version = request.headers.get("mcp-protocol-version");
+	if (version !== null && !MODEL_CONTEXT_PROTOCOL_VERSIONS.includes(version)) return Response.json({
+		jsonrpc: "2.0",
+		id: null,
+		error: {
+			code: ModelContextProtocolErrorCode.InvalidRequest,
+			message: `Unsupported Model Context Protocol version "${version}".`
+		}
+	}, { status: 400 });
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return Response.json({
+			jsonrpc: "2.0",
+			id: null,
+			error: {
+				code: ModelContextProtocolErrorCode.ParseError,
+				message: "Parse error."
+			}
+		}, { status: 400 });
+	}
 	const collection = useTools(scope);
-	const server = new McpServer({
-		name: config.modelContextProtocol.name,
-		version: config.modelContextProtocol.version
-	}, {
-		capabilities: { tools: {} },
-		instructions: config.modelContextProtocol.instructions,
-		jsonSchemaValidator: new CfWorkerJsonSchemaValidator()
-	});
-	const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
 	const listTools = async () => {
-		const tools = await collection.listTools();
-		return options.filter ? tools.filter(options.filter) : tools;
+		const visible = new Array();
+		for (const tool of await collection.listTools()) if (!options.filter || options.filter(tool)) visible.push(tool);
+		return visible;
 	};
-	server.server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: (await listTools()).map((tool) => ({
-		name: tool.name,
-		description: tool.description,
-		inputSchema: tool.inputSchema,
-		annotations: tool.annotations
-	})) }));
-	server.server.setRequestHandler(CallToolRequestSchema, async ({ params }, extra) => {
-		if (options.filter && !(await listTools()).some((tool) => tool.name === params.name)) throw new McpError(ErrorCode.InvalidParams, `Unknown tool "${params.name}".`);
+	const batch = Array.isArray(body);
+	const entries = new Array();
+	if (Array.isArray(body)) for (const entry of body) entries.push(entry);
+	else entries.push(body);
+	const responses = new Array();
+	for (const entry of entries) {
+		if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+			responses.push({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: ModelContextProtocolErrorCode.InvalidRequest,
+					message: "Invalid request."
+				}
+			});
+			continue;
+		}
+		const message = entry;
+		if (typeof message.method !== "string" || message.id === void 0) continue;
+		const params = message.params ?? {};
 		try {
-			return await collection.callTool(params.name, params.arguments ?? {}, { signal: AbortSignal.any([request.signal, extra.signal]) });
+			let result;
+			switch (message.method) {
+				case "initialize": {
+					const requested = params.protocolVersion;
+					let protocolVersion = MODEL_CONTEXT_PROTOCOL_VERSIONS[0];
+					if (typeof requested === "string" && MODEL_CONTEXT_PROTOCOL_VERSIONS.includes(requested)) protocolVersion = requested;
+					result = {
+						protocolVersion,
+						capabilities: { tools: {} },
+						serverInfo: {
+							name: config.modelContextProtocol.name,
+							version: config.modelContextProtocol.version
+						},
+						instructions: config.modelContextProtocol.instructions
+					};
+					break;
+				}
+				case "ping":
+					result = {};
+					break;
+				case "tools/list": {
+					const tools = new Array();
+					for (const tool of await listTools()) tools.push({
+						name: tool.name,
+						description: tool.description,
+						inputSchema: tool.inputSchema,
+						annotations: tool.annotations
+					});
+					result = { tools };
+					break;
+				}
+				case "tools/call": {
+					const name = params.name;
+					const input = params.arguments ?? {};
+					if (typeof name !== "string" || input === null || typeof input !== "object" || Array.isArray(input)) throw new ModelContextProtocolError(ModelContextProtocolErrorCode.InvalidParams, "Tool calls require a name and object arguments.");
+					if (options.filter) {
+						let visible = false;
+						for (const tool of await listTools()) if (tool.name === name) {
+							visible = true;
+							break;
+						}
+						if (!visible) throw new ModelContextProtocolError(ModelContextProtocolErrorCode.InvalidParams, `Unknown tool "${name}".`);
+					}
+					try {
+						result = await collection.callTool(name, input, { signal: request.signal });
+					} catch (error) {
+						if (error instanceof ModelContextProtocolError) throw error;
+						result = {
+							content: [{
+								type: "text",
+								text: "Tool execution failed."
+							}],
+							isError: true
+						};
+					}
+					break;
+				}
+				default: throw new ModelContextProtocolError(ModelContextProtocolErrorCode.MethodNotFound, `Method "${message.method}" not found.`);
+			}
+			responses.push({
+				jsonrpc: "2.0",
+				id: message.id,
+				result
+			});
 		} catch (error) {
-			if (error instanceof McpError) throw error;
-			return {
-				content: [{
-					type: "text",
-					text: "Tool execution failed."
-				}],
-				isError: true
+			let failure = {
+				code: ModelContextProtocolErrorCode.InternalError,
+				message: "Internal error."
+			};
+			if (error instanceof ModelContextProtocolError) failure = {
+				code: error.code,
+				message: error.message,
+				data: error.data
 			};
+			responses.push({
+				jsonrpc: "2.0",
+				id: message.id,
+				error: failure
+			});
 		}
-	});
-	try {
-		await server.connect(transport);
-		return await transport.handleRequest(request);
-	} finally {
-		await server.close();
 	}
+	if (responses.length === 0) return new Response(null, { status: 202 });
+	if (batch) return Response.json(responses);
+	return Response.json(responses[0]);
 }
 async function useModelContextProtocol(options) {
-	const client = new Client(options.clientInfo ?? {
-		name: "revojs",
-		version: "1.0.0"
-	});
-	let transport = options.transport;
-	if (typeof transport !== "object") {
-		if (options.endpoint === void 0) throw new Error("Model Context Protocol requires an endpoint or a custom transport.");
-		transport = new StreamableHTTPClientTransport(new URL(options.endpoint), {
-			authProvider: options.authProvider,
-			fetch: options.fetch,
-			requestInit: { headers: options.headers }
-		});
-	}
+	const client = new ModelContextProtocolClient(options);
 	try {
-		await client.connect(transport, options.requestOptions);
-		return new ModelContextProtocolConnection(client, transport);
+		await client.connect();
+		return new ModelContextProtocolConnection(client);
 	} catch (error) {
-		await client.close().catch(() => {});
+		try {
+			await client.close();
+		} catch {}
 		throw error;
 	}
 }
@@ -398,8 +652,15 @@ async function* readDataFrames(response) {
 		buffer += decoder.decode(chunk, { stream: true });
 		const frames = buffer.split(/\r?\n\r?\n/);
 		buffer = frames.pop() ?? "";
-		for (const frame of frames) for (const line of frame.split(/\r?\n/)) if (line.startsWith("data:")) yield line.slice(5).trim();
+		for (const frame of frames) {
+			const lines = new Array();
+			for (const line of frame.split(/\r?\n/)) if (line.startsWith("data:")) lines.push(line.slice(5).trim());
+			if (lines.length > 0) yield lines.join("\n");
+		}
 	}
+	const lines = new Array();
+	for (const line of buffer.split(/\r?\n/)) if (line.startsWith("data:")) lines.push(line.slice(5).trim());
+	if (lines.length > 0) yield lines.join("\n");
 }
 function toStream(read) {
 	const iterator = read();
@@ -423,5 +684,27 @@ function toStream(read) {
 	});
 }
 var modelsDevCache = { loadedAt: 0 };
+var MODEL_CONTEXT_PROTOCOL_VERSIONS = [
+	"2025-11-25",
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05"
+];
+var MODEL_CONTEXT_PROTOCOL_TIMEOUT = 6e4;
+var ModelContextProtocolErrorCode = {
+	ParseError: -32700,
+	InvalidRequest: -32600,
+	MethodNotFound: -32601,
+	InvalidParams: -32602,
+	InternalError: -32603
+};
+var JSON_SCHEMA_DRAFTS = {
+	"https://json-schema.org/draft/2020-12/schema": "2020-12",
+	"https://json-schema.org/draft/2019-09/schema": "2019-09",
+	"http://json-schema.org/draft-07/schema": "7",
+	"http://json-schema.org/draft-07/schema#": "7",
+	"http://json-schema.org/draft-04/schema": "4",
+	"http://json-schema.org/draft-04/schema#": "4"
+};
 //#endregion
-export { ModelContextProtocolConnection, defineProvider, defineTool, handleModelContextProtocol, mergeHeaders, modelsDevProtocol, postJson, readDataFrames, toStream, toToolInput, useAi, useModelContextProtocol, useModelsDev, useTools };
+export { MODEL_CONTEXT_PROTOCOL_TIMEOUT, MODEL_CONTEXT_PROTOCOL_VERSIONS, ModelContextProtocolClient, ModelContextProtocolConnection, ModelContextProtocolError, ModelContextProtocolErrorCode, defineProvider, defineTool, handleModelContextProtocol, mergeHeaders, modelsDevProtocol, postJson, readDataFrames, toStream, toToolInput, useAi, useModelContextProtocol, useModelsDev, useTools };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/ai",
-    "version": "0.2.26",
+    "version": "0.2.28",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -30,7 +30,6 @@
     },
     "dependencies": {
         "@cfworker/json-schema": "^4.1.1",
-        "@modelcontextprotocol/sdk": "^1.32.1",
         "@revojs/server": "*",
         "revojs": "*"
     },