@basein/runner 0.1.0

package/dist/control/transcript.d.ts

@@ -0,0 +1,75 @@
+/**
+ * transcript — recover the model's reasoning for a tool call (Tier 1 only).
+ *
+ * Ported in miniature from RRepeat's `server/transcript.ts`. Claude Code writes
+ * each session to a JSONL file named by `transcript_path` on every hook payload:
+ *
+ *   { "type": "assistant", "message": { "role": "assistant", "content": [
+ *       { "type": "text", "text": "..." },
+ *       { "type": "tool_use", "id": "toolu_…", "name": "Bash", "input": {…} } ] } }
+ *
+ * `PreToolUse` gives the tool but **not** the reasoning that preceded it, and
+ * §7's recorded step carries that reasoning as a `tool_selected` step's
+ * `context`. So it is recovered here by finding the assistant message that
+ * emitted a given `tool_use_id` and returning its text blocks.
+ *
+ * The schema drifts between Claude Code versions, so every accessor is
+ * defensive: an unknown shape yields `""` rather than throwing. Nothing here is
+ * ever required for a recording to be valid — a missing context is a missing
+ * nicety, not a failed step.
+ */
+/** The assistant text that accompanied `toolUseId`, or "" when unavailable. */
+export declare function contextForToolUse(transcriptPath: string | undefined, toolUseId: string): string;
+/** The last assistant text in the transcript — the turn's final answer. */
+export declare function lastAssistantText(transcriptPath: string | undefined): string;
+/**
+ * The turn's final answer, waiting briefly for the transcript to catch up.
+ *
+ * WHY THE WAIT EXISTS. `Stop` fires the moment the assistant finishes its turn,
+ * which is *before* Claude Code has flushed that turn's last message to the
+ * JSONL file. Reading the transcript at that instant returns the previous
+ * assistant text — usually the empty one that carried the tool call — so the run
+ * gets finished with no answer at all. Observed, not theorised.
+ *
+ * The condition is "changed from what we already had", not "non-empty", because
+ * an intermediate assistant message may be non-empty and still not be the answer.
+ * On timeout it returns the best text available rather than nothing: a late or
+ * imperfect answer beats an empty one.
+ */
+export declare function settledLastAssistantText(transcriptPath: string | undefined, opts?: {
+    timeoutMs?: number;
+    confirmMs?: number;
+    pollMs?: number;
+}): Promise<string>;
+/**
+ * Per-model token usage, as it appears on one assistant message.
+ */
+export interface ModelUsage {
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+}
+/** Cumulative per-model totals, captured when a run starts. */
+export type UsageMark = Map<string, ModelUsage>;
+/**
+ * Snapshot cumulative usage at the moment a run starts.
+ *
+ * WHY A WATERMARK AND NOT A LINE INDEX. Claude Code writes one transcript per
+ * *session*, and this server rolls a new run on every prompt. Summing the whole
+ * file gives run 3 the cost of runs 1+2+3 — and every one of those numbers is a
+ * **baseline** on the service, so a three-prompt session would hand the savings
+ * ledger a baseline roughly three times the truth. Indexing by line does not fix
+ * it either: transcripts are appended concurrently and can be compacted. So
+ * snapshot the totals and subtract.
+ */
+export declare function markTranscriptUsage(transcriptPath: string | undefined): UsageMark | undefined;
+/**
+ * Per-model delta since `mark`, **clamped at 0 per field**, so a compaction or a
+ * rotated transcript degrades to "no usage" rather than to a negative cost.
+ */
+export declare function usageSince(transcriptPath: string | undefined, mark: UsageMark | undefined): ModelUsage[];
+/** The first user prompt in the transcript — the run's `input` when a hook omits it. */
+export declare function firstUserPrompt(transcriptPath: string | undefined): string;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/control/transcript.js

@@ -0,0 +1,241 @@
+/**
+ * transcript — recover the model's reasoning for a tool call (Tier 1 only).
+ *
+ * Ported in miniature from RRepeat's `server/transcript.ts`. Claude Code writes
+ * each session to a JSONL file named by `transcript_path` on every hook payload:
+ *
+ *   { "type": "assistant", "message": { "role": "assistant", "content": [
+ *       { "type": "text", "text": "..." },
+ *       { "type": "tool_use", "id": "toolu_…", "name": "Bash", "input": {…} } ] } }
+ *
+ * `PreToolUse` gives the tool but **not** the reasoning that preceded it, and
+ * §7's recorded step carries that reasoning as a `tool_selected` step's
+ * `context`. So it is recovered here by finding the assistant message that
+ * emitted a given `tool_use_id` and returning its text blocks.
+ *
+ * The schema drifts between Claude Code versions, so every accessor is
+ * defensive: an unknown shape yields `""` rather than throwing. Nothing here is
+ * ever required for a recording to be valid — a missing context is a missing
+ * nicety, not a failed step.
+ */
+import { readFileSync } from "node:fs";
+function readLines(transcriptPath) {
+    let raw;
+    try {
+        raw = readFileSync(transcriptPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            out.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Transcripts are appended concurrently; a half-written line is normal.
+        }
+    }
+    return out;
+}
+function blocksOf(line) {
+    const content = line.message?.content ?? line.content;
+    if (Array.isArray(content))
+        return content;
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return [];
+}
+function textOf(blocks) {
+    return blocks
+        .filter((b) => b.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("\n")
+        .trim();
+}
+/** The assistant text that accompanied `toolUseId`, or "" when unavailable. */
+export function contextForToolUse(transcriptPath, toolUseId) {
+    if (!transcriptPath || !toolUseId)
+        return "";
+    for (const line of readLines(transcriptPath)) {
+        const blocks = blocksOf(line);
+        if (blocks.some((b) => b.type === "tool_use" && b.id === toolUseId)) {
+            return textOf(blocks);
+        }
+    }
+    return "";
+}
+/** The last assistant text in the transcript — the turn's final answer. */
+export function lastAssistantText(transcriptPath) {
+    if (!transcriptPath)
+        return "";
+    const lines = readLines(transcriptPath);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i];
+        const role = line.message?.role ?? line.type;
+        if (role !== "assistant")
+            continue;
+        const text = textOf(blocksOf(line));
+        if (text)
+            return text;
+    }
+    return "";
+}
+/**
+ * The turn's final answer, waiting briefly for the transcript to catch up.
+ *
+ * WHY THE WAIT EXISTS. `Stop` fires the moment the assistant finishes its turn,
+ * which is *before* Claude Code has flushed that turn's last message to the
+ * JSONL file. Reading the transcript at that instant returns the previous
+ * assistant text — usually the empty one that carried the tool call — so the run
+ * gets finished with no answer at all. Observed, not theorised.
+ *
+ * The condition is "changed from what we already had", not "non-empty", because
+ * an intermediate assistant message may be non-empty and still not be the answer.
+ * On timeout it returns the best text available rather than nothing: a late or
+ * imperfect answer beats an empty one.
+ */
+export async function settledLastAssistantText(transcriptPath, opts = {}) {
+    if (!transcriptPath)
+        return "";
+    const pollMs = opts.pollMs ?? 150;
+    const before = lastAssistantText(transcriptPath);
+    // Waiting is only expensive when there is nothing to wait for. With text
+    // already in hand we only confirm that nothing more is coming; with none, the
+    // answer is genuinely still being written and is worth the longer window.
+    const timeoutMs = before ? (opts.confirmMs ?? 400) : (opts.timeoutMs ?? 2_000);
+    const deadline = Date.now() + timeoutMs;
+    let latest = before;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => {
+            const t = setTimeout(resolve, pollMs);
+            t.unref?.();
+        });
+        latest = lastAssistantText(transcriptPath);
+        if (latest && latest !== before)
+            return latest;
+    }
+    return latest || before;
+}
+const zeroUsage = (model) => ({
+    model,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+});
+/**
+ * Sum every assistant message's `usage` in the whole file, keyed by model.
+ *
+ * DEDUPLICATED BY `message.id`, and that is not an optimisation — it is the
+ * difference between a cost and a multiple of it.
+ *
+ * Claude Code writes **one transcript line per content block**, and every one of
+ * those lines repeats the `usage` of the whole message. An assistant turn that
+ * emits five tool calls therefore appears five times, each claiming the full
+ * turn's tokens. Summing lines inflates the total by the block count — a factor
+ * that varies per turn, so it does not even cancel out between two runs being
+ * compared.
+ *
+ * Measured on a real session: 37 lines carrying usage, 14 distinct messages,
+ * total overstated 2.6x. That inflation is what made every replay look more
+ * expensive than the run it replaced.
+ *
+ * A line with no `message.id` is counted once on its own (older transcripts, and
+ * anything hand-written in a test).
+ */
+function totalUsage(transcriptPath) {
+    const totals = new Map();
+    const seen = new Set();
+    for (const line of readLines(transcriptPath)) {
+        const usage = line.message?.usage;
+        if (!usage)
+            continue;
+        const id = line.message?.id;
+        if (id) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+        }
+        const model = line.message?.model ?? "unknown";
+        const acc = totals.get(model) ?? zeroUsage(model);
+        acc.inputTokens += usage.input_tokens ?? 0;
+        acc.outputTokens += usage.output_tokens ?? 0;
+        acc.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
+        acc.cacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+        totals.set(model, acc);
+    }
+    return totals;
+}
+/**
+ * Snapshot cumulative usage at the moment a run starts.
+ *
+ * WHY A WATERMARK AND NOT A LINE INDEX. Claude Code writes one transcript per
+ * *session*, and this server rolls a new run on every prompt. Summing the whole
+ * file gives run 3 the cost of runs 1+2+3 — and every one of those numbers is a
+ * **baseline** on the service, so a three-prompt session would hand the savings
+ * ledger a baseline roughly three times the truth. Indexing by line does not fix
+ * it either: transcripts are appended concurrently and can be compacted. So
+ * snapshot the totals and subtract.
+ */
+export function markTranscriptUsage(transcriptPath) {
+    // `undefined`, NOT an empty map. The two look alike and mean opposite things:
+    // an empty map is a real mark on a transcript with no usage yet (subtract
+    // nothing — correct), while a missing path means we could not take a mark at
+    // all, so `usageSince` would return the WHOLE FILE.
+    //
+    // That distinction is the difference between reporting this turn's cost and
+    // reporting the entire session's, and an empty Map is truthy — so a caller
+    // doing `Boolean(mark)` would call the second one "measured" and hand the
+    // savings ledger a baseline several times too large. Observed, not theorised:
+    // a run opened lazily by a proxy step (which carries no transcript path)
+    // reported $0.507 for a turn that cost $0.0009.
+    if (!transcriptPath)
+        return undefined;
+    return totalUsage(transcriptPath);
+}
+/**
+ * Per-model delta since `mark`, **clamped at 0 per field**, so a compaction or a
+ * rotated transcript degrades to "no usage" rather than to a negative cost.
+ */
+export function usageSince(transcriptPath, mark) {
+    if (!transcriptPath)
+        return [];
+    const now = totalUsage(transcriptPath);
+    const out = [];
+    for (const [model, current] of now) {
+        const before = mark?.get(model);
+        const delta = {
+            model,
+            inputTokens: Math.max(0, current.inputTokens - (before?.inputTokens ?? 0)),
+            outputTokens: Math.max(0, current.outputTokens - (before?.outputTokens ?? 0)),
+            cacheReadTokens: Math.max(0, current.cacheReadTokens - (before?.cacheReadTokens ?? 0)),
+            cacheCreationTokens: Math.max(0, current.cacheCreationTokens - (before?.cacheCreationTokens ?? 0)),
+        };
+        if (delta.inputTokens ||
+            delta.outputTokens ||
+            delta.cacheReadTokens ||
+            delta.cacheCreationTokens) {
+            out.push(delta);
+        }
+    }
+    return out;
+}
+/** The first user prompt in the transcript — the run's `input` when a hook omits it. */
+export function firstUserPrompt(transcriptPath) {
+    if (!transcriptPath)
+        return "";
+    for (const line of readLines(transcriptPath)) {
+        const role = line.message?.role ?? line.type;
+        if (role !== "user")
+            continue;
+        const text = textOf(blocksOf(line));
+        if (text)
+            return text;
+    }
+    return "";
+}
+//# sourceMappingURL=transcript.js.map

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * BaseInstRunnerMCP — public surface.
+ *
+ * The product is three binaries (`bir`, `bir-proxy`, `bir-hooks`); this module
+ * exists so the pieces can be embedded — an Agent SDK harness that wants to host
+ * its own control server, or a test that drives the relay directly.
+ */
+export * from "./jsonrpc/types.js";
+export { readFrames, writeFrame, DEFAULT_MAX_LINE_BYTES } from "./jsonrpc/framing.js";
+export type { UpstreamClient, UpstreamCloseInfo } from "./upstream/client.js";
+export { BaseUpstreamClient, BIR_ID_PREFIX } from "./upstream/client.js";
+export { StdioUpstreamClient, resolveCommand, whichSync } from "./upstream/stdio-client.js";
+export { HttpUpstreamClient } from "./upstream/http-client.js";
+export { LazyUpstreamClient } from "./upstream/lazy-client.js";
+export { Relay } from "./proxy/relay.js";
+export type { Interceptor, PendingRequest, HostDecision, RelayOptions } from "./proxy/relay.js";
+export { RecordingInterceptor } from "./proxy/intercept.js";
+export { ProxySession, DISCOVERY_WINDOW_MS } from "./proxy/session.js";
+export type { Tier } from "./proxy/session.js";
+export { ControlServer } from "./control/server.js";
+export type { ControlServerOptions, ControlServerAddress, HookPayload } from "./control/server.js";
+export { ControlClient } from "./control/client.js";
+export * from "./control/correlation.js";
+export { StepIndexAllocator } from "./control/ordering.js";
+export * from "./control/discovery.js";
+export * from "./control/paths.js";
+export * from "./record/recorder.js";
+export { RemoteRecorder } from "./record/remote-recorder.js";
+export { redact, redactText, REDACTED } from "./record/redact.js";
+export { serializeCapped, truncateString, truncateStrings, DEFAULT_MAX_PAYLOAD_BYTES, } from "./record/truncate.js";
+export { StepQueue } from "./record/queue.js";
+export * from "./config/resolve.js";
+export * from "./config/generate.js";
+export { authenticate, loadCredentials, saveCredentials, clearCredentials } from "./auth/client.js";
+export type { AuthSession, AuthUser } from "./auth/client.js";
+export { logLine, logDetail } from "./util/log.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,32 @@
+/**
+ * BaseInstRunnerMCP — public surface.
+ *
+ * The product is three binaries (`bir`, `bir-proxy`, `bir-hooks`); this module
+ * exists so the pieces can be embedded — an Agent SDK harness that wants to host
+ * its own control server, or a test that drives the relay directly.
+ */
+export * from "./jsonrpc/types.js";
+export { readFrames, writeFrame, DEFAULT_MAX_LINE_BYTES } from "./jsonrpc/framing.js";
+export { BaseUpstreamClient, BIR_ID_PREFIX } from "./upstream/client.js";
+export { StdioUpstreamClient, resolveCommand, whichSync } from "./upstream/stdio-client.js";
+export { HttpUpstreamClient } from "./upstream/http-client.js";
+export { LazyUpstreamClient } from "./upstream/lazy-client.js";
+export { Relay } from "./proxy/relay.js";
+export { RecordingInterceptor } from "./proxy/intercept.js";
+export { ProxySession, DISCOVERY_WINDOW_MS } from "./proxy/session.js";
+export { ControlServer } from "./control/server.js";
+export { ControlClient } from "./control/client.js";
+export * from "./control/correlation.js";
+export { StepIndexAllocator } from "./control/ordering.js";
+export * from "./control/discovery.js";
+export * from "./control/paths.js";
+export * from "./record/recorder.js";
+export { RemoteRecorder } from "./record/remote-recorder.js";
+export { redact, redactText, REDACTED } from "./record/redact.js";
+export { serializeCapped, truncateString, truncateStrings, DEFAULT_MAX_PAYLOAD_BYTES, } from "./record/truncate.js";
+export { StepQueue } from "./record/queue.js";
+export * from "./config/resolve.js";
+export * from "./config/generate.js";
+export { authenticate, loadCredentials, saveCredentials, clearCredentials } from "./auth/client.js";
+export { logLine, logDetail } from "./util/log.js";
+//# sourceMappingURL=index.js.map

package/dist/jsonrpc/framing.d.ts

@@ -0,0 +1,49 @@
+/**
+ * framing — line-delimited JSON-RPC over a byte stream (Phase 1.1).
+ *
+ * MCP's stdio transport is one JSON value per line. Three things break naive
+ * implementations, and all three are handled here:
+ *
+ *   1. **Partial reads.** A chunk boundary lands mid-message. Bytes are buffered
+ *      until a newline arrives.
+ *   2. **Oversized lines.** A runaway upstream can otherwise grow the buffer
+ *      without bound. Past `maxLineBytes` the reader drops bytes until the next
+ *      newline and reports one error, rather than allocating until the process
+ *      dies.
+ *   3. **Invalid JSON.** Reported to the caller (which answers `-32700` toward a
+ *      host, or logs and drops toward an upstream). It never throws.
+ *
+ * Buffering is done on `Buffer`, not on a decoded string: a multi-byte UTF-8
+ * character split across two chunks decodes to replacement characters if you
+ * concatenate strings, which silently corrupts payloads containing non-ASCII.
+ */
+import type { Readable, Writable } from "node:stream";
+import type { JsonRpcMessage } from "./types.js";
+/** 32 MiB. Large enough for a base64 screenshot, small enough to be a bound. */
+export declare const DEFAULT_MAX_LINE_BYTES: number;
+export interface FrameHandlers {
+    onMessage: (msg: JsonRpcMessage) => void;
+    /** A line that was not valid JSON, or that exceeded `maxLineBytes`. */
+    onParseError?: (detail: {
+        reason: string;
+        bytes: number;
+        sample: string;
+    }) => void;
+    /** The input stream ended or errored. Called at most once. */
+    onEnd?: (err?: Error) => void;
+}
+export interface FrameOptions {
+    maxLineBytes?: number;
+}
+/**
+ * Read newline-delimited JSON messages off `input`.
+ * Returns a detach function that stops the reader (it does not close `input`).
+ */
+export declare function readFrames(input: Readable, handlers: FrameHandlers, opts?: FrameOptions): () => void;
+/**
+ * Write one message as a single line. Serialization failure is swallowed after
+ * being reported: a proxy that throws while answering the host takes the host's
+ * session down with it, which rule 4 of §1 forbids.
+ */
+export declare function writeFrame(output: Writable, msg: unknown, onError?: (err: Error) => void): void;
+//# sourceMappingURL=framing.d.ts.map

package/dist/jsonrpc/framing.js

@@ -0,0 +1,143 @@
+/**
+ * framing — line-delimited JSON-RPC over a byte stream (Phase 1.1).
+ *
+ * MCP's stdio transport is one JSON value per line. Three things break naive
+ * implementations, and all three are handled here:
+ *
+ *   1. **Partial reads.** A chunk boundary lands mid-message. Bytes are buffered
+ *      until a newline arrives.
+ *   2. **Oversized lines.** A runaway upstream can otherwise grow the buffer
+ *      without bound. Past `maxLineBytes` the reader drops bytes until the next
+ *      newline and reports one error, rather than allocating until the process
+ *      dies.
+ *   3. **Invalid JSON.** Reported to the caller (which answers `-32700` toward a
+ *      host, or logs and drops toward an upstream). It never throws.
+ *
+ * Buffering is done on `Buffer`, not on a decoded string: a multi-byte UTF-8
+ * character split across two chunks decodes to replacement characters if you
+ * concatenate strings, which silently corrupts payloads containing non-ASCII.
+ */
+/** 32 MiB. Large enough for a base64 screenshot, small enough to be a bound. */
+export const DEFAULT_MAX_LINE_BYTES = 32 * 1024 * 1024;
+const NEWLINE = 0x0a;
+/**
+ * Read newline-delimited JSON messages off `input`.
+ * Returns a detach function that stops the reader (it does not close `input`).
+ */
+export function readFrames(input, handlers, opts = {}) {
+    const maxLineBytes = opts.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
+    let buf = Buffer.alloc(0);
+    /** Set after an oversized line: drop bytes until the next newline resynchronises us. */
+    let discarding = false;
+    let discarded = 0;
+    let ended = false;
+    const finish = (err) => {
+        if (ended)
+            return;
+        ended = true;
+        handlers.onEnd?.(err);
+    };
+    const onData = (chunk) => {
+        buf = Buffer.concat([buf, typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk]);
+        for (;;) {
+            const nl = buf.indexOf(NEWLINE);
+            if (nl === -1) {
+                if (discarding) {
+                    discarded += buf.length;
+                    buf = Buffer.alloc(0);
+                }
+                else if (buf.length > maxLineBytes) {
+                    // Enter discard mode; report once for the whole oversized line.
+                    handlers.onParseError?.({
+                        reason: `line exceeded ${maxLineBytes} bytes`,
+                        bytes: buf.length,
+                        sample: buf.subarray(0, 120).toString("utf8"),
+                    });
+                    discarding = true;
+                    discarded = buf.length;
+                    buf = Buffer.alloc(0);
+                }
+                return;
+            }
+            const line = buf.subarray(0, nl);
+            buf = buf.subarray(nl + 1);
+            if (discarding) {
+                // The tail of an oversized line. Resynchronised — resume normal reading.
+                discarded += line.length;
+                discarding = false;
+                discarded = 0;
+                continue;
+            }
+            if (line.length === 0)
+                continue; // keep-alive blank lines are legal noise
+            if (line.length > maxLineBytes) {
+                handlers.onParseError?.({
+                    reason: `line exceeded ${maxLineBytes} bytes`,
+                    bytes: line.length,
+                    sample: line.subarray(0, 120).toString("utf8"),
+                });
+                continue;
+            }
+            const text = line.toString("utf8");
+            let msg;
+            try {
+                msg = JSON.parse(text);
+            }
+            catch (err) {
+                handlers.onParseError?.({
+                    reason: err instanceof Error ? err.message : String(err),
+                    bytes: line.length,
+                    sample: text.slice(0, 120),
+                });
+                continue;
+            }
+            if (!msg || typeof msg !== "object" || Array.isArray(msg)) {
+                // A bare scalar or a JSON-RPC batch. Neither appears in MCP; both would
+                // desynchronise a 1:1 relay, so they are reported rather than forwarded.
+                handlers.onParseError?.({
+                    reason: "message was not a JSON object",
+                    bytes: line.length,
+                    sample: text.slice(0, 120),
+                });
+                continue;
+            }
+            handlers.onMessage(msg);
+        }
+    };
+    const onError = (err) => finish(err);
+    const onEnd = () => finish();
+    input.on("data", onData);
+    input.on("error", onError);
+    input.on("end", onEnd);
+    input.on("close", onEnd);
+    return () => {
+        input.off("data", onData);
+        input.off("error", onError);
+        input.off("end", onEnd);
+        input.off("close", onEnd);
+    };
+}
+/**
+ * Write one message as a single line. Serialization failure is swallowed after
+ * being reported: a proxy that throws while answering the host takes the host's
+ * session down with it, which rule 4 of §1 forbids.
+ */
+export function writeFrame(output, msg, onError) {
+    let line;
+    try {
+        line = JSON.stringify(msg);
+    }
+    catch (err) {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+        return;
+    }
+    if (line === undefined)
+        return;
+    try {
+        output.write(line + "\n");
+    }
+    catch (err) {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+}
+//# sourceMappingURL=framing.js.map

package/dist/jsonrpc/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * JSON-RPC 2.0 message types, kept deliberately loose.
+ *
+ * D7 is full transparent passthrough: the relay forwards methods it has never
+ * heard of. So nothing here enumerates MCP methods, and `params` / `result` are
+ * `unknown` — a typed MCP SDK would fight the one property that makes the proxy
+ * work.
+ */
+export type JsonRpcId = string | number | null;
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+/** Standard JSON-RPC error codes, plus the one we use for transport failure. */
+export declare const JsonRpcErrorCode: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+    /** Implementation-defined server error — the upstream is gone. */
+    readonly UpstreamUnavailable: -32000;
+};
+/** A message with an `id` and a `method` — something that expects a response. */
+export declare function isRequest(msg: JsonRpcMessage): msg is JsonRpcRequest;
+/** A message with a `method` and no `id` — fire-and-forget. */
+export declare function isNotification(msg: JsonRpcMessage): msg is JsonRpcNotification;
+/** A message with an `id` and no `method` — an answer to somebody's request. */
+export declare function isResponse(msg: JsonRpcMessage): msg is JsonRpcResponse;
+export declare function errorResponse(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcResponse;
+/** `params` as an object, or `{}` — every caller wants this and none wants a throw. */
+export declare function paramsObject(params: unknown): Record<string, unknown>;
+//# sourceMappingURL=types.d.ts.map

package/dist/jsonrpc/types.js

@@ -0,0 +1,46 @@
+/**
+ * JSON-RPC 2.0 message types, kept deliberately loose.
+ *
+ * D7 is full transparent passthrough: the relay forwards methods it has never
+ * heard of. So nothing here enumerates MCP methods, and `params` / `result` are
+ * `unknown` — a typed MCP SDK would fight the one property that makes the proxy
+ * work.
+ */
+/** Standard JSON-RPC error codes, plus the one we use for transport failure. */
+export const JsonRpcErrorCode = {
+    ParseError: -32700,
+    InvalidRequest: -32600,
+    MethodNotFound: -32601,
+    InvalidParams: -32602,
+    InternalError: -32603,
+    /** Implementation-defined server error — the upstream is gone. */
+    UpstreamUnavailable: -32000,
+};
+/** A message with an `id` and a `method` — something that expects a response. */
+export function isRequest(msg) {
+    const m = msg;
+    return typeof m.method === "string" && m.id !== undefined && m.id !== null;
+}
+/** A message with a `method` and no `id` — fire-and-forget. */
+export function isNotification(msg) {
+    const m = msg;
+    return typeof m.method === "string" && (m.id === undefined || m.id === null);
+}
+/** A message with an `id` and no `method` — an answer to somebody's request. */
+export function isResponse(msg) {
+    const m = msg;
+    return m.method === undefined && m.id !== undefined;
+}
+export function errorResponse(id, code, message, data) {
+    const error = { code, message };
+    if (data !== undefined)
+        error.data = data;
+    return { jsonrpc: "2.0", id, error };
+}
+/** `params` as an object, or `{}` — every caller wants this and none wants a throw. */
+export function paramsObject(params) {
+    return params && typeof params === "object" && !Array.isArray(params)
+        ? params
+        : {};
+}
+//# sourceMappingURL=types.js.map