kritya 0.8.13-beta → 0.8.15-beta

package/README.md

@@ -3,6 +3,11 @@
 [![CI](https://github.com/GenAICloudDevOps/Kritya/actions/workflows/ci.yml/badge.svg)](https://github.com/GenAICloudDevOps/Kritya/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/kritya/beta)](https://www.npmjs.com/package/kritya)
 [![License](https://img.shields.io/github/license/GenAICloudDevOps/Kritya)](LICENSE)
+[![Socket](https://img.shields.io/badge/Socket-scanned-brightgreen)](https://socket.dev/npm/package/kritya)
+
+Dependency risk is scanned on [Socket](https://socket.dev/npm/package/kritya);
+see [SECURITY.md](SECURITY.md#dependency-scanning) for how flagged findings
+are triaged.
 
 > ⚠️ **Beta** — APIs, flags, and behavior may still change between releases.
 

package/dist/mcp/client.js

@@ -8,6 +8,9 @@ import { missingVars } from "./servers.js";
 import { HttpTransport, StdioTransport } from "./transport.js";
 import { isPrivateOrLoopbackHost } from "../net/urlSafety.js";
 import { checkToolsShape, serverFingerprint } from "../trust/mcpTrust.js";
+import { probeStdioEra, probeHttpEra } from "./eraDetect.js";
+import { ModernMcpConnection } from "./clientModern.js";
+import { ModernHttpTransport, ReusedProcessTransport } from "./transportModern.js";
 /**
  * Thrown when a server's live tool shape no longer matches what was recorded
  * the first time its config was trusted — see checkToolsShape.
@@ -717,10 +720,52 @@ export async function connectServer(name, cfg, trace) {
         if (missing.length) {
             throw new Error(`missing env var${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`);
         }
-        conn = new McpConnection(name, makeTransport(name, cfg, workspace), workspace, {
-            onSampling: trace?.onSampling,
-            onElicitation: trace?.onElicitation,
-        });
+        // Checked here, before era detection branches on cfg.url, so a config
+        // setting both never quietly takes the modern-HTTP path — makeTransport
+        // (the legacy path's own guard) is skipped entirely whenever era
+        // detection resolves to modern, so this can't be left to run there alone.
+        if (cfg.url && cfg.command) {
+            throw new Error(`server "${name}" sets both "command" and "url"; pick one`);
+        }
+        let modernConn;
+        if (cfg.url) {
+            assertSafeUrl(name, cfg.url);
+            const probe = await probeHttpEra(cfg.url, cfg.headers ?? {});
+            if (probe.era === "modern") {
+                if (probe.discover) {
+                    modernConn = new ModernMcpConnection(name, new ModernHttpTransport(cfg.url, cfg.headers ?? {}));
+                }
+                else {
+                    throw new Error(`server "${name}" speaks the modern MCP protocol but rejected protocol version ` +
+                        `"2026-07-28" — this server may require a newer or older kritya`);
+                }
+            }
+        }
+        else if (cfg.command) {
+            const cwd = cfg.cwd ? path.resolve(workspace, cfg.cwd) : workspace;
+            const probe = await probeStdioEra(cfg.command, cfg.args ?? [], cfg.env, cwd);
+            if (probe.era === "modern") {
+                // Reuse the already-spawned probe process when the server kept it
+                // alive. A modern server that rejected our protocol version keeps no
+                // process alive — don't fall through to the legacy path, which would
+                // spawn a second process against a server that just told us it can't
+                // speak our version, producing a misleading "method not found"-style
+                // error instead of naming the real problem.
+                if (probe.process) {
+                    modernConn = new ModernMcpConnection(name, new ReusedProcessTransport(probe.process));
+                }
+                else {
+                    throw new Error(`server "${name}" speaks the modern MCP protocol but rejected protocol version ` +
+                        `"2026-07-28" — this server may require a newer or older kritya`);
+                }
+            }
+        }
+        conn =
+            modernConn ??
+                new McpConnection(name, makeTransport(name, cfg, workspace), workspace, {
+                    onSampling: trace?.onSampling,
+                    onElicitation: trace?.onElicitation,
+                });
         const listed = await conn.initialize();
         const specs = listed.tools;
         const shape = checkToolsShape(serverFingerprint(cfg), specs, trace?.mcpTrustFile);

package/dist/mcp/clientModern.js

@@ -0,0 +1,141 @@
+import { modernMeta } from "./eraDetect.js";
+/**
+ * Split the same way legacy McpConnection splits its timeouts: connect-time
+ * calls (the three list calls during initialize()) get a short ceiling since
+ * a hung server there should fail fast, while tools/call — which can
+ * legitimately run long — gets the generous one.
+ */
+const CONNECT_TIMEOUT_MS = 15_000;
+const CALL_TIMEOUT_MS = 120_000;
+/**
+ * Modern (2026-07-28+) MCP client: no `initialize`, every request carries
+ * its own `_meta`. Implements the same minimal surface as the legacy
+ * `McpConnection` (see docs/superpowers/specs/2026-08-30-mcp-modern-protocol-design.md)
+ * so `connectServer()` can use either interchangeably. `resultType:
+ * "input_required"` (MRTR — sampling/elicitation/roots) is rejected with a
+ * clear error here; Sub-project 2 replaces this with the real retry loop.
+ */
+export class ModernMcpConnection {
+    name;
+    transport;
+    nextId = 1;
+    pending = new Map();
+    closed = false;
+    constructor(name, transport) {
+        this.name = name;
+        this.transport = transport;
+        transport.onMessage = (msg) => this.onMessage(msg);
+        transport.onError = (err) => this.fail(new Error(`MCP server "${name}": ${err.message}`));
+    }
+    fail(err) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        this.pending.clear();
+    }
+    onMessage(msg) {
+        if (typeof msg.id !== "number")
+            return;
+        const p = this.pending.get(msg.id);
+        if (!p)
+            return;
+        this.pending.delete(msg.id);
+        clearTimeout(p.timer);
+        if (msg.error)
+            p.reject(new Error(msg.error.message ?? "MCP error"));
+        else
+            p.resolve(msg.result);
+    }
+    request(method, params, timeoutMs, signal) {
+        if (this.closed)
+            return Promise.reject(new Error(`MCP server "${this.name}" is not running`));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request "${method}" timed out`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.transport
+                .send({ jsonrpc: "2.0", id, method, params: { ...params, _meta: modernMeta() } }, timeoutMs, signal)
+                .catch((err) => {
+                const p = this.pending.get(id);
+                if (!p)
+                    return;
+                this.pending.delete(id);
+                clearTimeout(p.timer);
+                p.reject(err);
+            });
+        });
+    }
+    /** Unwrap a modern result's resultType, throwing for input_required (MRTR — Sub-project 2). */
+    unwrap(result) {
+        const r = result;
+        if (r.resultType === "input_required") {
+            throw new Error(`MCP server "${this.name}" requires an interactive capability (sampling, elicitation, ` +
+                `or roots) that modern-mode kritya does not yet support`);
+        }
+        if (r.resultType !== undefined && r.resultType !== "complete") {
+            throw new Error(`MCP server "${this.name}" returned an unrecognized resultType "${r.resultType}"`);
+        }
+        return result;
+    }
+    async initialize() {
+        const listed = this.unwrap(await this.request("tools/list", {}, CONNECT_TIMEOUT_MS));
+        let prompts = [];
+        let resources = [];
+        try {
+            const p = this.unwrap(await this.request("prompts/list", {}, CONNECT_TIMEOUT_MS));
+            prompts = p.prompts ?? [];
+        }
+        catch {
+            // prompts unsupported by this server — non-fatal, same as legacy behavior
+        }
+        try {
+            const r = this.unwrap(await this.request("resources/list", {}, CONNECT_TIMEOUT_MS));
+            resources = r.resources ?? [];
+        }
+        catch {
+            // resources unsupported — non-fatal
+        }
+        return { tools: listed.tools ?? [], prompts, resources };
+    }
+    async getPrompt(name, args) {
+        const result = this.unwrap(await this.request("prompts/get", { name, arguments: args }, CALL_TIMEOUT_MS));
+        const messages = result.messages ?? [];
+        const multiRole = new Set(messages.map((m) => m.role ?? "user")).size > 1;
+        return messages
+            .map((m) => {
+            const text = m.content?.text ?? "";
+            return multiRole ? `[${m.role ?? "user"}] ${text}` : text;
+        })
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    async readResource(uri) {
+        const result = this.unwrap(await this.request("resources/read", { uri }, CALL_TIMEOUT_MS));
+        return (result.contents ?? []).map((c) => c.text ?? "").join("\n");
+    }
+    async callTool(toolName, args, signal, _tasksEnabled, _onProgress) {
+        // Tasks-under-modern is out of scope for this plan (see spec's "Out of
+        // scope"); the params exist only so this signature matches
+        // McpConnection.callTool's, which callers invoke uniformly through the
+        // McpConnection | ModernMcpConnection union built in Task 6.
+        const result = this.unwrap(await this.request("tools/call", { name: toolName, arguments: args }, CALL_TIMEOUT_MS, signal));
+        const text = (result.content ?? [])
+            .filter((b) => b.type === "text")
+            .map((b) => b.text ?? "")
+            .join("\n");
+        if (result.isError)
+            throw new Error(text || "MCP tool reported an error");
+        return text || "(no output)";
+    }
+    close() {
+        this.fail(new Error(`MCP server "${this.name}" connection closed`));
+        this.transport.close();
+    }
+}

package/dist/mcp/eraDetect.js

@@ -0,0 +1,209 @@
+import { VERSION } from "../version.js";
+/**
+ * Era detection and the modern (2026-07-28+) per-request `_meta` shape.
+ *
+ * Modern MCP has no `initialize` handshake: every request carries its
+ * protocol version, capabilities, and identity in `_meta`, and the server
+ * answers each request independently. See
+ * /specification/2026-07-28/basic/versioning for the era model this file
+ * implements detection for.
+ */
+export const MODERN_PROTOCOL_VERSION = "2026-07-28";
+/** The `_meta` block every modern request carries, per spec's "Per-request protocol fields". */
+export function modernMeta(clientCapabilities = {}) {
+    return {
+        "io.modelcontextprotocol/protocolVersion": MODERN_PROTOCOL_VERSION,
+        "io.modelcontextprotocol/clientInfo": { name: "kritya", version: VERSION },
+        "io.modelcontextprotocol/clientCapabilities": clientCapabilities,
+    };
+}
+/** The three error codes the 2026-07-28 spec reserves for version/capability/header mismatches. */
+const MODERN_ERROR_CODES = new Set([-32020, -32021, -32022]);
+export function isRecognizedModernError(err) {
+    return typeof err?.code === "number" && MODERN_ERROR_CODES.has(err.code);
+}
+/** Parse a raw JSON-RPC `result` into a DiscoverResult; undefined if the shape doesn't match. */
+export function parseDiscoverResult(result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const r = result;
+    if (!Array.isArray(r.supportedVersions) ||
+        !r.supportedVersions.every((v) => typeof v === "string")) {
+        return undefined;
+    }
+    if (!r.capabilities || typeof r.capabilities !== "object")
+        return undefined;
+    return {
+        supportedVersions: r.supportedVersions,
+        capabilities: r.capabilities,
+        serverInfo: r._meta?.["io.modelcontextprotocol/serverInfo"],
+        instructions: typeof r.instructions === "string" ? r.instructions : undefined,
+    };
+}
+import { spawn } from "node:child_process";
+import { planSpawn } from "./spawnWin.js";
+import { minimalEnv } from "./transport.js";
+import { OAuthSession } from "./oauth.js";
+const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
+/**
+ * Probe a stdio server with `server/discover`, per
+ * /specification/2026-07-28/basic/transports/stdio#backward-compatibility.
+ * Three outcomes: a DiscoverResult (modern, process kept alive for reuse), a
+ * recognized modern error (modern, but report — don't fall back), or
+ * anything else / a timeout (legacy — the caller launches its own process).
+ */
+export function probeStdioEra(command, args, env, cwd, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const plan = planSpawn(command, args);
+        const proc = spawn(plan.command, plan.args, {
+            // Minimal env, not the full process env — see StdioTransport's
+            // minimalEnv() doc comment: a probe process is still a third-party MCP
+            // server and must not automatically receive kritya's own API keys.
+            env: { ...minimalEnv(), ...env },
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsVerbatimArguments: plan.windowsVerbatimArguments,
+        });
+        // Draining stderr is not optional here either: a server that logs more
+        // than the OS pipe buffer blocks in its own write() forever if nobody
+        // reads it, even during just the probe's short wait. Kept attached
+        // (never removed) so a process handed off to ReusedProcessTransport
+        // keeps draining seamlessly across that handoff.
+        proc.stderr?.setEncoding("utf8");
+        proc.stderr?.on("data", () => { });
+        let buffer = "";
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            proc.stdout?.removeAllListeners("data");
+            if (result.era === "legacy")
+                proc.kill();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish({ era: "legacy" }), timeoutMs);
+        timer.unref?.();
+        proc.on("error", () => finish({ era: "legacy" }));
+        proc.stdout?.setEncoding("utf8");
+        proc.stdout?.on("data", (chunk) => {
+            buffer += chunk;
+            let idx;
+            while ((idx = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, idx).trim();
+                buffer = buffer.slice(idx + 1);
+                if (!line)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    // Some servers log to stdout — tolerate a non-JSON line the same
+                    // way StdioTransport does, and keep listening for the real reply.
+                    continue;
+                }
+                if (msg.result !== undefined) {
+                    const discover = parseDiscoverResult(msg.result);
+                    if (discover) {
+                        finish({ era: "modern", process: proc, discover });
+                        return;
+                    }
+                }
+                if (isRecognizedModernError(msg.error)) {
+                    proc.kill();
+                    finish({ era: "modern" });
+                    return;
+                }
+                finish({ era: "legacy" });
+                return;
+            }
+        });
+        proc.stdin?.write(JSON.stringify({
+            jsonrpc: "2.0",
+            id: "discover-probe",
+            method: "server/discover",
+            params: { _meta: modernMeta() },
+        }) + "\n");
+    });
+}
+const DEFAULT_HTTP_PROBE_TIMEOUT_MS = 10_000;
+/**
+ * Probe an HTTP server by attempting a modern `server/discover` POST, per
+ * /specification/2026-07-28/basic/transports/streamable-http#backward-compatibility.
+ *
+ * OAuth-aware: without this, an OAuth-protected modern server answers with a
+ * 401 (neither a DiscoverResult nor a recognized modern error), which used to
+ * be classified as "legacy" — permanently hiding a modern server behind auth,
+ * since the real ModernHttpTransport connection (which *does* handle OAuth)
+ * would then never run against it. A bearer token is injected the same way
+ * `ModernHttpTransport.buildHeaders` does, and a 401 is given one
+ * refresh-and-retry before falling back to "legacy" — matching the retry
+ * shape `ModernHttpTransport.send`/`HttpTransport.send` use post-connect.
+ */
+export async function probeHttpEra(url, headers, timeoutMs = DEFAULT_HTTP_PROBE_TIMEOUT_MS) {
+    const oauth = new OAuthSession(url);
+    const hasExplicitAuth = Object.keys(headers).some((k) => k.toLowerCase() === "authorization");
+    const buildHeaders = async () => {
+        const built = {
+            ...headers,
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            "mcp-protocol-version": MODERN_PROTOCOL_VERSION,
+            "mcp-method": "server/discover",
+        };
+        if (!hasExplicitAuth) {
+            const token = await oauth.accessToken();
+            if (token)
+                built.authorization = `Bearer ${token}`;
+        }
+        return built;
+    };
+    const post = async () => fetch(url, {
+        method: "POST",
+        headers: await buildHeaders(),
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "discover-probe",
+            method: "server/discover",
+            params: { _meta: modernMeta() },
+        }),
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    let res;
+    try {
+        res = await post();
+        if (res.status === 401 && !hasExplicitAuth) {
+            // Give a stored (or freshly refreshed) token a fair shot before
+            // concluding legacy — a server that only needed auth deserves a real
+            // DiscoverResult or recognized modern error, not a guess.
+            const refreshed = await oauth.handleUnauthorized();
+            if (refreshed) {
+                await res.body?.cancel().catch(() => { });
+                res = await post();
+            }
+        }
+    }
+    catch {
+        return { era: "legacy" };
+    }
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        return { era: "legacy" };
+    }
+    const msg = body;
+    if (res.ok) {
+        const discover = parseDiscoverResult(msg.result);
+        if (discover)
+            return { era: "modern", discover };
+        return { era: "legacy" };
+    }
+    if (isRecognizedModernError(msg.error))
+        return { era: "modern" };
+    return { era: "legacy" };
+}

package/dist/mcp/transport.js

@@ -22,7 +22,7 @@ const PASSTHROUGH_ENV_VARS = [
     "LOCALAPPDATA",
     "NODE_PATH",
 ];
-function minimalEnv() {
+export function minimalEnv() {
     const env = {};
     for (const key of PASSTHROUGH_ENV_VARS) {
         const value = process.env[key];
@@ -36,7 +36,7 @@ function minimalEnv() {
  * `AbortSignal.any` only landed in Node 20 and we support 18, hence the manual
  * bridge.
  */
-function withTimeout(timeoutMs, signal) {
+export function withTimeout(timeoutMs, signal) {
     const timeout = AbortSignal.timeout(timeoutMs);
     if (!signal)
         return timeout;

package/dist/mcp/transportModern.js

@@ -0,0 +1,267 @@
+import { McpAuthRequiredError, OAuthSession, parseWwwAuthenticate } from "./oauth.js";
+import { withTimeout } from "./transport.js";
+import { modernMeta, MODERN_PROTOCOL_VERSION } from "./eraDetect.js";
+/** Same-origin redirects we'll follow before calling it a loop. */
+const MAX_REDIRECTS = 5;
+/** How much of a server's stderr to keep for diagnostics, and how much to report. */
+const STDERR_KEEP_BYTES = 8_192;
+const STDERR_REPORT_LINES = 5;
+function isRedirect(status) {
+    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+/**
+ * True when a string is safe to send verbatim as an HTTP header value:
+ * visible ASCII (0x21-0x7E), space, and horizontal tab only, no
+ * leading/trailing whitespace, per RFC 9110 field-value rules.
+ */
+function isPlainAsciiHeaderSafe(s) {
+    if (s !== s.trim())
+        return false;
+    return /^[\t\x20-\x7E]*$/.test(s);
+}
+const BASE64_SENTINEL_RE = /^=\?base64\?[A-Za-z0-9+/=]*\?=$/;
+/**
+ * Encode a value for an `Mcp-Name`/`Mcp-Param-*` header per the 2026-07-28
+ * Streamable HTTP spec's Value Encoding rules: plain ASCII as-is, otherwise
+ * (or if it collides with the sentinel pattern itself) base64-sentinel the
+ * UTF-8 bytes.
+ */
+export function encodeHeaderValue(value) {
+    if (isPlainAsciiHeaderSafe(value) && !BASE64_SENTINEL_RE.test(value))
+        return value;
+    return `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+/** Pull the `Mcp-Name` source value (params.name or params.uri) for a request, if any. */
+function mcpNameFor(msg) {
+    const params = msg.params;
+    if (typeof params?.name === "string")
+        return params.name;
+    if (typeof params?.uri === "string")
+        return params.uri;
+    return undefined;
+}
+/**
+ * Streamable HTTP transport for the modern (2026-07-28+), stateless,
+ * per-request era: no `Mcp-Session-Id`, no `initialize`, every POST carries
+ * `_meta` in the body and mirrors `MCP-Protocol-Version`/`Mcp-Method`/
+ * `Mcp-Name` into headers. See
+ * /specification/2026-07-28/basic/transports/streamable-http.
+ */
+export class ModernHttpTransport {
+    url;
+    headers;
+    onMessage = () => { };
+    onError = () => { };
+    oauth;
+    constructor(url, headers) {
+        this.url = url;
+        this.headers = headers;
+        this.oauth = new OAuthSession(url);
+    }
+    async buildHeaders(msg) {
+        const headers = {
+            ...this.headers,
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            "mcp-protocol-version": MODERN_PROTOCOL_VERSION,
+            "mcp-method": msg.method ?? "",
+        };
+        const name = mcpNameFor(msg);
+        if (name !== undefined)
+            headers["mcp-name"] = encodeHeaderValue(name);
+        const hasExplicitAuth = Object.keys(headers).some((k) => k.toLowerCase() === "authorization");
+        if (!hasExplicitAuth) {
+            const token = await this.oauth.accessToken();
+            if (token)
+                headers.authorization = `Bearer ${token}`;
+        }
+        return headers;
+    }
+    withMeta(msg) {
+        const params = (msg.params ?? {});
+        return { ...msg, params: { ...params, _meta: modernMeta() } };
+    }
+    async send(msg, timeoutMs, signal) {
+        const body = this.withMeta(msg);
+        let res = await this.post(body, timeoutMs, signal);
+        if (res.status === 401) {
+            const refreshed = await this.oauth.handleUnauthorized();
+            if (refreshed) {
+                await res.body?.cancel().catch(() => { });
+                res = await this.post(body, timeoutMs, signal);
+            }
+            if (res.status === 401) {
+                const challenge = parseWwwAuthenticate(res.headers.get("www-authenticate"));
+                await res.body?.cancel().catch(() => { });
+                throw new McpAuthRequiredError(this.url, challenge);
+            }
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                // not JSON — fall through to the generic HTTP error below
+            }
+            if (parsed?.error) {
+                this.onMessage(parsed);
+                return;
+            }
+            throw new Error(`HTTP ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
+        }
+        const contentType = res.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            const parsed = (await res.json());
+            this.onMessage(parsed);
+        }
+        else if (contentType.includes("text/event-stream")) {
+            await this.readSse(res);
+        }
+    }
+    async post(msg, timeoutMs, signal) {
+        const body = JSON.stringify(msg);
+        let url = this.url;
+        for (let hop = 0;; hop++) {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: await this.buildHeaders(msg),
+                body,
+                redirect: "manual",
+                signal: withTimeout(timeoutMs, signal),
+            });
+            if (!isRedirect(res.status))
+                return res;
+            const location = res.headers.get("location");
+            await res.body?.cancel().catch(() => { });
+            if (!location)
+                throw new Error(`HTTP ${res.status} redirect with no Location header`);
+            if (hop >= MAX_REDIRECTS)
+                throw new Error(`too many redirects from ${this.url}`);
+            const target = new URL(location, url);
+            if (target.origin !== new URL(url).origin) {
+                throw new Error(`refusing redirect to a different origin (${target.origin}) — ` +
+                    `it would send this server's credentials there.`);
+            }
+            url = target.toString();
+        }
+    }
+    async readSse(res) {
+        if (!res.body)
+            return;
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const dispatch = (rawEvent) => {
+            const data = rawEvent
+                .split(/\r?\n/)
+                .filter((l) => l.startsWith("data:"))
+                .map((l) => l.slice(5).trimStart())
+                .join("\n");
+            if (!data)
+                return;
+            try {
+                this.onMessage(JSON.parse(data));
+            }
+            catch {
+                // ignore non-JSON events (comments, keep-alives)
+            }
+        };
+        for await (const chunk of res.body) {
+            buffer += decoder.decode(chunk, { stream: true });
+            let idx;
+            while ((idx = buffer.search(/\r?\n\r?\n/)) >= 0) {
+                const rawEvent = buffer.slice(0, idx);
+                buffer = buffer.slice(idx).replace(/^\r?\n\r?\n/, "");
+                dispatch(rawEvent);
+            }
+        }
+        if (buffer.trim())
+            dispatch(buffer);
+    }
+    close() {
+        // No session to terminate — modern mode never sends DELETE.
+    }
+}
+/**
+ * Wraps an already-spawned stdio child process — one `probeStdioEra` kept
+ * alive after a successful `server/discover` — as a `Transport`, instead of
+ * paying for a second process launch.
+ *
+ * Mirrors `StdioTransport`'s framing and lifecycle handling (line buffering
+ * across chunk boundaries, `onError` wired to `close`/`exit`/`error`) rather
+ * than a one-shot "resolve on next data event" adapter: `ModernMcpConnection`
+ * can have more than one request in flight (e.g. concurrent tool calls), and
+ * a naive adapter would resolve the wrong `send()` call, or drop data split
+ * across multiple chunks/lines.
+ */
+export class ReusedProcessTransport {
+    proc;
+    onMessage = () => { };
+    onError = () => { };
+    buffer = "";
+    /** Tail of the server's stderr, kept for the exit message (see StdioTransport). */
+    stderrTail = "";
+    constructor(proc) {
+        this.proc = proc;
+        // Attached first, before anything else: draining stderr is not optional
+        // (see StdioTransport's doc comment) — a server that logs more than the
+        // OS pipe buffer blocks in its own write() forever if nobody reads it,
+        // and the process may already be mid-flight from probeStdioEra's own
+        // (brief) probe window.
+        this.proc.stderr?.setEncoding("utf8");
+        this.proc.stderr?.on("data", (chunk) => {
+            this.stderrTail = (this.stderrTail + chunk).slice(-STDERR_KEEP_BYTES);
+        });
+        this.proc.stdout?.setEncoding("utf8");
+        this.proc.stdout?.on("data", (chunk) => this.onData(chunk));
+        let reported = false;
+        const report = (code, signal) => {
+            if (reported)
+                return;
+            reported = true;
+            const how = signal ? `killed by ${signal}` : `exited with code ${code ?? 0}`;
+            this.onError(new Error(`server process ${how}${this.stderrDetail()}`));
+        };
+        // Same close/exit split as StdioTransport: "close" waits for stdio to
+        // flush, "exit" arms a short fallback in case a grandchild holds the
+        // pipes open.
+        this.proc.on("close", report);
+        this.proc.on("exit", (code, signal) => {
+            setTimeout(() => report(code, signal), 200).unref();
+        });
+        this.proc.on("error", (err) => this.onError(new Error(`${err.message}${this.stderrDetail()}`)));
+    }
+    /** The last few non-blank stderr lines, formatted for an error message. */
+    stderrDetail() {
+        const lines = this.stderrTail
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter(Boolean)
+            .slice(-STDERR_REPORT_LINES);
+        return lines.length ? ` — stderr: ${lines.join(" | ")}` : "";
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        let idx;
+        while ((idx = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, idx).trim();
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            try {
+                this.onMessage(JSON.parse(line));
+            }
+            catch {
+                // ignore non-JSON (some servers log to stdout)
+            }
+        }
+    }
+    send(msg) {
+        this.proc.stdin?.write(JSON.stringify(msg) + "\n");
+        return Promise.resolve();
+    }
+    close() {
+        this.proc.kill();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.13-beta",
+  "version": "0.8.15-beta",
   "description": "Kritya — a lean, provider-agnostic terminal coding agent (NVIDIA, OpenAI, OpenRouter, Groq, Ollama, and more)",
   "type": "module",
   "publishConfig": {