@praxis-ai/praxis 0.1.4 → 0.1.5

package/dist/runtimeImplementation/runtime.execEngine/mcpRuntimeAdapter.js

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+const MCP_PROTOCOL_VERSION = "2025-06-18";
+const MCP_SESSION_ID_HEADER = "mcp-session-id";
 function success(output, metadata) {
     return { ok: true, output, metadata };
 }
@@ -20,6 +22,10 @@ function contentLengthFrame(payload) {
     const body = JSON.stringify(payload);
     return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
 }
+function writeStdioPayload(connection, payload) {
+    const framing = connection.profile.transport === "stdio" ? connection.profile.framing ?? "line-json" : undefined;
+    connection.child?.stdin.write(framing === "line-json" ? `${JSON.stringify(payload)}\n` : contentLengthFrame(payload));
+}
 function extractContentLengthFrames(buffer) {
     const messages = [];
     let rest = buffer;
@@ -70,9 +76,60 @@ function extractLineJsonFrames(buffer) {
     }
     return { messages, rest };
 }
+function jsonRpcMessagesFromUnknown(value) {
+    if (Array.isArray(value))
+        return value.filter(isObject);
+    return isObject(value) ? [value] : [];
+}
+function extractServerSentEvents(buffer) {
+    const events = [];
+    const chunks = buffer.split(/\r?\n\r?\n/u);
+    const rest = chunks.pop() ?? "";
+    for (const event of chunks) {
+        let eventName;
+        const dataLines = [];
+        for (const line of event.split(/\r?\n/u)) {
+            if (line.startsWith("event:")) {
+                const eventData = line.slice("event:".length);
+                eventName = eventData.startsWith(" ") ? eventData.slice(1) : eventData;
+            }
+            else if (line.startsWith("data:")) {
+                const data = line.slice("data:".length);
+                dataLines.push(data.startsWith(" ") ? data.slice(1) : data);
+            }
+        }
+        if (dataLines.length > 0)
+            events.push({ event: eventName, data: dataLines.join("\n") });
+    }
+    return { events, rest };
+}
+function parseServerSentEventMessages(text) {
+    const messages = [];
+    for (const event of extractServerSentEvents(text).events) {
+        try {
+            messages.push(...jsonRpcMessagesFromUnknown(JSON.parse(event.data)));
+        }
+        catch {
+            // Ignore malformed SSE data frames; the caller will fail if no response frame is present.
+        }
+    }
+    return messages;
+}
+function parseHttpJsonRpcMessages(contentType, text) {
+    if (contentType?.toLowerCase().includes("text/event-stream") === true) {
+        return parseServerSentEventMessages(text);
+    }
+    try {
+        return jsonRpcMessagesFromUnknown(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}
 export function createMcpRuntimeAdapter(options) {
     const profiles = new Map(options.servers.map((profile) => [profile.serverId, profile]));
     const connections = new Map();
+    const rootsByServerId = new Map();
     const metadata = (profile, extra = {}) => ({
         serverId: profile.serverId,
         transport: profile.transport,
@@ -80,6 +137,20 @@ export function createMcpRuntimeAdapter(options) {
         ...extra,
     });
     const getProfile = (serverId) => profiles.get(serverId);
+    const subscriptionResourceUri = (requestInput) => {
+        if (typeof requestInput.uri === "string" && requestInput.uri.trim().length > 0)
+            return requestInput.uri;
+        if (typeof requestInput.subject === "string" && requestInput.subject.trim().length > 0)
+            return requestInput.subject;
+        if (typeof requestInput.subscriptionId !== "string")
+            return undefined;
+        const marker = ":subscription:resource:";
+        const markerIndex = requestInput.subscriptionId.indexOf(marker);
+        if (markerIndex < 0)
+            return undefined;
+        const uri = requestInput.subscriptionId.slice(markerIndex + marker.length);
+        return uri.trim().length > 0 ? uri : undefined;
+    };
     const getConnection = async (serverId, connectionId) => {
         const profile = getProfile(serverId);
         if (profile === undefined)
@@ -98,7 +169,309 @@ export function createMcpRuntimeAdapter(options) {
         if (connection.profile.transport === "stdio") {
             return requestStdio(connection, method, params);
         }
-        return requestHttp(connection.profile, method, params);
+        if (connection.profile.transport === "sse") {
+            return requestSse(connection, method, params);
+        }
+        const requested = await requestHttp(connection.profile, method, params, connection.sessionId, (message) => {
+            recordNotification(connection, message);
+        });
+        if (requested.ok && typeof requested.metadata?.mcpSessionId === "string") {
+            connection.sessionId = requested.metadata.mcpSessionId;
+        }
+        return requested;
+    };
+    const notify = async (connection, method, params = {}) => {
+        if (connection.profile.transport === "stdio") {
+            return notifyStdio(connection, method, params);
+        }
+        if (connection.profile.transport === "sse") {
+            return notifySse(connection, method, params);
+        }
+        return notifyHttp(connection.profile, method, params, connection.sessionId);
+    };
+    const closeConnection = (connection) => {
+        for (const [, pending] of connection.pending) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(`MCP connection '${connection.connectionId}' was closed.`));
+        }
+        connection.pending.clear();
+        connection.child?.kill();
+        connection.sseAbort?.abort();
+    };
+    const stdioClientCapabilities = () => ({
+        roots: { listChanged: true },
+        ...(options.host?.createSamplingMessage === undefined ? {} : { sampling: {} }),
+        ...(options.host?.elicit === undefined ? {} : { elicitation: { form: {}, url: {} } }),
+    });
+    const writeStdioResult = (connection, id, result) => {
+        if (id === undefined || id === null)
+            return;
+        writeStdioPayload(connection, { jsonrpc: "2.0", id, result });
+    };
+    const writeStdioError = (connection, id, code, message, data) => {
+        if (id === undefined || id === null)
+            return;
+        writeStdioPayload(connection, {
+            jsonrpc: "2.0",
+            id,
+            error: { code, message, ...(data === undefined ? {} : { data }) },
+        });
+    };
+    const hostRequest = (connection, message) => ({
+        serverId: connection.profile.serverId,
+        connectionId: connection.connectionId,
+        method: message.method ?? "",
+        requestId: message.id,
+        params: resultObject(message.params),
+    });
+    const recordNotification = (connection, message) => {
+        if (typeof message.method !== "string")
+            return;
+        const notification = {
+            serverId: connection.profile.serverId,
+            connectionId: connection.connectionId,
+            method: message.method,
+            params: resultObject(message.params),
+        };
+        connection.notifications.push(notification);
+        if (connection.notifications.length > 100)
+            connection.notifications.splice(0, connection.notifications.length - 100);
+        const notified = options.host?.onNotification?.(notification);
+        if (notified !== undefined)
+            void Promise.resolve(notified).catch(() => undefined);
+    };
+    const handleServerRequest = async (connection, message, writeResult, writeError) => {
+        if (typeof message.method !== "string") {
+            await writeError(message.id, -32600, "Invalid MCP JSON-RPC request.");
+            return;
+        }
+        try {
+            if (message.method === "ping") {
+                await writeResult(message.id, {});
+                return;
+            }
+            if (message.method === "roots/list") {
+                const requestInput = hostRequest(connection, message);
+                const roots = options.host?.listRoots === undefined
+                    ? rootsByServerId.get(connection.profile.serverId) ?? []
+                    : await options.host.listRoots(requestInput);
+                await writeResult(message.id, { roots });
+                return;
+            }
+            if (message.method === "sampling/createMessage") {
+                if (options.host?.createSamplingMessage === undefined) {
+                    await writeError(message.id, -32601, "MCP sampling is not configured for this Praxis runtime.");
+                    return;
+                }
+                await writeResult(message.id, await options.host.createSamplingMessage(hostRequest(connection, message)));
+                return;
+            }
+            if (message.method === "elicitation/create") {
+                if (options.host?.elicit === undefined) {
+                    await writeError(message.id, -32601, "MCP elicitation is not configured for this Praxis runtime.");
+                    return;
+                }
+                await writeResult(message.id, await options.host.elicit(hostRequest(connection, message)));
+                return;
+            }
+            await writeError(message.id, -32601, `MCP client method '${message.method}' is not supported by this Praxis runtime.`);
+        }
+        catch (error) {
+            await writeError(message.id, -32603, textFromUnknown(error.message ?? error));
+        }
+    };
+    const handleStdioRequest = async (connection, message) => {
+        await handleServerRequest(connection, message, (id, result) => writeStdioResult(connection, id, result), (id, code, messageText, data) => writeStdioError(connection, id, code, messageText, data));
+    };
+    const handleStdioMessage = (connection, message) => {
+        if (typeof message.method === "string" && message.id !== undefined && message.id !== null) {
+            void handleStdioRequest(connection, message);
+            return;
+        }
+        if (typeof message.method === "string") {
+            recordNotification(connection, message);
+            return;
+        }
+        if (message.id === undefined || message.id === null)
+            return;
+        const pending = connection.pending.get(message.id);
+        if (pending === undefined)
+            return;
+        clearTimeout(pending.timeout);
+        connection.pending.delete(message.id);
+        pending.resolve(message);
+    };
+    const handleSseMessage = (connection, message) => {
+        if (typeof message.method === "string" && message.id !== undefined && message.id !== null) {
+            void handleServerRequest(connection, message, async (id, result) => {
+                await postSsePayload(connection, { jsonrpc: "2.0", id, result });
+            }, async (id, code, messageText, data) => {
+                await postSsePayload(connection, {
+                    jsonrpc: "2.0",
+                    id,
+                    error: { code, message: messageText, ...(data === undefined ? {} : { data }) },
+                });
+            });
+            return;
+        }
+        if (typeof message.method === "string") {
+            recordNotification(connection, message);
+            return;
+        }
+        if (message.id === undefined || message.id === null)
+            return;
+        const pending = connection.pending.get(message.id);
+        if (pending === undefined)
+            return;
+        clearTimeout(pending.timeout);
+        connection.pending.delete(message.id);
+        pending.resolve(message);
+    };
+    const postSsePayload = async (connection, payload) => {
+        if (connection.profile.transport !== "sse")
+            return failure("MCP_SSE_NOT_CONNECTED", "MCP SSE transport is not connected.");
+        const endpointUrl = connection.sseEndpointUrl ?? connection.profile.url;
+        const posted = await postJsonRpcPayload(connection.profile, endpointUrl, payload, connection.sessionId);
+        if (!posted.ok)
+            return posted;
+        if (typeof posted.metadata?.mcpSessionId === "string")
+            connection.sessionId = posted.metadata.mcpSessionId;
+        for (const message of posted.output.messages) {
+            handleSseMessage(connection, message);
+        }
+        return success({ status: "posted" });
+    };
+    const requestSse = async (connection, method, params) => {
+        if (connection.profile.transport !== "sse")
+            return failure("MCP_SSE_NOT_CONNECTED", "MCP SSE transport is not connected.");
+        const id = connection.nextId++;
+        const timeoutMs = connection.profile.timeoutMs ?? 5_000;
+        const response = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                connection.pending.delete(id);
+                reject(new Error(`MCP SSE request '${method}' timed out after ${timeoutMs}ms.`));
+            }, timeoutMs);
+            connection.pending.set(id, { resolve, reject, timeout });
+        });
+        const posted = await postSsePayload(connection, { jsonrpc: "2.0", id, method, params });
+        if (!posted.ok) {
+            const pending = connection.pending.get(id);
+            if (pending !== undefined)
+                clearTimeout(pending.timeout);
+            connection.pending.delete(id);
+            return posted;
+        }
+        try {
+            return normalizeJsonRpcResponse(await response);
+        }
+        catch (error) {
+            return failure("MCP_SSE_REQUEST_FAILED", textFromUnknown(error.message ?? error));
+        }
+    };
+    const notifySse = async (connection, method, params) => {
+        const posted = await postSsePayload(connection, { jsonrpc: "2.0", method, params });
+        if (!posted.ok)
+            return posted;
+        return success({ status: "notified" });
+    };
+    const openSseConnection = async (connection) => {
+        if (connection.profile.transport !== "sse")
+            return failure("MCP_SSE_CONNECT_FAILED", "MCP SSE profile is not configured.");
+        const profile = connection.profile;
+        const controller = new AbortController();
+        connection.sseAbort = controller;
+        let settled = false;
+        let settle = () => undefined;
+        const ready = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const readyTimeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            controller.abort();
+            settle(failure("MCP_SSE_CONNECT_FAILED", "MCP SSE endpoint did not announce a message endpoint."));
+        }, profile.timeoutMs ?? 5_000);
+        const setEndpoint = (endpointUrl) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(readyTimeout);
+            connection.sseEndpointUrl = endpointUrl;
+            settle(success({ endpointUrl }));
+        };
+        try {
+            const response = await fetch(profile.sseUrl ?? profile.url, {
+                headers: httpHeaders(profile),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                clearTimeout(readyTimeout);
+                settled = true;
+                return failure("MCP_SSE_CONNECT_FAILED", `MCP SSE endpoint returned HTTP ${response.status}.`);
+            }
+            if (response.body === null) {
+                clearTimeout(readyTimeout);
+                settled = true;
+                return failure("MCP_SSE_CONNECT_FAILED", "MCP SSE endpoint did not return a readable event stream.");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            void (async () => {
+                let streamBuffer = "";
+                try {
+                    while (true) {
+                        const read = await reader.read();
+                        if (read.done)
+                            break;
+                        streamBuffer += decoder.decode(read.value, { stream: true });
+                        const extracted = extractServerSentEvents(streamBuffer);
+                        streamBuffer = extracted.rest;
+                        for (const event of extracted.events) {
+                            if (event.event === "endpoint") {
+                                setEndpoint(resolveLegacySseEndpointUrl(profile, event.data));
+                                continue;
+                            }
+                            if (!settled)
+                                setEndpoint(profile.url);
+                            for (const message of parseServerSentEventMessages(`${event.event === undefined ? "" : `event: ${event.event}\n`}data: ${event.data}\n\n`)) {
+                                handleSseMessage(connection, message);
+                            }
+                        }
+                    }
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(readyTimeout);
+                        settle(failure("MCP_SSE_CONNECT_FAILED", "MCP SSE endpoint closed before announcing a message endpoint."));
+                    }
+                    for (const [id, pending] of connection.pending) {
+                        clearTimeout(pending.timeout);
+                        pending.reject(new Error(`MCP SSE stream closed before response ${String(id)}.`));
+                    }
+                    connection.pending.clear();
+                }
+                catch (error) {
+                    if (controller.signal.aborted)
+                        return;
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(readyTimeout);
+                        settle(failure("MCP_SSE_CONNECT_FAILED", textFromUnknown(error.message ?? error)));
+                    }
+                    for (const [id, pending] of connection.pending) {
+                        clearTimeout(pending.timeout);
+                        pending.reject(new Error(`MCP SSE stream failed before response ${String(id)}: ${textFromUnknown(error.message ?? error)}`));
+                    }
+                    connection.pending.clear();
+                }
+            })();
+            return ready;
+        }
+        catch (error) {
+            clearTimeout(readyTimeout);
+            settled = true;
+            return failure("MCP_SSE_CONNECT_FAILED", textFromUnknown(error.message ?? error));
+        }
     };
     const connectProfile = async (profile, connectionId) => {
         if (profile.transport === "stdio") {
@@ -107,25 +480,27 @@ export function createMcpRuntimeAdapter(options) {
                 env: { ...process.env, ...(profile.env ?? {}) },
                 stdio: ["pipe", "pipe", "pipe"],
             });
-            const connection = { profile, connectionId, child, nextId: 1, pending: new Map(), buffer: "" };
+            const connection = { profile, connectionId, child, nextId: 1, pending: new Map(), buffer: "", notifications: [] };
             child.stdout.setEncoding("utf8");
             child.stdout.on("data", (chunk) => {
-                const extracted = profile.framing === "line-json"
+                const extracted = (profile.framing ?? "line-json") === "line-json"
                     ? extractLineJsonFrames(connection.buffer + chunk)
                     : extractContentLengthFrames(connection.buffer + chunk);
                 connection.buffer = extracted.rest;
                 for (const message of extracted.messages) {
-                    if (message.id === undefined || message.id === null)
-                        continue;
-                    const pending = connection.pending.get(message.id);
-                    if (pending === undefined)
-                        continue;
+                    handleStdioMessage(connection, message);
+                }
+            });
+            child.on("error", (error) => {
+                connections.delete(connectionId);
+                for (const [id, pending] of connection.pending) {
                     clearTimeout(pending.timeout);
-                    connection.pending.delete(message.id);
-                    pending.resolve(message);
+                    pending.reject(new Error(`MCP stdio server error before response ${String(id)}: ${textFromUnknown(error.message)}`));
                 }
+                connection.pending.clear();
             });
             child.on("exit", () => {
+                connections.delete(connectionId);
                 for (const [id, pending] of connection.pending) {
                     clearTimeout(pending.timeout);
                     pending.reject(new Error(`MCP stdio server exited before response ${String(id)}.`));
@@ -134,41 +509,66 @@ export function createMcpRuntimeAdapter(options) {
             });
             const initialized = await requestStdio(connection, "initialize", {
                 protocolVersion: "2025-06-18",
-                capabilities: {},
+                capabilities: stdioClientCapabilities(),
                 clientInfo: { name: "praxis-agentcore", version: "0.1.0" },
             });
             if (!initialized.ok) {
                 child.kill();
                 return initialized;
             }
+            writeStdioPayload(connection, { jsonrpc: "2.0", method: "notifications/initialized", params: {} });
             return success(connection, metadata(profile, { connectionId, initialized: true }));
         }
-        if (profile.transport === "sse" && profile.sseUrl !== undefined) {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), profile.timeoutMs ?? 2_000);
-            try {
-                const response = await fetch(profile.sseUrl, { headers: profile.headers, signal: controller.signal });
-                if (!response.ok)
-                    return failure("MCP_SSE_CONNECT_FAILED", `MCP SSE endpoint returned HTTP ${response.status}.`);
-            }
-            catch (error) {
-                return failure("MCP_SSE_CONNECT_FAILED", textFromUnknown(error.message ?? error));
+        const connection = { profile, connectionId, nextId: 1, pending: new Map(), buffer: "", notifications: [] };
+        if (profile.transport === "sse") {
+            const opened = await openSseConnection(connection);
+            if (!opened.ok)
+                return opened;
+            const initialized = await requestSse(connection, "initialize", {
+                protocolVersion: "2025-06-18",
+                capabilities: {},
+                clientInfo: { name: "praxis-agentcore", version: "0.1.0" },
+            });
+            if (!initialized.ok) {
+                closeConnection(connection);
+                return initialized;
             }
-            finally {
-                clearTimeout(timeout);
+            const notified = await notifySse(connection, "notifications/initialized", {});
+            if (!notified.ok) {
+                closeConnection(connection);
+                return notified;
             }
+            return success(connection, metadata(profile, { connectionId, initialized: true, endpointUrl: opened.output.endpointUrl }));
         }
-        const connection = { profile, connectionId, nextId: 1, pending: new Map(), buffer: "" };
         const initialized = await requestHttp(profile, "initialize", {
             protocolVersion: "2025-06-18",
             capabilities: {},
             clientInfo: { name: "praxis-agentcore", version: "0.1.0" },
+        }, undefined, (message) => {
+            recordNotification(connection, message);
         });
         if (!initialized.ok)
             return initialized;
-        return success(connection, metadata(profile, { connectionId, initialized: true }));
+        const sessionId = typeof initialized.metadata?.mcpSessionId === "string" ? initialized.metadata.mcpSessionId : undefined;
+        const notified = await notifyHttp(profile, "notifications/initialized", {}, sessionId);
+        if (!notified.ok)
+            return notified;
+        connection.sessionId = sessionId;
+        return success(connection, metadata(profile, { connectionId, initialized: true, sessionId }));
     };
     return {
+        async shutdown() {
+            const closedConnections = connections.size;
+            for (const [, connection] of connections) {
+                closeConnection(connection);
+            }
+            connections.clear();
+            return success({
+                status: "shutdown",
+                closedConnections,
+                serverIds: [...profiles.keys()],
+            });
+        },
         async authenticate(requestInput) {
             const profile = getProfile(requestInput.serverId);
             if (profile === undefined)
@@ -207,7 +607,7 @@ export function createMcpRuntimeAdapter(options) {
             const connection = connections.get(id);
             if (connection === undefined)
                 return success({ connectionId: id, status: "not_found", serverId: requestInput.serverId, providerMetadata: metadata(profile, { connectionId: id }) });
-            connection.child?.kill();
+            closeConnection(connection);
             connections.delete(id);
             return success({ connectionId: id, status: "disconnected", serverId: requestInput.serverId, providerMetadata: metadata(profile, { connectionId: id }) });
         },
@@ -215,13 +615,62 @@ export function createMcpRuntimeAdapter(options) {
             const connected = await getConnection(requestInput.serverId, requestInput.connectionId);
             if (!connected.ok)
                 return connected;
-            return success({ subscriptionId: `${requestInput.serverId}:subscription:${requestInput.subjectType}:${requestInput.subject}`, status: "subscribed", serverId: requestInput.serverId, connectionId: connected.output.connectionId, providerMetadata: metadata(connected.output.profile, { eventKinds: requestInput.eventKinds ?? [] }) });
+            const resourceUri = subscriptionResourceUri(requestInput);
+            if ((requestInput.subjectType === undefined || requestInput.subjectType === "resource") && resourceUri !== undefined) {
+                const subscribed = await request(connected.output, "resources/subscribe", { uri: resourceUri });
+                if (!subscribed.ok)
+                    return subscribed;
+                return success({
+                    subscriptionId: `${requestInput.serverId}:subscription:resource:${resourceUri}`,
+                    status: "subscribed",
+                    serverId: requestInput.serverId,
+                    connectionId: connected.output.connectionId,
+                    uri: resourceUri,
+                    providerMetadata: metadata(connected.output.profile, {
+                        method: "resources/subscribe",
+                        eventKinds: requestInput.eventKinds ?? [],
+                    }),
+                    raw: subscribed.output,
+                });
+            }
+            return success({
+                subscriptionId: `${requestInput.serverId}:subscription:${requestInput.subjectType}:${requestInput.subject}`,
+                status: "subscribed",
+                serverId: requestInput.serverId,
+                connectionId: connected.output.connectionId,
+                providerMetadata: metadata(connected.output.profile, {
+                    eventKinds: requestInput.eventKinds ?? [],
+                    hostSemantic: "subscribe",
+                    localOnly: true,
+                }),
+            });
         },
         async unsubscribe(requestInput) {
-            const profile = getProfile(requestInput.serverId);
-            if (profile === undefined)
-                return failure("MCP_SERVER_NOT_CONFIGURED", `MCP server '${requestInput.serverId}' is not configured.`);
-            return success({ subscriptionId: requestInput.subscriptionId, status: "unsubscribed", serverId: requestInput.serverId, providerMetadata: metadata(profile) });
+            const connected = await getConnection(requestInput.serverId, requestInput.connectionId);
+            if (!connected.ok)
+                return connected;
+            const resourceUri = subscriptionResourceUri(requestInput);
+            if (resourceUri !== undefined) {
+                const unsubscribed = await request(connected.output, "resources/unsubscribe", { uri: resourceUri });
+                if (!unsubscribed.ok)
+                    return unsubscribed;
+                return success({
+                    subscriptionId: requestInput.subscriptionId ?? `${requestInput.serverId}:subscription:resource:${resourceUri}`,
+                    status: "unsubscribed",
+                    serverId: requestInput.serverId,
+                    connectionId: connected.output.connectionId,
+                    uri: resourceUri,
+                    providerMetadata: metadata(connected.output.profile, { method: "resources/unsubscribe" }),
+                    raw: unsubscribed.output,
+                });
+            }
+            return success({
+                subscriptionId: requestInput.subscriptionId,
+                status: "unsubscribed",
+                serverId: requestInput.serverId,
+                connectionId: connected.output.connectionId,
+                providerMetadata: metadata(connected.output.profile, { hostSemantic: "unsubscribe", localOnly: true }),
+            });
         },
         async callTool(requestInput) {
             const connected = await getConnection(requestInput.serverId);
@@ -242,10 +691,16 @@ export function createMcpRuntimeAdapter(options) {
             return success({ executionId: `${requestInput.serverId}:execution:${requestInput.name}`, streamId: `${requestInput.serverId}:stream:${requestInput.name}`, status: "completed", channel: requestInput.channel ?? "chunks", chunks: [called.output], providerMetadata: metadata(connected.output.profile, { method: "tools/call", toolName: requestInput.name }) });
         },
         async cancelExecution(requestInput) {
-            const profile = getProfile(requestInput.serverId);
-            if (profile === undefined)
-                return failure("MCP_SERVER_NOT_CONFIGURED", `MCP server '${requestInput.serverId}' is not configured.`);
-            return success({ executionId: requestInput.executionId, status: "cancelled", serverId: requestInput.serverId, providerMetadata: metadata(profile) });
+            const connected = await getConnection(requestInput.serverId);
+            if (!connected.ok)
+                return connected;
+            const cancelled = await notify(connected.output, "notifications/cancelled", {
+                requestId: requestInput.executionId,
+                reason: requestInput.reason,
+            });
+            if (!cancelled.ok)
+                return cancelled;
+            return success({ executionId: requestInput.executionId, status: "cancelled", serverId: requestInput.serverId, providerMetadata: metadata(connected.output.profile, { method: "notifications/cancelled" }) });
         },
         async nativeExecute(requestInput) {
             const connected = await getConnection(requestInput.serverId);
@@ -260,7 +715,7 @@ export function createMcpRuntimeAdapter(options) {
             const connected = await getConnection(requestInput.serverId);
             if (!connected.ok)
                 return connected;
-            const listed = await request(connected.output, "tools/list", {});
+            const listed = await request(connected.output, "tools/list", requestInput.cursor === undefined ? {} : { cursor: requestInput.cursor });
             if (!listed.ok)
                 return listed;
             const raw = resultObject(listed.output);
@@ -272,7 +727,12 @@ export function createMcpRuntimeAdapter(options) {
                 namespace: requestInput.namespace,
                 raw: tool,
             })).filter((tool) => tool.name.length > 0) : [];
-            return success({ tools, providerMetadata: metadata(connected.output.profile, { method: "tools/list" }), raw: listed.output });
+            return success({
+                tools,
+                nextCursor: typeof raw.nextCursor === "string" ? raw.nextCursor : undefined,
+                providerMetadata: metadata(connected.output.profile, { method: "tools/list" }),
+                raw: listed.output,
+            });
         },
         async registerTool(requestInput) {
             const profile = getProfile(requestInput.serverId);
@@ -296,7 +756,7 @@ export function createMcpRuntimeAdapter(options) {
             const connected = await getConnection(requestInput.serverId);
             if (!connected.ok)
                 return connected;
-            const listed = await request(connected.output, "resources/list", {});
+            const listed = await request(connected.output, "resources/list", requestInput.cursor === undefined ? {} : { cursor: requestInput.cursor });
             if (!listed.ok)
                 return listed;
             const raw = resultObject(listed.output);
@@ -306,13 +766,47 @@ export function createMcpRuntimeAdapter(options) {
                 mimeType: typeof resource.mimeType === "string" ? resource.mimeType : typeof resource.mime_type === "string" ? resource.mime_type : undefined,
                 raw: resource,
             })).filter((resource) => resource.uri.length > 0 && (requestInput.uriPrefix === undefined || resource.uri.startsWith(requestInput.uriPrefix))) : [];
-            return success({ resources, exhausted: true, providerMetadata: metadata(connected.output.profile, { method: "resources/list" }), raw: listed.output });
+            const nextCursor = typeof raw.nextCursor === "string" ? raw.nextCursor : undefined;
+            return success({
+                resources,
+                nextCursor,
+                exhausted: nextCursor === undefined,
+                providerMetadata: metadata(connected.output.profile, { method: "resources/list" }),
+                raw: listed.output,
+            });
+        },
+        async listResourceTemplates(requestInput) {
+            const connected = await getConnection(requestInput.serverId);
+            if (!connected.ok)
+                return connected;
+            const listed = await request(connected.output, "resources/templates/list", requestInput.cursor === undefined ? {} : { cursor: requestInput.cursor });
+            if (!listed.ok)
+                return listed;
+            const raw = resultObject(listed.output);
+            const resourceTemplates = Array.isArray(raw.resourceTemplates) ? raw.resourceTemplates.filter(isObject).map((template) => ({
+                uriTemplate: String(template.uriTemplate ?? template.uri_template ?? ""),
+                name: typeof template.name === "string" ? template.name : undefined,
+                title: typeof template.title === "string" ? template.title : undefined,
+                description: typeof template.description === "string" ? template.description : undefined,
+                mimeType: typeof template.mimeType === "string" ? template.mimeType : typeof template.mime_type === "string" ? template.mime_type : undefined,
+                raw: template,
+            })).filter((template) => template.uriTemplate.length > 0) : [];
+            const nextCursor = typeof raw.nextCursor === "string" ? raw.nextCursor : undefined;
+            return success({
+                resourceTemplates,
+                templates: resourceTemplates,
+                nextCursor,
+                exhausted: nextCursor === undefined,
+                providerMetadata: metadata(connected.output.profile, { method: "resources/templates/list" }),
+                raw: listed.output,
+            });
         },
         async readResource(requestInput) {
             const connected = await getConnection(requestInput.serverId);
             if (!connected.ok)
                 return connected;
-            const read = await request(connected.output, "resources/read", { uri: requestInput.resourceUri });
+            const uri = typeof requestInput.uri === "string" ? requestInput.uri : requestInput.resourceUri;
+            const read = await request(connected.output, "resources/read", { uri });
             if (!read.ok)
                 return read;
             const raw = resultObject(read.output);
@@ -322,7 +816,7 @@ export function createMcpRuntimeAdapter(options) {
                 bytesBase64: typeof content.blob === "string" ? content.blob : undefined,
                 raw: content,
             })) : [];
-            return success({ uri: requestInput.resourceUri, contents, truncated: false, providerMetadata: metadata(connected.output.profile, { method: "resources/read" }), raw: read.output });
+            return success({ uri, contents, truncated: false, providerMetadata: metadata(connected.output.profile, { method: "resources/read" }), raw: read.output });
         },
         async listPrompts(requestInput) {
             const connected = await getConnection(requestInput.serverId);
@@ -350,11 +844,45 @@ export function createMcpRuntimeAdapter(options) {
                 return read;
             return success(read.output, metadata(connected.output.profile, { method: "prompts/get", promptName: requestInput.name }));
         },
+        async complete(requestInput) {
+            const connected = await getConnection(requestInput.serverId);
+            if (!connected.ok)
+                return connected;
+            const params = {
+                ref: isObject(requestInput.ref) ? requestInput.ref : {},
+                argument: isObject(requestInput.argument) ? requestInput.argument : {},
+                ...(isObject(requestInput.context) ? { context: requestInput.context } : {}),
+            };
+            const completed = await request(connected.output, "completion/complete", params);
+            if (!completed.ok)
+                return completed;
+            const raw = resultObject(completed.output);
+            const completion = isObject(raw.completion) ? raw.completion : {};
+            return success({
+                completion,
+                values: Array.isArray(completion.values) ? completion.values.filter((value) => typeof value === "string") : [],
+                total: typeof completion.total === "number" ? completion.total : undefined,
+                hasMore: typeof completion.hasMore === "boolean" ? completion.hasMore : undefined,
+                providerMetadata: metadata(connected.output.profile, { method: "completion/complete" }),
+                raw: completed.output,
+            });
+        },
         async setRoots(requestInput) {
             const profile = getProfile(requestInput.serverId);
             if (profile === undefined)
                 return failure("MCP_SERVER_NOT_CONFIGURED", `MCP server '${requestInput.serverId}' is not configured.`);
-            return success({ serverId: requestInput.serverId, roots: requestInput.roots ?? [], status: "registered", providerMetadata: metadata(profile, { hostSemantic: "roots" }) });
+            const roots = (Array.isArray(requestInput.roots) ? requestInput.roots.filter(isObject).map((root) => ({
+                uri: String(root.uri ?? ""),
+                name: typeof root.name === "string" ? root.name : undefined,
+                _meta: isObject(root._meta) ? root._meta : undefined,
+            })).filter((root) => root.uri.length > 0) : []);
+            rootsByServerId.set(requestInput.serverId, roots);
+            for (const [, connection] of connections) {
+                if (connection.profile.serverId === requestInput.serverId) {
+                    await notify(connection, "notifications/roots/list_changed", {});
+                }
+            }
+            return success({ serverId: requestInput.serverId, roots, status: "registered", providerMetadata: metadata(profile, { hostSemantic: "roots" }) });
         },
         async reportProgress(requestInput) {
             const profile = getProfile(requestInput.serverId);
@@ -375,10 +903,14 @@ export function createMcpRuntimeAdapter(options) {
             return success({ serverId: requestInput.serverId, status: "pending", request: requestInput, providerMetadata: metadata(profile, { hostSemantic: "elicitation" }) });
         },
         async setLoggingLevel(requestInput) {
-            const profile = getProfile(requestInput.serverId);
-            if (profile === undefined)
-                return failure("MCP_SERVER_NOT_CONFIGURED", `MCP server '${requestInput.serverId}' is not configured.`);
-            return success({ serverId: requestInput.serverId, level: requestInput.level ?? "info", status: "configured", providerMetadata: metadata(profile, { hostSemantic: "logging" }) });
+            const connected = await getConnection(requestInput.serverId);
+            if (!connected.ok)
+                return connected;
+            const level = requestInput.level ?? "info";
+            const configured = await request(connected.output, "logging/setLevel", { level });
+            if (!configured.ok)
+                return configured;
+            return success({ serverId: requestInput.serverId, level, status: "configured", providerMetadata: metadata(connected.output.profile, { method: "logging/setLevel" }), raw: configured.output });
         },
         async createResource(requestInput) {
             const profile = getProfile(requestInput.serverId);
@@ -427,8 +959,7 @@ async function requestStdio(connection, method, params) {
         }, timeoutMs);
         connection.pending.set(id, { resolve, reject, timeout });
     });
-    const framing = connection.profile.transport === "stdio" ? connection.profile.framing : undefined;
-    connection.child.stdin.write(framing === "line-json" ? `${JSON.stringify(payload)}\n` : contentLengthFrame(payload));
+    writeStdioPayload(connection, payload);
     try {
         return normalizeJsonRpcResponse(await response);
     }
@@ -436,22 +967,42 @@ async function requestStdio(connection, method, params) {
         return failure("MCP_STDIO_REQUEST_FAILED", textFromUnknown(error.message ?? error));
     }
 }
-async function requestHttp(profile, method, params) {
+async function notifyStdio(connection, method, params) {
+    if (connection.child === undefined)
+        return failure("MCP_STDIO_NOT_CONNECTED", "MCP stdio child process is not connected.");
+    writeStdioPayload(connection, { jsonrpc: "2.0", method, params });
+    return success({ status: "notified" });
+}
+function httpHeaders(profile, sessionId) {
+    return {
+        "content-type": "application/json",
+        accept: "application/json, text/event-stream",
+        "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+        ...(profile.headers ?? {}),
+        ...(sessionId === undefined ? {} : { [MCP_SESSION_ID_HEADER]: sessionId }),
+    };
+}
+function resolveLegacySseEndpointUrl(profile, endpoint) {
+    return new URL(endpoint, profile.sseUrl ?? profile.url).toString();
+}
+async function postJsonRpcPayload(profile, url, payload, sessionId) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), profile.timeoutMs ?? 5_000);
     try {
-        const response = await fetch(profile.url, {
+        const response = await fetch(url, {
             method: "POST",
-            headers: { "content-type": "application/json", ...(profile.headers ?? {}) },
-            body: JSON.stringify({ jsonrpc: "2.0", id: `${Date.now()}:${Math.random()}`, method, params }),
+            headers: httpHeaders(profile, sessionId),
+            body: JSON.stringify(payload),
             signal: controller.signal,
         });
         if (!response.ok)
             return failure("MCP_HTTP_REQUEST_FAILED", `MCP HTTP endpoint returned HTTP ${response.status}.`);
-        const json = await response.json();
-        if (!isObject(json))
-            return failure("MCP_HTTP_RESPONSE_INVALID", "MCP HTTP response was not a JSON object.");
-        return normalizeJsonRpcResponse(json);
+        const body = await response.text();
+        const messages = body.trim().length === 0 ? [] : parseHttpJsonRpcMessages(response.headers.get("content-type"), body);
+        if (messages === undefined)
+            return failure("MCP_HTTP_RESPONSE_INVALID", "MCP HTTP response was not valid JSON or SSE JSON-RPC.");
+        const responseSessionId = response.headers.get(MCP_SESSION_ID_HEADER) ?? undefined;
+        return success({ messages }, responseSessionId === undefined ? undefined : { mcpSessionId: responseSessionId });
     }
     catch (error) {
         return failure("MCP_HTTP_REQUEST_FAILED", textFromUnknown(error.message ?? error));
@@ -460,6 +1011,47 @@ async function requestHttp(profile, method, params) {
         clearTimeout(timeout);
     }
 }
+async function requestHttp(profile, method, params, sessionId, onNotification) {
+    const requestId = `${Date.now()}:${Math.random()}`;
+    const posted = await postJsonRpcPayload(profile, profile.url, { jsonrpc: "2.0", id: requestId, method, params }, sessionId);
+    if (!posted.ok)
+        return posted;
+    const messages = posted.output.messages;
+    for (const message of messages) {
+        if (typeof message.method === "string" && (message.id === undefined || message.id === null)) {
+            onNotification?.(message);
+        }
+    }
+    const responseMessage = messages.find((message) => message.id === requestId)
+        ?? messages.find((message) => message.id !== undefined && message.id !== null && message.method === undefined);
+    if (responseMessage === undefined)
+        return failure("MCP_HTTP_RESPONSE_INVALID", "MCP HTTP response did not include a JSON-RPC response for the request.");
+    const normalized = normalizeJsonRpcResponse(responseMessage);
+    if (!normalized.ok || posted.metadata?.mcpSessionId === undefined)
+        return normalized;
+    return success(normalized.output, { ...(normalized.metadata ?? {}), mcpSessionId: posted.metadata.mcpSessionId });
+}
+async function notifyHttp(profile, method, params, sessionId) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), profile.timeoutMs ?? 5_000);
+    try {
+        const response = await fetch(profile.url, {
+            method: "POST",
+            headers: httpHeaders(profile, sessionId),
+            body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return failure("MCP_HTTP_NOTIFICATION_FAILED", `MCP HTTP endpoint returned HTTP ${response.status}.`);
+        return success({ status: "notified" });
+    }
+    catch (error) {
+        return failure("MCP_HTTP_NOTIFICATION_FAILED", textFromUnknown(error.message ?? error));
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 function normalizeJsonRpcResponse(response) {
     if (response.error !== undefined) {
         return failure("MCP_JSONRPC_ERROR", response.error.message ?? `MCP JSON-RPC error ${String(response.error.code ?? "unknown")}.`);