md-semantic-search 1.0.3 → 2.0.0

package/dist/markdown-parser.js

@@ -139,9 +139,63 @@ export function resolveChunkBudget(tokens, defaultMax = 1200) {
     }
     return defaultMax;
 }
+/**
+ * issue #202: script-calibrated token estimate for the sentencepiece E5/BGE
+ * vocab family — the fast-path alternative to running the real tokenizer per
+ * block. Ratios are calibrated so the estimate errs slightly HIGH: a budget
+ * checked against this estimate never overflows the model's real maxTokens.
+ *   Latin/digits/punctuation ≈ 4 chars/token, Cyrillic ≈ 1.8 chars/token
+ *   (RU systematically under-chunked by the old char budget — the point of
+ *   this issue), CJK ≈ 1 token/char, whitespace mostly merges into the
+ *   following subword so it counts a little.
+ */
+export function estimateTokens(text) {
+    let tokens = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if (c >= 0x0400 && c <= 0x04ff)
+            tokens += 0.55; // Cyrillic (+ Cyrillic supplement edges)
+        else if ((c >= 0x3040 && c <= 0x30ff) || // hiragana / katakana
+            (c >= 0x3400 && c <= 0x4dbf) || // CJK ext A
+            (c >= 0x4e00 && c <= 0x9fff) || // CJK unified
+            (c >= 0xff00 && c <= 0xffef) // fullwidth forms
+        ) {
+            tokens += 1.0;
+        }
+        else if (c === 0x20 || (c >= 0x09 && c <= 0x0d))
+            tokens += 0.08;
+        else if (c < 0x80)
+            tokens += 0.25; // ASCII (latin, digits, punctuation, markdown syntax)
+        else
+            tokens += 0.35; // other scripts / symbols — conservative middle ground
+    }
+    return Math.ceil(tokens);
+}
+/** Char budget (pre-#202 behavior) vs token budget (issue #202). */
+export function resolveChunkingBudget(opts) {
+    if (opts.maxChunkTokens && Number.isFinite(opts.maxChunkTokens) && opts.maxChunkTokens > 0) {
+        const budget = Math.max(32, Math.round(opts.maxChunkTokens));
+        return { budget, measure: opts.countTokens ?? estimateTokens, unit: 'tokens' };
+    }
+    const budget = resolveChunkBudget(undefined, opts.maxChunk ?? 1200);
+    return { budget, measure: (t) => t.length, unit: 'chars' };
+}
+/**
+ * issue #202: the DEFAULT chunk budget in tokens, derived from the embedding
+ * adapter's context window. Capped at 512 — a passage much larger than that
+ * dilutes retrieval granularity even for models with 8k+ context (bge-m3).
+ * Returns undefined for adapters without a known maxTokens, which keeps the
+ * legacy char budget instead of guessing.
+ */
+export function defaultChunkTokenBudget(adapter) {
+    const mt = adapter?.maxTokens;
+    if (!mt || !Number.isFinite(mt) || mt <= 0)
+        return undefined;
+    return Math.min(Math.round(mt), 512);
+}
 export function chunkMarkdownStructural(input, opts) {
     const options = typeof opts === 'number' ? { maxChunk: opts } : (opts || {});
-    const maxChunk = resolveChunkBudget(options.targetTokens, options.maxChunk ?? 1200);
+    const { budget: maxChunk, measure } = resolveChunkingBudget(options);
     const blocks = typeof input === 'string' ? parseMarkdownBlocks(input) : input;
     const chunks = [];
     const headingStack = [];
@@ -149,6 +203,8 @@ export function chunkMarkdownStructural(input, opts) {
     let currentLen = 0;
     let groupStartLine = 0;
     let groupEndLine = 0;
+    // measured size of the '\n\n' joiner — 2 in char mode, ~1 in token mode
+    const joinerSize = measure('\n\n');
     const flushGroup = () => {
         if (currentGroup.length === 0)
             return;
@@ -180,26 +236,25 @@ export function chunkMarkdownStructural(input, opts) {
         const blockText = block.text.trim();
         if (!blockText)
             continue;
-        if (blockText.length > maxChunk) {
+        if (measure(blockText) > maxChunk) {
             flushGroup();
             const headingPath = headingStack.map(h => h.heading);
-            const subPieces = splitOversizedBlock(blockText, maxChunk, block.type);
-            let lineCursor = block.startLine;
-            for (let idx = 0; idx < subPieces.length; idx++) {
-                const piece = subPieces[idx];
-                const pieceLineCount = piece.split('\n').length;
+            // Issue #167: pieces carry the block-relative range of REAL source
+            // lines backing them — synthetic fence/header repeats must not advance
+            // the line cursor, or every later sub-chunk drifts down the file.
+            const subPieces = splitOversizedByMeasure(blockText, maxChunk, measure, block.type);
+            for (const piece of subPieces) {
                 chunks.push({
                     heading: headingPath.at(-1) ?? '',
                     headingPath: [...headingPath],
-                    text: piece,
-                    startLine: lineCursor,
-                    endLine: Math.min(block.endLine, lineCursor + pieceLineCount - 1),
+                    text: piece.text,
+                    startLine: block.startLine + piece.startLine,
+                    endLine: Math.min(block.endLine, block.startLine + piece.endLine),
                 });
-                lineCursor += pieceLineCount;
             }
             continue;
         }
-        const addedLen = currentLen === 0 ? blockText.length : currentLen + 2 + blockText.length;
+        const addedLen = currentLen === 0 ? measure(blockText) : currentLen + joinerSize + measure(blockText);
         if (addedLen > maxChunk && currentGroup.length > 0) {
             flushGroup();
         }
@@ -207,7 +262,7 @@ export function chunkMarkdownStructural(input, opts) {
             groupStartLine = block.startLine;
         }
         currentGroup.push(blockText);
-        currentLen += (currentGroup.length === 1 ? 0 : 2) + blockText.length;
+        currentLen += (currentGroup.length === 1 ? 0 : joinerSize) + measure(blockText);
         groupEndLine = block.endLine;
     }
     flushGroup();
@@ -228,9 +283,121 @@ function splitLongLine(line, maxChunk) {
     return pieces;
 }
 export function splitOversizedBlock(text, maxChunk, blockType) {
+    return splitOversizedBlockWithRanges(text, maxChunk, blockType).map((p) => p.text);
+}
+/**
+ * issue #202: oversized-block splitting under an arbitrary measure (chars or
+ * tokens). The heavy lifting (fence repeats, table header repeats, #167 line
+ * ranges) stays in the char-based splitOversizedBlockWithRanges; the token
+ * budget is converted to a char budget for THIS block via its own chars-per-
+ * measured-unit ratio, then every piece is verified — script-skew inside the
+ * block (ASCII header + Cyrillic body) is caught by a greedy re-split.
+ */
+export function splitOversizedByMeasure(text, budget, measure, blockType) {
+    if (measure(text) <= budget) {
+        return [{ text, startLine: 0, endLine: Number.MAX_SAFE_INTEGER }];
+    }
+    // char equivalent of the budget for this block's script mix; fall back to
+    // a plain char split with the raw budget when measuring is degenerate
+    const measured = Math.max(1, measure(text));
+    const charsPerUnit = text.length / measured;
+    const charBudget = Math.max(32, Math.floor(budget * charsPerUnit));
+    const pieces = splitOversizedBlockWithRanges(text, charBudget, blockType);
+    const out = [];
+    for (const piece of pieces) {
+        if (measure(piece.text) <= budget) {
+            out.push(piece);
+            continue;
+        }
+        // script-skew safety net: greedy line/word accumulation under measure;
+        // the greedy splitter tracks consumed source lines so #167 ranges stay real
+        const spanLines = piece.endLine - piece.startLine + 1;
+        const textLines = piece.text.split('\n');
+        // when synthetic lines (fence/table repeats) inflated the piece, the text
+        // has more lines than the source span — clamp keeps ranges inside the block
+        const lineStride = textLines.length > spanLines ? spanLines / textLines.length : 1;
+        for (const sub of greedySplitByMeasure(piece.text, budget, measure)) {
+            const startLine = piece.startLine + Math.min(spanLines - 1, Math.floor(sub.startLine * lineStride));
+            const endLine = piece.startLine + Math.min(spanLines - 1, Math.max(sub.startLine, Math.floor(sub.endLine * lineStride)));
+            out.push({ text: sub.text, startLine, endLine });
+        }
+    }
+    return out;
+}
+function greedySplitByMeasure(text, budget, measure) {
+    const out = [];
+    const lines = text.split('\n');
+    let bufStart = 0;
+    let bufEnd = 0;
+    let current = '';
+    const flush = (uptoLine) => {
+        if (current.trim())
+            out.push({ text: current.trim(), startLine: bufStart, endLine: uptoLine });
+        current = '';
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const candidate = current ? `${current}\n${line}` : line;
+        if (measure(candidate) <= budget) {
+            if (!current)
+                bufStart = i;
+            current = candidate;
+            bufEnd = i;
+            continue;
+        }
+        flush(i - 1);
+        if (measure(line) <= budget) {
+            bufStart = i;
+            current = line;
+            bufEnd = i;
+            continue;
+        }
+        // single line over budget: word-level accumulation, all pieces stay on
+        // this line's range
+        const words = line.split(/\s+/);
+        let wordBuf = '';
+        for (const word of words) {
+            const wc = wordBuf ? `${wordBuf} ${word}` : word;
+            if (measure(wc) <= budget) {
+                wordBuf = wc;
+                continue;
+            }
+            if (wordBuf.trim())
+                out.push({ text: wordBuf.trim(), startLine: i, endLine: i });
+            if (measure(word) <= budget) {
+                wordBuf = word;
+                continue;
+            }
+            // monster token (no spaces): hard-slice by chars proportional to budget
+            const ratio = line.length / Math.max(1, measure(line));
+            const sliceLen = Math.max(8, Math.floor(budget * ratio));
+            let rest = word;
+            while (measure(rest) > budget && rest.length > sliceLen) {
+                out.push({ text: rest.slice(0, sliceLen), startLine: i, endLine: i });
+                rest = rest.slice(sliceLen);
+            }
+            wordBuf = rest;
+        }
+        if (wordBuf.trim()) {
+            bufStart = i;
+            current = wordBuf;
+            bufEnd = i;
+        }
+    }
+    flush(bufEnd);
+    return out;
+}
+/**
+ * Issue #167: like splitOversizedBlock, but each piece also reports the
+ * block-relative range of source lines it was built from. Synthetic lines
+ * added to keep pieces self-contained (fence repeats, table header repeats)
+ * do NOT count — only the first piece's opening fence/header and a real
+ * closing fence belong to the source.
+ */
+export function splitOversizedBlockWithRanges(text, maxChunk, blockType) {
     const lines = text.split('\n');
     if (lines.length <= 1) {
-        return splitLongLine(text, maxChunk);
+        return splitLongLine(text, maxChunk).map((piece) => ({ text: piece, startLine: 0, endLine: 0 }));
     }
     // If code block with opening fence
     if (blockType === 'code' && lines.length > 2 && /^(\s*)(`{3,}|~{3,})/.test(lines[0])) {
@@ -241,17 +408,30 @@ export function splitOversizedBlock(text, maxChunk, blockType) {
         const pieces = [];
         let currentCode = [];
         let currentLen = openFence.length + closeFence.length + 2;
-        for (const line of innerLines) {
+        // The opening fence is a real source line only in the first piece; a
+        // real closing fence only in the final one.
+        const flush = (isFinal) => {
+            const firstReal = pieces.length === 0 ? 0 : currentCode[0].srcIdx;
+            const lastReal = isFinal && hasCloseFence ? lines.length - 1 : currentCode[currentCode.length - 1].srcIdx;
+            pieces.push({
+                text: [openFence, ...currentCode.map((c) => c.line), closeFence].join('\n'),
+                startLine: firstReal,
+                endLine: lastReal,
+            });
+        };
+        for (let offset = 0; offset < innerLines.length; offset++) {
+            const line = innerLines[offset];
+            const srcIdx = 1 + offset;
             if (currentLen + line.length + 1 > maxChunk && currentCode.length > 0) {
-                pieces.push([openFence, ...currentCode, closeFence].join('\n'));
+                flush(false);
                 currentCode = [];
                 currentLen = openFence.length + closeFence.length + 2;
             }
-            currentCode.push(line);
+            currentCode.push({ line, srcIdx });
             currentLen += line.length + 1;
         }
         if (currentCode.length > 0) {
-            pieces.push([openFence, ...currentCode, closeFence].join('\n'));
+            flush(true);
         }
         if (pieces.length > 0)
             return pieces;
@@ -264,17 +444,27 @@ export function splitOversizedBlock(text, maxChunk, blockType) {
         const pieces = [];
         let currentRows = [];
         let currentLen = headerLen;
-        for (const row of dataRows) {
+        const flush = () => {
+            const firstReal = pieces.length === 0 ? 0 : currentRows[0].srcIdx;
+            pieces.push({
+                text: [...headerRows, ...currentRows.map((r) => r.row)].join('\n'),
+                startLine: firstReal,
+                endLine: currentRows[currentRows.length - 1].srcIdx,
+            });
+        };
+        for (let offset = 0; offset < dataRows.length; offset++) {
+            const row = dataRows[offset];
+            const srcIdx = 2 + offset;
             if (currentLen + row.length + 1 > maxChunk && currentRows.length > 0) {
-                pieces.push([...headerRows, ...currentRows].join('\n'));
+                flush();
                 currentRows = [];
                 currentLen = headerLen;
             }
-            currentRows.push(row);
+            currentRows.push({ row, srcIdx });
             currentLen += row.length + 1;
         }
         if (currentRows.length > 0) {
-            pieces.push([...headerRows, ...currentRows].join('\n'));
+            flush();
         }
         if (pieces.length > 0)
             return pieces;
@@ -283,29 +473,36 @@ export function splitOversizedBlock(text, maxChunk, blockType) {
     const pieces = [];
     let currentLines = [];
     let currentLen = 0;
-    for (const line of lines) {
+    const flush = () => {
+        pieces.push({
+            text: currentLines.map((l) => l.line).join('\n').trim(),
+            startLine: currentLines[0].srcIdx,
+            endLine: currentLines[currentLines.length - 1].srcIdx,
+        });
+    };
+    for (let srcIdx = 0; srcIdx < lines.length; srcIdx++) {
+        const line = lines[srcIdx];
         if (currentLen + line.length + 1 > maxChunk && currentLines.length > 0) {
-            pieces.push(currentLines.join('\n').trim());
+            flush();
             currentLines = [];
             currentLen = 0;
         }
         if (line.length > maxChunk) {
             if (currentLines.length > 0) {
-                pieces.push(currentLines.join('\n').trim());
+                flush();
                 currentLines = [];
             }
-            const splitLines = splitLongLine(line, maxChunk);
-            for (const piece of splitLines) {
-                pieces.push(piece);
+            for (const piece of splitLongLine(line, maxChunk)) {
+                pieces.push({ text: piece, startLine: srcIdx, endLine: srcIdx });
             }
             currentLen = 0;
             continue;
         }
-        currentLines.push(line);
+        currentLines.push({ line, srcIdx });
         currentLen += line.length + 1;
     }
     if (currentLines.length > 0) {
-        pieces.push(currentLines.join('\n').trim());
+        flush();
     }
     return pieces;
 }

package/dist/mcp.d.ts

@@ -4,9 +4,71 @@
  * via a zero-dependency JSON-RPC 2.0 stdio transport per the MCP specification.
  */
 import readline from 'node:readline';
+/**
+ * Protocol versions this server can speak (issue #197), newest first.
+ * `initialize` echoes the client's requested version when we support it,
+ * otherwise answers with MCP_SUPPORTED_VERSIONS[0].
+ */
+export declare const MCP_SUPPORTED_VERSIONS: string[];
+/**
+ * Resolves the protocol version to answer an `initialize` with: the client's
+ * exact request when supported, else the newest version we speak (the spec's
+ * "respond with another protocol version you support" branch).
+ */
+export declare function negotiateProtocolVersion(requested?: unknown): string;
+export interface McpClientChannelRequestOptions {
+    timeoutMs?: number;
+}
+/**
+ * Reverse channel for server→client JSON-RPC requests (issue #197) — today
+ * only `sampling/createMessage`. Both transports build one: stdio writes
+ * requests to its stdout and matches response lines by id; HTTP pushes them
+ * onto the GET /mcp SSE stream and matches POSTed responses by id.
+ */
+export interface McpClientChannel {
+    request(method: string, params?: any, opts?: McpClientChannelRequestOptions): Promise<any>;
+    /**
+     * Feeds a client message in. Returns true when it resolved a pending
+     * request; false means the message is a client request/notification and
+     * belongs to the normal handler.
+     */
+    handleResponse(msg: any): boolean;
+}
+/** Server→client requests that outlive this wait degrade, not hang (issue #197). */
+export declare const DEFAULT_SAMPLING_TIMEOUT_MS = 60000;
+/** `sampling/createMessage` requires maxTokens — a grounded citation answer fits comfortably. */
+export declare const DEFAULT_SAMPLING_MAX_TOKENS = 1024;
+export declare function samplingTimeoutMs(envValue?: string): number;
+/**
+ * Builds a client channel over a raw sink. Ids are prefixed `mdss-srv-` so
+ * they can never collide with the client's own request ids in either
+ * direction's logs or pending maps.
+ */
+export declare function createClientChannel(send: (msg: any) => void): McpClientChannel;
+/**
+ * A sampling-backed synthesis hook for the RAG layer (issue #197): returns
+ * null unless the client both declared the `sampling` capability at
+ * initialize AND a reverse channel exists — otherwise ask_knowledge_base goes
+ * straight to the local extractive answer. Any in-flight failure (client
+ * refusal, timeout, non-text content) throws and degrades the same way.
+ */
+export declare function createSamplingSynthesizer(state: {
+    channel?: McpClientChannel;
+    clientCapabilities?: any;
+}): {
+    fn: (req: {
+        system: string;
+        user: string;
+    }) => Promise<string>;
+    used: () => boolean;
+} | null;
 export declare const MCP_TOOLS: ({
     name: string;
     description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
     inputSchema: {
         type: string;
         properties: {
@@ -44,14 +106,23 @@ export declare const MCP_TOOLS: ({
                 type: string;
                 description: string;
             };
-            file?: undefined;
             heading?: undefined;
+            fromLine?: undefined;
+            maxLines?: undefined;
+            file?: undefined;
+            direction?: undefined;
+            semantic?: undefined;
+            sessionId?: undefined;
         };
         required: string[];
     };
 } | {
     name: string;
     description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
     inputSchema: {
         type: string;
         properties: {
@@ -67,15 +138,100 @@ export declare const MCP_TOOLS: ({
                 type: string;
                 description: string;
             };
+            fromLine?: undefined;
+            maxLines?: undefined;
+            direction?: undefined;
+            semantic?: undefined;
             path?: undefined;
             query?: undefined;
             k?: undefined;
+            sessionId?: undefined;
         };
         required: string[];
     };
 } | {
     name: string;
     description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            vaults?: undefined;
+            tag?: undefined;
+            filter?: undefined;
+            graphBoost?: undefined;
+            heading?: undefined;
+            file: {
+                type: string;
+                description: string;
+            };
+            fromLine: {
+                type: string;
+                description: string;
+            };
+            maxLines: {
+                type: string;
+                description: string;
+            };
+            direction?: undefined;
+            semantic?: undefined;
+            path?: undefined;
+            query?: undefined;
+            k?: undefined;
+            sessionId?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            vaults?: undefined;
+            tag?: undefined;
+            filter?: undefined;
+            graphBoost?: undefined;
+            heading?: undefined;
+            fromLine?: undefined;
+            maxLines?: undefined;
+            file: {
+                type: string;
+                description: string;
+            };
+            k: {
+                type: string;
+                description: string;
+            };
+            direction: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            semantic: {
+                type: string;
+                description: string;
+            };
+            path?: undefined;
+            query?: undefined;
+            sessionId?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
     inputSchema: {
         type: string;
         properties: {
@@ -83,20 +239,29 @@ export declare const MCP_TOOLS: ({
             tag?: undefined;
             filter?: undefined;
             graphBoost?: undefined;
-            file?: undefined;
             heading?: undefined;
+            fromLine?: undefined;
+            maxLines?: undefined;
+            file?: undefined;
+            direction?: undefined;
+            semantic?: undefined;
             path: {
                 type: string;
                 description: string;
             };
             query?: undefined;
             k?: undefined;
+            sessionId?: undefined;
         };
         required?: undefined;
     };
 } | {
     name: string;
     description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
     inputSchema: {
         type: string;
         properties: {
@@ -104,17 +269,26 @@ export declare const MCP_TOOLS: ({
             tag?: undefined;
             filter?: undefined;
             graphBoost?: undefined;
-            file?: undefined;
             heading?: undefined;
+            fromLine?: undefined;
+            maxLines?: undefined;
+            file?: undefined;
+            direction?: undefined;
+            semantic?: undefined;
             path?: undefined;
             query?: undefined;
             k?: undefined;
+            sessionId?: undefined;
         };
         required?: undefined;
     };
 } | {
     name: string;
     description: string;
+    annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
     inputSchema: {
         type: string;
         properties: {
@@ -122,8 +296,12 @@ export declare const MCP_TOOLS: ({
             tag?: undefined;
             filter?: undefined;
             graphBoost?: undefined;
-            file?: undefined;
             heading?: undefined;
+            fromLine?: undefined;
+            maxLines?: undefined;
+            file?: undefined;
+            direction?: undefined;
+            semantic?: undefined;
             path?: undefined;
             query: {
                 type: string;
@@ -133,16 +311,46 @@ export declare const MCP_TOOLS: ({
                 type: string;
                 description: string;
             };
+            sessionId: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };
 })[];
-export declare function handleMcpRequest(req: any, state: {
+export declare const MCP_RESOURCE_TEMPLATES: {
+    uriTemplate: string;
+    name: string;
+    description: string;
+    mimeType: string;
+}[];
+export declare const MCP_PROMPTS: {
+    name: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+}[];
+/**
+ * Shared state for both MCP transports (stdio + Streamable HTTP): the
+ * transports own the extras — `channel` (server→client requests, issue #197),
+ * `clientCapabilities` (recorded at initialize), `output` (stdio sink, test seam).
+ */
+export interface McpHandlerState {
     loaded: any;
     cacheDir: string;
     offline: boolean;
     embedFn?: any;
-}): Promise<any | null>;
+    channel?: McpClientChannel;
+    clientCapabilities?: any;
+    output?: {
+        write(chunk: string): void;
+    };
+}
+export declare function handleMcpRequest(req: any, state: McpHandlerState): Promise<any | null>;
 export interface StartMcpServerOptions {
     indexDir: string;
     cacheDir: string;
@@ -151,9 +359,23 @@ export interface StartMcpServerOptions {
     ignore?: string[];
     offline?: boolean;
     embedFn?: any;
+    /** Stdio source (default process.stdin) — test/embedding seam (issue #197). */
+    input?: NodeJS.ReadableStream;
+    /** Stdio sink (default process.stdout) — test/embedding seam (issue #197). */
+    output?: {
+        write(chunk: string): void;
+    };
     log?: (msg: string) => void;
 }
 export declare function startMcpServer(opts: StartMcpServerOptions): Promise<{
-    state: any;
+    state: McpHandlerState;
     rl: readline.Interface;
 }>;
+/**
+ * One guarded, in-order stdio JSON-RPC exchange (issues #180/#185): caps the
+ * line length, turns JSON parse failures into `-32700`, and converts ANY
+ * handler escape into a `-32603` response instead of an unhandled rejection
+ * that would kill the daemon.
+ */
+export declare const MAX_STDIO_LINE_CHARS: number;
+export declare function handleStdioLine(line: string, state: McpHandlerState): Promise<void>;