@skaile/transform-proxy 0.0.0-stage → 0.2.0

package/dist/config-DQPsbYLi.mjs

@@ -0,0 +1,1717 @@
+import { createRequire } from "node:module";
+import { timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parse } from "yaml";
+// src/log.ts
+/** Default logger: drops everything. Hosts pass their own `Logger`. */
+const silentLogger = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {}
+};
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+// src/chain.ts
+/**
+* Composes the stages of one pipeline into a single transform.
+* Outbound runs stage 1 to n, inbound and streamed inbound run stage n to 1.
+* The empty list is the identity.
+*/
+function composeTransforms(stages, log = silentLogger) {
+	const instructions = stages.flatMap((stage) => stage.instruction === void 0 ? [] : [stage.instruction]);
+	const reversed = [...stages].reverse();
+	return {
+		...instructions.length > 0 ? { instruction: instructions.join("\n\n") } : {},
+		async outbound(text, leaf) {
+			let out = text;
+			for (const stage of stages) out = await stage.outbound(out, leaf);
+			return out;
+		},
+		inbound(text) {
+			let out = text;
+			for (const stage of reversed) out = stage.inbound(out);
+			return out;
+		},
+		inboundStream() {
+			return composeStreams(stages.map((stage) => stage.inboundStream()));
+		},
+		async dispose() {
+			for (const stage of stages) try {
+				await stage.dispose?.();
+			} catch (err) {
+				log.error(`transform dispose failed: ${errorMessage(err)}`);
+			}
+		}
+	};
+}
+/**
+* Streams stage by stage. `streams` is in pipeline order (stage 1 first).
+* push feeds stage n first and passes each result down to stage 1.
+* flush goes n to 1: each stage's tail is pushed through the stages below it.
+*/
+function composeStreams(streams) {
+	const reversed = [...streams].reverse();
+	return {
+		push(chunk) {
+			let out = chunk;
+			for (const stream of reversed) out = stream.push(out);
+			return out;
+		},
+		flush() {
+			let carry = "";
+			for (const stream of reversed) carry = (carry === "" ? "" : stream.push(carry)) + stream.flush();
+			return carry;
+		}
+	};
+}
+// src/facts.ts
+function createSessionFacts() {
+	const bySource = /* @__PURE__ */ new Map();
+	let version = 0;
+	return {
+		facts: {
+			get version() {
+				return version;
+			},
+			list(kind) {
+				const all = [];
+				for (const facts of bySource.values()) for (const fact of facts) if (kind === void 0 || fact.kind === kind) all.push(fact);
+				return all;
+			}
+		},
+		publisher(source) {
+			return {
+				publish(facts) {
+					bySource.set(source, facts.map((fact) => ({
+						kind: fact.kind,
+						value: fact.value,
+						source
+					})));
+					version++;
+				},
+				clear() {
+					bySource.delete(source);
+					version++;
+				}
+			};
+		}
+	};
+}
+// src/modules.ts
+/** Loads and opens every configured transform once. Any failure rejects with the transform id. */
+async function openTransforms(specs, baseDir, log) {
+	const factories = /* @__PURE__ */ new Map();
+	for (const [id, spec] of Object.entries(specs)) {
+		const module = typeof spec.module === "string" ? await loadModule(id, spec.module, baseDir) : spec.module;
+		try {
+			factories.set(id, await module.open(spec.config, {
+				baseDir,
+				log
+			}));
+		} catch (err) {
+			throw new Error(`transform "${id}" failed to open: ${errorMessage(err)}`, { cause: err });
+		}
+	}
+	return factories;
+}
+async function loadModule(id, specifier, baseDir) {
+	let exported;
+	try {
+		exported = (await import(resolveSpecifier(specifier, baseDir))).default;
+	} catch (err) {
+		throw new Error(`transform "${id}": cannot load module ${specifier}: ${errorMessage(err)}`, { cause: err });
+	}
+	if (!isTransformModule(exported)) throw new Error(`transform "${id}": ${specifier} has no default TransformModule export`);
+	return exported;
+}
+/**
+* Resolves a module specifier to a file URL. Relative and absolute paths resolve against `baseDir`.
+* Package names resolve from `baseDir` by the `require` conditions first, then by the `import` condition.
+*/
+function resolveSpecifier(specifier, baseDir) {
+	const root = resolve(baseDir);
+	if (specifier.startsWith(".") || isAbsolute(specifier)) return pathToFileURL(resolve(root, specifier)).href;
+	try {
+		return pathToFileURL(createRequire(join(root, "noop.cjs")).resolve(specifier)).href;
+	} catch (err) {
+		const fallback = resolveImportCondition(specifier, root);
+		if (fallback === void 0) throw err;
+		return pathToFileURL(fallback).href;
+	}
+}
+/** Walks up node_modules from `root` and resolves a package entry through its `import` condition. */
+function resolveImportCondition(specifier, root) {
+	const parts = specifier.split("/");
+	const nameParts = specifier.startsWith("@") ? 2 : 1;
+	const name = parts.slice(0, nameParts).join("/");
+	const subpath = parts.length > nameParts ? `./${parts.slice(nameParts).join("/")}` : ".";
+	let dir = root;
+	for (;;) {
+		const pkgDir = join(dir, "node_modules", name);
+		const pkgJson = join(pkgDir, "package.json");
+		if (existsSync(pkgJson)) {
+			const pkg = JSON.parse(readFileSync(pkgJson, "utf8"));
+			const target = pkg.exports === void 0 ? subpath === "." ? pkg.main ?? "index.js" : void 0 : exportTarget(pkg.exports, subpath);
+			return target === void 0 ? void 0 : join(pkgDir, target);
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+function exportTarget(exports, subpath) {
+	return conditionTarget((isRecord$1(exports) && Object.keys(exports).some((key) => key.startsWith(".")) ? exports : { ".": exports })[subpath]);
+}
+function conditionTarget(entry) {
+	if (typeof entry === "string") return entry;
+	if (!isRecord$1(entry)) return void 0;
+	return conditionTarget(entry.import) ?? conditionTarget(entry.default);
+}
+function isTransformModule(value) {
+	return isRecord$1(value) && typeof value.id === "string" && typeof value.open === "function";
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// src/wire/json-args.ts
+const SIMPLE_ESCAPES = {
+	"\"": "\"",
+	"\\": "\\",
+	"/": "/",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+/** The body of a JSON string for `text`, without the surrounding quotes. */
+function escapeJsonBody(text) {
+	return JSON.stringify(text).slice(1, -1);
+}
+/**
+* Streaming restorer over raw JSON text. `openString` yields a fresh restorer for each string
+* value, so a placeholder never spans two values. Structural JSON outside strings passes through.
+*/
+function createJsonArgRestorer(openString) {
+	let current;
+	let escape = "none";
+	let hex = "";
+	return {
+		push(fragment) {
+			let out = "";
+			for (const ch of fragment) {
+				if (current === void 0) {
+					out += ch;
+					if (ch === "\"") current = openString();
+					continue;
+				}
+				const restorer = current;
+				if (escape === "unicode") {
+					hex += ch;
+					if (hex.length === 4) {
+						out += escapeJsonBody(restorer.push(String.fromCharCode(Number.parseInt(hex, 16))));
+						hex = "";
+						escape = "none";
+					}
+					continue;
+				}
+				if (escape === "backslash") {
+					escape = "none";
+					if (ch === "u") {
+						escape = "unicode";
+						continue;
+					}
+					out += escapeJsonBody(restorer.push(SIMPLE_ESCAPES[ch] ?? ch));
+					continue;
+				}
+				if (ch === "\\") {
+					escape = "backslash";
+					continue;
+				}
+				if (ch === "\"") {
+					out += escapeJsonBody(restorer.flush()) + "\"";
+					current = void 0;
+					continue;
+				}
+				out += escapeJsonBody(restorer.push(ch));
+			}
+			return out;
+		},
+		flush() {
+			if (current === void 0) return "";
+			const tail = escapeJsonBody(current.flush());
+			current = void 0;
+			escape = "none";
+			hex = "";
+			return tail;
+		}
+	};
+}
+// src/wire/sse.ts
+const DELIMITER = /\r?\n\r?\n/;
+function parseSseBlock(raw) {
+	let event;
+	const data = [];
+	for (const line of raw.split(/\r?\n/)) if (line.startsWith("event:")) event = line.slice(6).replace(/^ /, "");
+	else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
+	return {
+		event,
+		data: data.join("\n"),
+		raw
+	};
+}
+/** Serializes one rewritten event. `data` is JSON-encoded; the event name is kept when the source had one. */
+function formatSseEvent(event, data) {
+	return `${event === void 0 ? "" : `event: ${event}\n`}data: ${JSON.stringify(data)}\n\n`;
+}
+/**
+* Builds an SSE transformer. `handle` returns the output for one complete event (usually
+* `block.raw` or `formatSseEvent(...)`); `finish` returns output for state still open at end of stream.
+*/
+function createSseFramer(handle, finish = () => "") {
+	let buffer = "";
+	return {
+		push(chunk) {
+			buffer += chunk;
+			let out = "";
+			for (let match = DELIMITER.exec(buffer); match !== null; match = DELIMITER.exec(buffer)) {
+				const end = match.index + match[0].length;
+				const raw = buffer.slice(0, end);
+				buffer = buffer.slice(end);
+				out += handle(parseSseBlock(raw));
+			}
+			return out;
+		},
+		flush() {
+			const rest = buffer;
+			buffer = "";
+			return (rest === "" ? "" : handle(parseSseBlock(rest + "\n\n"))) + finish();
+		}
+	};
+}
+// src/wire/types.ts
+/** Thrown by `request` for attachments (image, document, file parts); the server answers 400 `unsupported_content`. */
+var UnsupportedContentError = class extends Error {
+	code = "unsupported_content";
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedContentError";
+	}
+};
+// src/wire/anthropic.ts
+const isObj$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Block types that carry attachments the proxy cannot pseudonymize. */
+const REFUSED_BLOCKS = {
+	image: true,
+	document: true,
+	search_result: true
+};
+const signatureKey$1 = (signature) => `anthropic:${signature}`;
+function refuse$1(block) {
+	if (typeof block.type === "string" && REFUSED_BLOCKS[block.type] === true) throw new UnsupportedContentError(`Anthropic ${block.type} content cannot be transformed`);
+}
+async function outbound$2(transform, text, leaf) {
+	return text === "" ? text : transform.outbound(text, leaf);
+}
+/** A string, or an array of blocks whose `text` blocks are rewritten. */
+async function rewriteText(content, leaf, transform) {
+	if (typeof content === "string") return outbound$2(transform, content, leaf);
+	if (!Array.isArray(content)) return content;
+	const out = [];
+	for (const block of content) {
+		if (!isObj$2(block)) {
+			out.push(block);
+			continue;
+		}
+		refuse$1(block);
+		out.push(block.type === "text" && typeof block.text === "string" ? {
+			...block,
+			text: await outbound$2(transform, block.text, leaf)
+		} : block);
+	}
+	return out;
+}
+/** Every string leaf of a JSON value (tool-call input); keys stay as they are. */
+async function rewriteStrings$2(value, leaf, transform) {
+	if (typeof value === "string") return outbound$2(transform, value, leaf);
+	if (Array.isArray(value)) {
+		const out = [];
+		for (const item of value) out.push(await rewriteStrings$2(item, leaf, transform));
+		return out;
+	}
+	if (isObj$2(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = await rewriteStrings$2(item, leaf, transform);
+		return out;
+	}
+	return value;
+}
+/** Every string leaf of a JSON value, restored inbound. */
+function restoreStrings$1(value, transform) {
+	if (typeof value === "string") return transform.inbound(value);
+	if (Array.isArray(value)) return value.map((item) => restoreStrings$1(item, transform));
+	if (isObj$2(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = restoreStrings$1(item, transform);
+		return out;
+	}
+	return value;
+}
+/** A thinking block: swaps in the cached model text when its signature is known, else rewrites it. */
+async function rewriteThinking(block, ctx) {
+	if (typeof block.signature === "string") {
+		const cached = ctx.signatures.get(signatureKey$1(block.signature));
+		if (cached !== void 0) return {
+			...block,
+			thinking: cached
+		};
+	}
+	if (typeof block.thinking !== "string") return block;
+	return {
+		...block,
+		thinking: await outbound$2(ctx.transform, block.thinking, { kind: "thinking" })
+	};
+}
+async function rewriteContent$2(content, role, toolNames, ctx) {
+	const textKind = role === "assistant" ? "assistant" : "user";
+	if (typeof content === "string") return outbound$2(ctx.transform, content, { kind: textKind });
+	if (!Array.isArray(content)) return content;
+	const out = [];
+	for (const block of content) {
+		if (!isObj$2(block)) {
+			out.push(block);
+			continue;
+		}
+		refuse$1(block);
+		switch (block.type) {
+			case "text":
+				out.push(typeof block.text === "string" ? {
+					...block,
+					text: await outbound$2(ctx.transform, block.text, { kind: textKind })
+				} : block);
+				break;
+			case "thinking":
+				out.push(await rewriteThinking(block, ctx));
+				break;
+			case "tool_use": {
+				const toolName = typeof block.name === "string" ? block.name : void 0;
+				out.push({
+					...block,
+					input: await rewriteStrings$2(block.input, {
+						kind: "toolCall",
+						toolName
+					}, ctx.transform)
+				});
+				break;
+			}
+			case "tool_result": {
+				const toolName = typeof block.tool_use_id === "string" ? toolNames.get(block.tool_use_id) : void 0;
+				out.push({
+					...block,
+					content: await rewriteText(block.content, {
+						kind: "toolResult",
+						toolName
+					}, ctx.transform)
+				});
+				break;
+			}
+			default: out.push(block);
+		}
+	}
+	return out;
+}
+/** Maps each `tool_use` id to its tool name, so tool results can name their tool. */
+function toolNamesById(messages) {
+	const names = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (!isObj$2(message) || !Array.isArray(message.content)) continue;
+		for (const block of message.content) if (isObj$2(block) && block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") names.set(block.id, block.name);
+	}
+	return names;
+}
+function withInstruction(system, instruction) {
+	if (system === void 0) return instruction;
+	if (typeof system === "string") return `${instruction}\n\n${system}`;
+	if (Array.isArray(system)) return [{
+		type: "text",
+		text: instruction
+	}, ...system];
+	return system;
+}
+function newBlockState(kind, transform) {
+	return {
+		kind,
+		restore: kind === "tool" ? createJsonArgRestorer(() => transform.inboundStream()) : transform.inboundStream(),
+		raw: ""
+	};
+}
+/** The delta that carries a block's held-back tail, shaped for the block's kind. */
+function tailDelta(kind, tail) {
+	if (kind === "text") return {
+		type: "text_delta",
+		text: tail
+	};
+	if (kind === "thinking") return {
+		type: "thinking_delta",
+		thinking: tail
+	};
+	return {
+		type: "input_json_delta",
+		partial_json: tail
+	};
+}
+function createStreamTransformer$2(ctx) {
+	const blocks = /* @__PURE__ */ new Map();
+	const handle = (block) => {
+		let payload;
+		try {
+			payload = JSON.parse(block.data);
+		} catch {
+			return block.raw;
+		}
+		if (!isObj$2(payload)) return block.raw;
+		const index = typeof payload.index === "number" ? payload.index : void 0;
+		switch (payload.type) {
+			case "content_block_start": {
+				const content = payload.content_block;
+				if (index === void 0 || !isObj$2(content)) return block.raw;
+				if (content.type === "text" || content.type === "thinking" || content.type === "tool_use") {
+					const kind = content.type === "tool_use" ? "tool" : content.type;
+					blocks.set(index, newBlockState(kind, ctx.transform));
+				}
+				return block.raw;
+			}
+			case "content_block_delta": {
+				const state = index === void 0 ? void 0 : blocks.get(index);
+				const delta = payload.delta;
+				if (state === void 0 || !isObj$2(delta)) return block.raw;
+				if (state.kind === "text" && delta.type === "text_delta" && typeof delta.text === "string") return formatSseEvent(block.event, {
+					...payload,
+					delta: {
+						...delta,
+						text: state.restore.push(delta.text)
+					}
+				});
+				if (state.kind === "thinking" && delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+					state.raw += delta.thinking;
+					return formatSseEvent(block.event, {
+						...payload,
+						delta: {
+							...delta,
+							thinking: state.restore.push(delta.thinking)
+						}
+					});
+				}
+				if (state.kind === "thinking" && delta.type === "signature_delta" && typeof delta.signature === "string") {
+					ctx.signatures.set(signatureKey$1(delta.signature), state.raw);
+					return block.raw;
+				}
+				if (state.kind === "tool" && delta.type === "input_json_delta" && typeof delta.partial_json === "string") return formatSseEvent(block.event, {
+					...payload,
+					delta: {
+						...delta,
+						partial_json: state.restore.push(delta.partial_json)
+					}
+				});
+				return block.raw;
+			}
+			case "content_block_stop": {
+				const state = index === void 0 ? void 0 : blocks.get(index);
+				if (index === void 0 || state === void 0) return block.raw;
+				blocks.delete(index);
+				const tail = state.restore.flush();
+				if (tail === "") return block.raw;
+				return formatSseEvent("content_block_delta", {
+					type: "content_block_delta",
+					index,
+					delta: tailDelta(state.kind, tail)
+				}) + block.raw;
+			}
+			default: return block.raw;
+		}
+	};
+	const finish = () => {
+		let out = "";
+		for (const [index, state] of blocks) {
+			const tail = state.restore.flush();
+			if (tail !== "") out += formatSseEvent("content_block_delta", {
+				type: "content_block_delta",
+				index,
+				delta: tailDelta(state.kind, tail)
+			});
+		}
+		blocks.clear();
+		return out;
+	};
+	return createSseFramer(handle, finish);
+}
+const anthropicWalker = {
+	async request(body, ctx) {
+		if (!isObj$2(body)) return body;
+		const out = { ...body };
+		if (body.system !== void 0) out.system = await rewriteText(body.system, { kind: "system" }, ctx.transform);
+		if (ctx.transform.instruction !== void 0) out.system = withInstruction(out.system, ctx.transform.instruction);
+		if (Array.isArray(body.messages)) {
+			const toolNames = toolNamesById(body.messages);
+			const messages = [];
+			for (const message of body.messages) messages.push(isObj$2(message) ? {
+				...message,
+				content: await rewriteContent$2(message.content, message.role, toolNames, ctx)
+			} : message);
+			out.messages = messages;
+		}
+		return out;
+	},
+	response(body, ctx) {
+		if (!isObj$2(body) || !Array.isArray(body.content)) return body;
+		const content = body.content.map((block) => {
+			if (!isObj$2(block)) return block;
+			if (block.type === "text" && typeof block.text === "string") return {
+				...block,
+				text: ctx.transform.inbound(block.text)
+			};
+			if (block.type === "thinking" && typeof block.thinking === "string") {
+				if (typeof block.signature === "string") ctx.signatures.set(signatureKey$1(block.signature), block.thinking);
+				return {
+					...block,
+					thinking: ctx.transform.inbound(block.thinking)
+				};
+			}
+			if (block.type === "tool_use") return {
+				...block,
+				input: restoreStrings$1(block.input, ctx.transform)
+			};
+			return block;
+		});
+		return {
+			...body,
+			content
+		};
+	},
+	stream(ctx) {
+		return createStreamTransformer$2(ctx);
+	}
+};
+// src/wire/openai-chat.ts
+const isObj$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Content part types that carry attachments the proxy cannot pseudonymize. */
+const REFUSED_PARTS$1 = {
+	image_url: true,
+	input_audio: true,
+	file: true
+};
+/** Reasoning fields used by OpenAI-compatible providers. */
+const REASONING_FIELDS = ["reasoning_content", "reasoning"];
+async function outbound$1(transform, text, leaf) {
+	return text === "" ? text : transform.outbound(text, leaf);
+}
+/** A string, or an array of parts whose `text` parts are rewritten. */
+async function rewriteContent$1(content, leaf, transform) {
+	if (typeof content === "string") return outbound$1(transform, content, leaf);
+	if (!Array.isArray(content)) return content;
+	const out = [];
+	for (const part of content) {
+		if (!isObj$1(part)) {
+			out.push(part);
+			continue;
+		}
+		if (typeof part.type === "string" && REFUSED_PARTS$1[part.type] === true) throw new UnsupportedContentError(`OpenAI chat ${part.type} content cannot be transformed`);
+		out.push(part.type === "text" && typeof part.text === "string" ? {
+			...part,
+			text: await outbound$1(transform, part.text, leaf)
+		} : part);
+	}
+	return out;
+}
+async function rewriteStrings$1(value, leaf, transform) {
+	if (typeof value === "string") return outbound$1(transform, value, leaf);
+	if (Array.isArray(value)) {
+		const out = [];
+		for (const item of value) out.push(await rewriteStrings$1(item, leaf, transform));
+		return out;
+	}
+	if (isObj$1(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = await rewriteStrings$1(item, leaf, transform);
+		return out;
+	}
+	return value;
+}
+function restoreStrings(value, transform) {
+	if (typeof value === "string") return transform.inbound(value);
+	if (Array.isArray(value)) return value.map((item) => restoreStrings(item, transform));
+	if (isObj$1(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = restoreStrings(item, transform);
+		return out;
+	}
+	return value;
+}
+/** Tool-call arguments are a JSON string: rewrite its string leaves, or the raw text when it is not JSON. */
+async function rewriteArguments$1(args, leaf, transform) {
+	let parsed;
+	try {
+		parsed = JSON.parse(args);
+	} catch {
+		return outbound$1(transform, args, leaf);
+	}
+	return JSON.stringify(await rewriteStrings$1(parsed, leaf, transform));
+}
+function restoreArguments$1(args, transform) {
+	let parsed;
+	try {
+		parsed = JSON.parse(args);
+	} catch {
+		return transform.inbound(args);
+	}
+	return JSON.stringify(restoreStrings(parsed, transform));
+}
+async function rewriteToolCalls(calls, transform, names) {
+	if (!Array.isArray(calls)) return calls;
+	const out = [];
+	for (const call of calls) {
+		if (!isObj$1(call) || !isObj$1(call.function)) {
+			out.push(call);
+			continue;
+		}
+		const fn = call.function;
+		const toolName = typeof fn.name === "string" ? fn.name : void 0;
+		if (typeof call.id === "string" && toolName !== void 0) names.set(call.id, toolName);
+		out.push(typeof fn.arguments === "string" ? {
+			...call,
+			function: {
+				...fn,
+				arguments: await rewriteArguments$1(fn.arguments, {
+					kind: "toolCall",
+					toolName
+				}, transform)
+			}
+		} : call);
+	}
+	return out;
+}
+async function rewriteMessage(message, transform, names) {
+	const out = { ...message };
+	switch (message.role) {
+		case "system":
+		case "developer":
+			out.content = await rewriteContent$1(message.content, { kind: "system" }, transform);
+			break;
+		case "user":
+			out.content = await rewriteContent$1(message.content, { kind: "user" }, transform);
+			break;
+		case "assistant":
+			for (const field of REASONING_FIELDS) {
+				const value = message[field];
+				if (typeof value === "string") out[field] = await outbound$1(transform, value, { kind: "thinking" });
+			}
+			out.content = await rewriteContent$1(message.content, { kind: "assistant" }, transform);
+			out.tool_calls = await rewriteToolCalls(message.tool_calls, transform, names);
+			if (message.tool_calls === void 0) delete out.tool_calls;
+			break;
+		case "tool": {
+			const toolName = typeof message.tool_call_id === "string" ? names.get(message.tool_call_id) : void 0;
+			out.content = await rewriteContent$1(message.content, {
+				kind: "toolResult",
+				toolName
+			}, transform);
+			break;
+		}
+		default: return message;
+	}
+	if (message.content === void 0) delete out.content;
+	return out;
+}
+/** The delta carrying every held tail of one choice, or undefined when nothing is held. */
+function flushChoice(state) {
+	const delta = {};
+	if (state.content !== void 0) {
+		const tail = state.content.flush();
+		if (tail !== "") delta.content = tail;
+	}
+	for (const [field, restore] of state.reasoning) {
+		const tail = restore.flush();
+		if (tail !== "") delta[field] = tail;
+	}
+	const tools = [];
+	for (const [index, restore] of state.tools) {
+		const tail = restore.flush();
+		if (tail !== "") tools.push({
+			index,
+			function: { arguments: tail }
+		});
+	}
+	if (tools.length > 0) delta.tool_calls = tools;
+	state.content = void 0;
+	state.reasoning.clear();
+	state.tools.clear();
+	return Object.keys(delta).length === 0 ? void 0 : delta;
+}
+function createStreamTransformer$1(ctx) {
+	const choices = /* @__PURE__ */ new Map();
+	/** The latest chunk's envelope (id, model, ...), reused for tail chunks. */
+	let envelope = { object: "chat.completion.chunk" };
+	const choiceState = (index) => {
+		let state = choices.get(index);
+		if (state === void 0) {
+			state = {
+				reasoning: /* @__PURE__ */ new Map(),
+				tools: /* @__PURE__ */ new Map()
+			};
+			choices.set(index, state);
+		}
+		return state;
+	};
+	const tailEvent = (event, index, delta) => formatSseEvent(event, {
+		...envelope,
+		choices: [{
+			index,
+			delta,
+			finish_reason: null
+		}]
+	});
+	const flushAll = (event) => {
+		let out = "";
+		for (const [index, state] of choices) {
+			const delta = flushChoice(state);
+			if (delta !== void 0) out += tailEvent(event, index, delta);
+		}
+		choices.clear();
+		return out;
+	};
+	const rewriteDelta = (delta, state) => {
+		const out = { ...delta };
+		let changed = false;
+		if (typeof delta.content === "string") {
+			state.content ??= ctx.transform.inboundStream();
+			out.content = state.content.push(delta.content);
+			changed = true;
+		}
+		for (const field of REASONING_FIELDS) {
+			const value = delta[field];
+			if (typeof value !== "string") continue;
+			let restore = state.reasoning.get(field);
+			if (restore === void 0) {
+				restore = ctx.transform.inboundStream();
+				state.reasoning.set(field, restore);
+			}
+			out[field] = restore.push(value);
+			changed = true;
+		}
+		if (Array.isArray(delta.tool_calls)) out.tool_calls = delta.tool_calls.map((call) => {
+			if (!isObj$1(call) || !isObj$1(call.function) || typeof call.function.arguments !== "string") return call;
+			const index = typeof call.index === "number" ? call.index : 0;
+			let restore = state.tools.get(index);
+			if (restore === void 0) {
+				restore = createJsonArgRestorer(() => ctx.transform.inboundStream());
+				state.tools.set(index, restore);
+			}
+			changed = true;
+			return {
+				...call,
+				function: {
+					...call.function,
+					arguments: restore.push(call.function.arguments)
+				}
+			};
+		});
+		return {
+			delta: out,
+			changed
+		};
+	};
+	const handle = (block) => {
+		if (block.data.trim() === "[DONE]") return flushAll(block.event) + block.raw;
+		let payload;
+		try {
+			payload = JSON.parse(block.data);
+		} catch {
+			return block.raw;
+		}
+		if (!isObj$1(payload) || !Array.isArray(payload.choices)) return block.raw;
+		const { choices: _choices, ...rest } = payload;
+		envelope = rest;
+		let changed = false;
+		let before = "";
+		const rewritten = payload.choices.map((choice) => {
+			if (!isObj$1(choice)) return choice;
+			const index = typeof choice.index === "number" ? choice.index : 0;
+			const state = choiceState(index);
+			let next = choice;
+			if (isObj$1(choice.delta)) {
+				const result = rewriteDelta(choice.delta, state);
+				if (result.changed) {
+					next = {
+						...choice,
+						delta: result.delta
+					};
+					changed = true;
+				}
+			}
+			if (choice.finish_reason !== null && choice.finish_reason !== void 0) {
+				const tail = flushChoice(state);
+				choices.delete(index);
+				if (tail !== void 0) before += tailEvent(block.event, index, tail);
+			}
+			return next;
+		});
+		return before + (changed ? formatSseEvent(block.event, {
+			...payload,
+			choices: rewritten
+		}) : block.raw);
+	};
+	return createSseFramer(handle, () => flushAll(void 0));
+}
+const openaiChatWalker = {
+	async request(body, ctx) {
+		if (!isObj$1(body)) return body;
+		const out = { ...body };
+		if (Array.isArray(body.messages)) {
+			const names = /* @__PURE__ */ new Map();
+			const messages = [];
+			for (const message of body.messages) messages.push(isObj$1(message) ? await rewriteMessage(message, ctx.transform, names) : message);
+			if (ctx.transform.instruction !== void 0) messages.unshift({
+				role: "system",
+				content: ctx.transform.instruction
+			});
+			out.messages = messages;
+		}
+		return out;
+	},
+	response(body, ctx) {
+		if (!isObj$1(body) || !Array.isArray(body.choices)) return body;
+		const choices = body.choices.map((choice) => {
+			if (!isObj$1(choice) || !isObj$1(choice.message)) return choice;
+			const message = { ...choice.message };
+			if (typeof message.content === "string") message.content = ctx.transform.inbound(message.content);
+			for (const field of REASONING_FIELDS) {
+				const value = message[field];
+				if (typeof value === "string") message[field] = ctx.transform.inbound(value);
+			}
+			if (Array.isArray(message.tool_calls)) message.tool_calls = message.tool_calls.map((call) => {
+				if (!isObj$1(call) || !isObj$1(call.function) || typeof call.function.arguments !== "string") return call;
+				return {
+					...call,
+					function: {
+						...call.function,
+						arguments: restoreArguments$1(call.function.arguments, ctx.transform)
+					}
+				};
+			});
+			return {
+				...choice,
+				message
+			};
+		});
+		return {
+			...body,
+			choices
+		};
+	},
+	stream(ctx) {
+		return createStreamTransformer$1(ctx);
+	}
+};
+// src/wire/openai-responses.ts
+const isObj = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Part types that carry attachments the proxy cannot pseudonymize. */
+const REFUSED_PARTS = {
+	input_image: true,
+	input_file: true,
+	input_audio: true
+};
+const signatureKey = (itemId) => `responses:${itemId}`;
+function refuse(part) {
+	if (typeof part.type === "string" && REFUSED_PARTS[part.type] === true) throw new UnsupportedContentError(`OpenAI responses ${part.type} content cannot be transformed`);
+}
+async function outbound(transform, text, leaf) {
+	return text === "" ? text : transform.outbound(text, leaf);
+}
+/** A string, or an array of parts whose `input_text`/`output_text` parts are rewritten. */
+async function rewriteContent(content, leaf, transform) {
+	if (typeof content === "string") return outbound(transform, content, leaf);
+	if (!Array.isArray(content)) return content;
+	const out = [];
+	for (const part of content) {
+		if (!isObj(part)) {
+			out.push(part);
+			continue;
+		}
+		refuse(part);
+		out.push((part.type === "input_text" || part.type === "output_text") && typeof part.text === "string" ? {
+			...part,
+			text: await outbound(transform, part.text, leaf)
+		} : part);
+	}
+	return out;
+}
+async function rewriteStrings(value, leaf, transform) {
+	if (typeof value === "string") return outbound(transform, value, leaf);
+	if (Array.isArray(value)) {
+		const out = [];
+		for (const item of value) out.push(await rewriteStrings(item, leaf, transform));
+		return out;
+	}
+	if (isObj(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = await rewriteStrings(item, leaf, transform);
+		return out;
+	}
+	return value;
+}
+/** Tool-call arguments: a JSON string whose string leaves are rewritten; raw text when it is not JSON. */
+async function rewriteArguments(args, leaf, transform) {
+	let parsed;
+	try {
+		parsed = JSON.parse(args);
+	} catch {
+		return outbound(transform, args, leaf);
+	}
+	return JSON.stringify(await rewriteStrings(parsed, leaf, transform));
+}
+/** Restores the string values of a JSON text, keeping its formatting; restored originals are JSON-escaped. */
+function restoreArguments(args, transform) {
+	const restorer = createJsonArgRestorer(() => transform.inboundStream());
+	return restorer.push(args) + restorer.flush();
+}
+function summaryTexts(item) {
+	if (!Array.isArray(item.summary)) return void 0;
+	const texts = [];
+	for (const part of item.summary) {
+		if (!isObj(part) || typeof part.text !== "string") return void 0;
+		texts.push(part.text);
+	}
+	return texts;
+}
+function cachedSummary(item, ctx) {
+	if (typeof item.id !== "string") return void 0;
+	const cached = ctx.signatures.get(signatureKey(item.id));
+	if (cached === void 0) return void 0;
+	const texts = JSON.parse(cached);
+	if (!Array.isArray(texts) || !Array.isArray(item.summary) || texts.length !== item.summary.length) return void 0;
+	return texts;
+}
+async function rewriteReasoning(item, ctx) {
+	if (!Array.isArray(item.summary)) return item;
+	const cached = cachedSummary(item, ctx);
+	const summary = [];
+	for (const [i, part] of item.summary.entries()) if (!isObj(part) || typeof part.text !== "string") summary.push(part);
+	else if (cached !== void 0) summary.push({
+		...part,
+		text: cached[i]
+	});
+	else summary.push({
+		...part,
+		text: await outbound(ctx.transform, part.text, { kind: "thinking" })
+	});
+	return {
+		...item,
+		summary
+	};
+}
+function roleKind(role) {
+	if (role === "developer" || role === "system") return "system";
+	if (role === "user") return "user";
+	if (role === "assistant") return "assistant";
+}
+function toolNamesByCallId(items) {
+	const names = /* @__PURE__ */ new Map();
+	for (const item of items) if (isObj(item) && item.type === "function_call" && typeof item.call_id === "string" && typeof item.name === "string") names.set(item.call_id, item.name);
+	return names;
+}
+async function rewriteItem(item, toolNames, ctx) {
+	if (item.type === "message" || item.type === void 0 && item.role !== void 0) {
+		const kind = roleKind(item.role);
+		if (kind === void 0) return item;
+		return {
+			...item,
+			content: await rewriteContent(item.content, { kind }, ctx.transform)
+		};
+	}
+	switch (item.type) {
+		case "function_call": {
+			if (typeof item.arguments !== "string") return item;
+			const toolName = typeof item.name === "string" ? item.name : void 0;
+			return {
+				...item,
+				arguments: await rewriteArguments(item.arguments, {
+					kind: "toolCall",
+					toolName
+				}, ctx.transform)
+			};
+		}
+		case "function_call_output": {
+			const toolName = typeof item.call_id === "string" ? toolNames.get(item.call_id) : void 0;
+			return {
+				...item,
+				output: await rewriteContent(item.output, {
+					kind: "toolResult",
+					toolName
+				}, ctx.transform)
+			};
+		}
+		case "reasoning": return rewriteReasoning(item, ctx);
+		default: return item;
+	}
+}
+/** Restores one output item; reasoning items store their raw summary in the signature cache first. */
+function restoreItem(item, ctx) {
+	if (!isObj(item)) return item;
+	const transform = ctx.transform;
+	switch (item.type) {
+		case "message":
+			if (!Array.isArray(item.content)) return item;
+			return {
+				...item,
+				content: item.content.map((part) => restorePart(part, transform))
+			};
+		case "reasoning": {
+			const texts = summaryTexts(item);
+			if (texts === void 0) return item;
+			if (typeof item.id === "string") ctx.signatures.set(signatureKey(item.id), JSON.stringify(texts));
+			return {
+				...item,
+				summary: item.summary.map((part) => ({
+					...part,
+					text: transform.inbound(part.text)
+				}))
+			};
+		}
+		case "function_call": return typeof item.arguments === "string" ? {
+			...item,
+			arguments: restoreArguments(item.arguments, transform)
+		} : item;
+		default: return item;
+	}
+}
+function restorePart(part, transform) {
+	return isObj(part) && part.type === "output_text" && typeof part.text === "string" ? {
+		...part,
+		text: transform.inbound(part.text)
+	} : part;
+}
+function restoreResponse(body, ctx) {
+	const out = { ...body };
+	if (Array.isArray(body.output)) out.output = body.output.map((item) => restoreItem(item, ctx));
+	if (typeof body.output_text === "string") out.output_text = ctx.transform.inbound(body.output_text);
+	return out;
+}
+function createStreamTransformer(ctx) {
+	const streams = /* @__PURE__ */ new Map();
+	const open = (key, factory) => {
+		let state = streams.get(key);
+		if (state === void 0) {
+			state = { restore: factory() };
+			streams.set(key, state);
+		}
+		return state;
+	};
+	/** Emits the tail delta (if any) followed by the rewritten `.done` event. */
+	const closeWith = (block, payload, key, deltaType, done) => {
+		const state = streams.get(key);
+		streams.delete(key);
+		let out = "";
+		const tail = state?.restore.flush() ?? "";
+		if (tail !== "") {
+			const { text: _text, arguments: _args, ...rest } = payload;
+			out += formatSseEvent(block.event === void 0 ? void 0 : deltaType, {
+				...rest,
+				type: deltaType,
+				delta: tail
+			});
+		}
+		return out + formatSseEvent(block.event, done);
+	};
+	const handle = (block) => {
+		let payload;
+		try {
+			payload = JSON.parse(block.data);
+		} catch {
+			return block.raw;
+		}
+		if (!isObj(payload)) return block.raw;
+		const itemId = typeof payload.item_id === "string" ? payload.item_id : void 0;
+		const textKey = `text:${itemId}:${String(payload.content_index)}`;
+		const summaryKey = `summary:${itemId}:${String(payload.summary_index)}`;
+		const argsKey = `args:${itemId}`;
+		const textStream = () => ctx.transform.inboundStream();
+		const argStream = () => createJsonArgRestorer(() => ctx.transform.inboundStream());
+		switch (payload.type) {
+			case "response.output_text.delta":
+				if (itemId === void 0 || typeof payload.delta !== "string") return block.raw;
+				return formatSseEvent(block.event, {
+					...payload,
+					delta: open(textKey, textStream).restore.push(payload.delta)
+				});
+			case "response.reasoning_summary_text.delta":
+				if (itemId === void 0 || typeof payload.delta !== "string") return block.raw;
+				return formatSseEvent(block.event, {
+					...payload,
+					delta: open(summaryKey, textStream).restore.push(payload.delta)
+				});
+			case "response.function_call_arguments.delta":
+				if (itemId === void 0 || typeof payload.delta !== "string") return block.raw;
+				return formatSseEvent(block.event, {
+					...payload,
+					delta: open(argsKey, argStream).restore.push(payload.delta)
+				});
+			case "response.output_text.done":
+				if (itemId === void 0 || typeof payload.text !== "string") return block.raw;
+				return closeWith(block, payload, textKey, "response.output_text.delta", {
+					...payload,
+					text: ctx.transform.inbound(payload.text)
+				});
+			case "response.reasoning_summary_text.done":
+				if (itemId === void 0 || typeof payload.text !== "string") return block.raw;
+				return closeWith(block, payload, summaryKey, "response.reasoning_summary_text.delta", {
+					...payload,
+					text: ctx.transform.inbound(payload.text)
+				});
+			case "response.function_call_arguments.done":
+				if (itemId === void 0 || typeof payload.arguments !== "string") return block.raw;
+				return closeWith(block, payload, argsKey, "response.function_call_arguments.delta", {
+					...payload,
+					arguments: restoreArguments(payload.arguments, ctx.transform)
+				});
+			case "response.content_part.done": return isObj(payload.part) ? formatSseEvent(block.event, {
+				...payload,
+				part: restorePart(payload.part, ctx.transform)
+			}) : block.raw;
+			case "response.reasoning_summary_part.done": return isObj(payload.part) && typeof payload.part.text === "string" ? formatSseEvent(block.event, {
+				...payload,
+				part: {
+					...payload.part,
+					text: ctx.transform.inbound(payload.part.text)
+				}
+			}) : block.raw;
+			case "response.output_item.done": return isObj(payload.item) ? formatSseEvent(block.event, {
+				...payload,
+				item: restoreItem(payload.item, ctx)
+			}) : block.raw;
+			case "response.completed":
+			case "response.incomplete": return isObj(payload.response) ? formatSseEvent(block.event, {
+				...payload,
+				response: restoreResponse(payload.response, ctx)
+			}) : block.raw;
+			default: return block.raw;
+		}
+	};
+	const finish = () => {
+		let out = "";
+		for (const [key, state] of streams) {
+			const tail = state.restore.flush();
+			if (tail === "") continue;
+			const [kind, itemId] = key.split(":");
+			const type = kind === "text" ? "response.output_text.delta" : kind === "summary" ? "response.reasoning_summary_text.delta" : "response.function_call_arguments.delta";
+			out += formatSseEvent(type, {
+				type,
+				item_id: itemId,
+				delta: tail
+			});
+		}
+		streams.clear();
+		return out;
+	};
+	return createSseFramer(handle, finish);
+}
+const openaiResponsesWalker = {
+	async request(body, ctx) {
+		if (!isObj(body)) return body;
+		const out = { ...body };
+		if (typeof body.instructions === "string") out.instructions = await outbound(ctx.transform, body.instructions, { kind: "system" });
+		const instruction = ctx.transform.instruction;
+		if (instruction !== void 0) out.instructions = typeof out.instructions === "string" && out.instructions !== "" ? `${instruction}\n\n${out.instructions}` : instruction;
+		if (typeof body.input === "string") out.input = await outbound(ctx.transform, body.input, { kind: "user" });
+		else if (Array.isArray(body.input)) {
+			const toolNames = toolNamesByCallId(body.input);
+			const input = [];
+			for (const item of body.input) input.push(isObj(item) ? await rewriteItem(item, toolNames, ctx) : item);
+			out.input = input;
+		}
+		return out;
+	},
+	response(body, ctx) {
+		return isObj(body) ? restoreResponse(body, ctx) : body;
+	},
+	stream(ctx) {
+		return createStreamTransformer(ctx);
+	}
+};
+// src/routes.ts
+/**
+* The route table. Routes are matched in order, so longer suffixes come first.
+* Any other path, embeddings included, answers 404 `unsupported_route`.
+*/
+const WIRE_ROUTES = [
+	{
+		suffix: "/messages/count_tokens",
+		wire: anthropicWalker,
+		rewriteResponse: false
+	},
+	{
+		suffix: "/messages",
+		wire: anthropicWalker,
+		rewriteResponse: true
+	},
+	{
+		suffix: "/chat/completions",
+		wire: openaiChatWalker,
+		rewriteResponse: true
+	},
+	{
+		suffix: "/responses",
+		wire: openaiResponsesWalker,
+		rewriteResponse: true
+	}
+];
+/** Classifies a request by method and path. `undefined` means the route is unsupported. */
+function classify(method, pathname) {
+	if (method === "GET" && pathname.endsWith("/models")) return { kind: "passthrough" };
+	if (method !== "POST") return void 0;
+	const route = WIRE_ROUTES.find((candidate) => pathname.endsWith(candidate.suffix));
+	return route === void 0 ? void 0 : {
+		kind: "wire",
+		route
+	};
+}
+// src/sessions.ts
+function createSessionState() {
+	return {
+		facts: createSessionFacts(),
+		signatures: /* @__PURE__ */ new Map(),
+		instances: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* Returns the session's instance for a pipeline, building it on first use.
+* Concurrent first calls share one build; a failed build is forgotten so the next call retries.
+*/
+function instanceFor(state, pipelineId, build) {
+	const existing = state.instances.get(pipelineId);
+	if (existing) return existing;
+	const pending = build().catch((err) => {
+		if (state.instances.get(pipelineId) === pending) state.instances.delete(pipelineId);
+		throw err;
+	});
+	state.instances.set(pipelineId, pending);
+	return pending;
+}
+/** Disposes every instance of a session, waiting for pending builds first. Dispose errors are logged. */
+async function disposeInstances(state, log) {
+	const settled = await Promise.allSettled([...state.instances.values()]);
+	state.instances.clear();
+	for (const result of settled) {
+		if (result.status !== "fulfilled") continue;
+		try {
+			await result.value.dispose?.();
+		} catch (err) {
+			log.error(`transform dispose failed: ${errorMessage(err)}`);
+		}
+	}
+}
+// src/server.ts
+const UPSTREAM_HEADER = "x-skaile-transform-upstream";
+const SESSION_HEADER = "x-skaile-transform-session";
+const PIPELINE_HEADER = "x-skaile-transform-pipeline";
+const TOKEN_HEADER = "x-skaile-transform-token";
+const DEFAULT_SESSION = "default";
+const LOOPBACK_HOSTS = {
+	"127.0.0.1": true,
+	localhost: true,
+	"::1": true,
+	"[::1]": true
+};
+/** Connection-level headers: never forwarded in either direction. */
+const HOP_BY_HOP = {
+	connection: true,
+	"keep-alive": true,
+	"proxy-connection": true,
+	te: true,
+	trailer: true,
+	"transfer-encoding": true,
+	upgrade: true
+};
+const REQUEST_SKIP = {
+	...HOP_BY_HOP,
+	host: true,
+	"content-length": true,
+	"accept-encoding": true
+};
+/** Response headers the proxy re-derives: the body length and encoding after rewriting, and set-cookie (sent via getSetCookie). */
+const RESPONSE_SKIP = {
+	...HOP_BY_HOP,
+	"content-length": true,
+	"content-encoding": true,
+	"set-cookie": true
+};
+async function createTransformProxy(options) {
+	const log = options.log ?? silentLogger;
+	const host = options.host ?? "127.0.0.1";
+	if (!Object.hasOwn(LOOPBACK_HOSTS, host) && options.token === void 0) throw new Error(`transform proxy host ${host} is not loopback: a token is required`);
+	validatePipelines(options);
+	const allowed = options.allowUpstreams === void 0 ? void 0 : new Set(options.allowUpstreams.map(originOf));
+	const factories = await openTransforms(options.transforms, options.baseDir, log);
+	const pipelines = options.pipelines;
+	const sessions = /* @__PURE__ */ new Map();
+	function stateFor(id) {
+		const existing = sessions.get(id);
+		if (existing) return existing;
+		const created = createSessionState();
+		sessions.set(id, created);
+		return created;
+	}
+	async function buildInstance(state, sessionId, pipelineId) {
+		const stages = [];
+		const ids = pipelines[pipelineId] ?? [];
+		try {
+			for (const id of ids) {
+				const factory = factories.get(id);
+				if (factory === void 0) throw new Error(`transform "${id}" is not configured`);
+				try {
+					stages.push(await factory({
+						sessionId,
+						facts: state.facts.facts,
+						log
+					}));
+				} catch (err) {
+					throw new Error(`transform "${id}" failed to start: ${errorMessage(err)}`, { cause: err });
+				}
+			}
+		} catch (err) {
+			for (const stage of stages) try {
+				await stage.dispose?.();
+			} catch (disposeErr) {
+				log.error(`transform dispose failed: ${errorMessage(disposeErr)}`);
+			}
+			throw err;
+		}
+		return composeTransforms(stages, log);
+	}
+	async function handle(req, res) {
+		const url = new URL(req.url ?? "/", "http://proxy.invalid");
+		if (options.token !== void 0 && !tokenMatches(header(req, "x-skaile-transform-token"), options.token)) return sendError(res, 401, "unauthorized", `${TOKEN_HEADER} is missing or wrong`);
+		if (req.method === "OPTIONS") return sendError(res, 405, "method_not_allowed", "OPTIONS is refused");
+		const upstreamValue = header(req, UPSTREAM_HEADER);
+		if (upstreamValue === void 0) return sendError(res, 400, "missing_upstream", `${UPSTREAM_HEADER} is required`);
+		const upstream = parseHttpUrl(upstreamValue);
+		if (upstream === void 0) return sendError(res, 400, "invalid_upstream", `${UPSTREAM_HEADER} must be an http(s) URL`);
+		if (!upstreamAllowed(upstream, allowed)) return sendError(res, 403, "upstream_not_allowed", `upstream ${upstream.origin} is not allowed`);
+		const sessionId = header(req, "x-skaile-transform-session") ?? DEFAULT_SESSION;
+		const pipelineId = header(req, "x-skaile-transform-pipeline") ?? options.defaultPipeline;
+		if (pipelineId === void 0) return sendError(res, 400, "no_pipeline", `${PIPELINE_HEADER} is required`);
+		if (!Object.hasOwn(pipelines, pipelineId)) return sendError(res, 400, "unknown_pipeline", `pipeline "${pipelineId}" is not configured`);
+		const method = req.method ?? "GET";
+		const classified = classify(method, url.pathname);
+		if (classified === void 0) return sendError(res, 404, "unsupported_route", `${method} ${url.pathname} is not proxied`);
+		const forwardTo = `${upstream.origin}${upstream.pathname.replace(/\/+$/, "")}${url.pathname}${url.search}`;
+		const headers = forwardRequestHeaders(req.headers);
+		if (classified.kind === "passthrough") return relayUpstream(res, await fetchUpstream(res, forwardTo, method, headers, void 0), void 0);
+		const { route } = classified;
+		const encoding = header(req, "content-encoding");
+		if (encoding !== void 0 && encoding !== "identity") return sendError(res, 400, "unsupported_encoding", "request bodies must not be content-encoded");
+		const raw = await readBody(req);
+		let parsed;
+		try {
+			parsed = JSON.parse(raw.toString("utf8"));
+		} catch {
+			return sendError(res, 400, "invalid_json", "request body is not JSON");
+		}
+		const state = stateFor(sessionId);
+		let instance;
+		try {
+			instance = await instanceFor(state, pipelineId, () => buildInstance(state, sessionId, pipelineId));
+		} catch (err) {
+			return sendError(res, 502, "transform_failed", errorMessage(err));
+		}
+		const ctx = {
+			transform: instance,
+			signatures: state.signatures
+		};
+		let rewritten;
+		try {
+			rewritten = await route.wire.request(parsed, ctx);
+		} catch (err) {
+			if (err instanceof UnsupportedContentError) return sendError(res, 400, "unsupported_content", err.message);
+			return sendError(res, 502, "transform_failed", errorMessage(err));
+		}
+		return relayUpstream(res, await fetchUpstream(res, forwardTo, method, headers, JSON.stringify(rewritten)), route.rewriteResponse ? {
+			wire: route.wire,
+			ctx
+		} : void 0);
+	}
+	async function fetchUpstream(res, target, method, headers, body) {
+		try {
+			return await fetch(target, {
+				method,
+				headers,
+				body,
+				redirect: "manual"
+			});
+		} catch (err) {
+			sendError(res, 502, "upstream_unreachable", errorMessage(err));
+			return;
+		}
+	}
+	/** Relays an upstream response. With `rewrite`, a 2xx JSON or SSE body is restored on the way back. */
+	async function relayUpstream(res, upstreamRes, rewrite) {
+		if (upstreamRes === void 0) return;
+		const contentType = upstreamRes.headers.get("content-type") ?? "";
+		const headers = relayHeaders(upstreamRes.headers);
+		if (rewrite !== void 0 && upstreamRes.ok && contentType.startsWith("text/event-stream")) return pipeStream(res, upstreamRes, headers, rewrite.wire.stream(rewrite.ctx), log);
+		if (rewrite !== void 0 && upstreamRes.ok && contentType.includes("application/json")) {
+			const text = await upstreamRes.text();
+			let restored;
+			try {
+				restored = JSON.stringify(rewrite.wire.response(JSON.parse(text), rewrite.ctx));
+			} catch (err) {
+				return sendError(res, 502, "transform_failed", errorMessage(err));
+			}
+			res.writeHead(upstreamRes.status, headers);
+			res.end(restored);
+			return;
+		}
+		res.writeHead(upstreamRes.status, headers);
+		res.end(Buffer.from(await upstreamRes.arrayBuffer()));
+	}
+	const server = createServer((req, res) => {
+		handle(req, res).catch((err) => {
+			log.error(`request failed: ${errorMessage(err)}`);
+			sendError(res, 500, "internal_error", "transform proxy failed");
+		});
+	});
+	const listening = Promise.withResolvers();
+	server.once("error", listening.reject);
+	server.listen(options.port ?? 0, host, () => {
+		server.off("error", listening.reject);
+		listening.resolve();
+	});
+	await listening.promise;
+	const address = server.address();
+	return {
+		url: `http://${host.includes(":") ? `[${host}]` : host}:${address.port}`,
+		session(id) {
+			const state = stateFor(id);
+			return {
+				facts: state.facts.facts,
+				publisher: (source) => state.facts.publisher(source)
+			};
+		},
+		async dropSession(id) {
+			const state = sessions.get(id);
+			if (state === void 0) return;
+			sessions.delete(id);
+			await disposeInstances(state, log);
+		},
+		async close() {
+			const closed = Promise.withResolvers();
+			server.close((err) => err ? closed.reject(err) : closed.resolve());
+			server.closeAllConnections();
+			await closed.promise;
+			for (const id of [...sessions.keys()]) {
+				const state = sessions.get(id);
+				sessions.delete(id);
+				if (state !== void 0) await disposeInstances(state, log);
+			}
+		}
+	};
+}
+function validatePipelines(options) {
+	for (const [pipelineId, ids] of Object.entries(options.pipelines)) for (const id of ids) if (!Object.hasOwn(options.transforms, id)) throw new Error(`pipeline "${pipelineId}" names unknown transform "${id}"`);
+	if (options.defaultPipeline !== void 0 && !Object.hasOwn(options.pipelines, options.defaultPipeline)) throw new Error(`defaultPipeline "${options.defaultPipeline}" is not a configured pipeline`);
+}
+function originOf(value) {
+	const url = parseHttpUrl(value);
+	if (url === void 0) throw new Error(`allowUpstreams entry "${value}" is not an http(s) URL`);
+	return url.origin;
+}
+function parseHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" || url.protocol === "http:" ? url : void 0;
+	} catch {
+		return;
+	}
+}
+function upstreamAllowed(url, allowed) {
+	if (allowed !== void 0) return allowed.has(url.origin);
+	return url.protocol === "https:" || url.protocol === "http:" && Object.hasOwn(LOOPBACK_HOSTS, url.hostname);
+}
+function tokenMatches(given, expected) {
+	if (given === void 0) return false;
+	const a = Buffer.from(given);
+	const b = Buffer.from(expected);
+	return a.length === b.length && timingSafeEqual(a, b);
+}
+function header(req, name) {
+	const value = req.headers[name];
+	const first = Array.isArray(value) ? value[0] : value;
+	return first === void 0 || first === "" ? void 0 : first;
+}
+function forwardRequestHeaders(incoming) {
+	const out = new Headers();
+	for (const [name, value] of Object.entries(incoming)) {
+		if (value === void 0 || name.startsWith("x-skaile-transform-") || Object.hasOwn(REQUEST_SKIP, name)) continue;
+		for (const item of Array.isArray(value) ? value : [value]) out.append(name, item);
+	}
+	out.set("accept-encoding", "identity");
+	return out;
+}
+function relayHeaders(headers) {
+	const out = {};
+	headers.forEach((value, name) => {
+		if (!Object.hasOwn(RESPONSE_SKIP, name)) out[name] = value;
+	});
+	const cookies = headers.getSetCookie();
+	if (cookies.length > 0) out["set-cookie"] = cookies;
+	return out;
+}
+async function readBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks);
+}
+/** Streams an SSE body through the transformer, chunk by chunk, decoding UTF-8 across chunk boundaries. */
+async function pipeStream(res, upstreamRes, headers, transformer, log) {
+	res.writeHead(upstreamRes.status, headers);
+	const reader = upstreamRes.body?.getReader();
+	if (reader === void 0) {
+		res.end();
+		return;
+	}
+	const decoder = new TextDecoder();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			await writeText(res, transformer.push(decoder.decode(value, { stream: true })));
+			if (res.destroyed) {
+				await reader.cancel();
+				return;
+			}
+		}
+		await writeText(res, transformer.push(decoder.decode()) + transformer.flush());
+		res.end();
+	} catch (err) {
+		log.error(`stream relay failed: ${errorMessage(err)}`);
+		res.destroy();
+	}
+}
+function writeText(res, text) {
+	if (text === "" || res.write(text)) return Promise.resolve();
+	const drained = Promise.withResolvers();
+	const done = () => {
+		res.off("drain", done);
+		res.off("close", done);
+		drained.resolve();
+	};
+	res.once("drain", done);
+	res.once("close", done);
+	return drained.promise;
+}
+/** Writes the error envelope `{ error: { type, message } }`. */
+function sendError(res, status, type, message) {
+	if (res.headersSent) {
+		res.destroy();
+		return;
+	}
+	res.writeHead(status, { "content-type": "application/json" });
+	res.end(JSON.stringify({ error: {
+		type,
+		message
+	} }));
+}
+// src/config.ts
+const CONFIG_FILE_NAME = "transform-proxy.yaml";
+/** The implicit lookup locations, in order: `./.skaile/` then `~/.config/skaile/`. */
+function configCandidates(cwd, home) {
+	return [join(cwd, ".skaile", CONFIG_FILE_NAME), join(home, ".config", "skaile", CONFIG_FILE_NAME)];
+}
+/**
+* Finds the config file: the explicit path when given (it must exist), otherwise the first
+* existing implicit candidate. Returns `undefined` when no implicit candidate exists.
+*/
+function findProxyConfig(lookup) {
+	if (lookup.explicit !== void 0) {
+		const path = resolve(lookup.cwd, lookup.explicit);
+		if (!existsSync(path)) throw new Error(`transform proxy config not found: ${path}`);
+		return path;
+	}
+	return configCandidates(lookup.cwd, lookup.home).find((candidate) => existsSync(candidate));
+}
+/** Finds and loads the config. Throws, naming the searched paths, when none is found. */
+function resolveProxyConfig(lookup) {
+	const path = findProxyConfig(lookup);
+	if (path === void 0) {
+		const searched = configCandidates(lookup.cwd, lookup.home).join(", ");
+		throw new Error(`no transform proxy config found (pass --config, or create one at ${searched})`);
+	}
+	return {
+		path,
+		options: loadProxyConfig(path)
+	};
+}
+const TOP_LEVEL_KEYS = {
+	transforms: true,
+	pipelines: true,
+	defaultPipeline: true,
+	allowUpstreams: true
+};
+/** Reads and validates a YAML config file. Unknown keys are rejected so that typos fail loudly. */
+function loadProxyConfig(path) {
+	const source = parse(readFileSync(path, "utf8"));
+	try {
+		return parseProxyConfig(source ?? {}, dirname(path));
+	} catch (err) {
+		throw new Error(`invalid transform proxy config ${path}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+	}
+}
+/** Validates an already-parsed config object. Exported for hosts that load YAML themselves. */
+function parseProxyConfig(source, baseDir) {
+	if (!isRecord(source)) throw new Error("the document must be a mapping");
+	for (const key of Object.keys(source)) if (!Object.hasOwn(TOP_LEVEL_KEYS, key)) throw new Error(`unknown key "${key}"`);
+	return {
+		baseDir,
+		transforms: parseTransforms(source.transforms),
+		pipelines: parsePipelines(source.pipelines),
+		...source.defaultPipeline === void 0 ? {} : { defaultPipeline: requireString(source.defaultPipeline, "defaultPipeline") },
+		...source.allowUpstreams === void 0 ? {} : { allowUpstreams: requireStringList(source.allowUpstreams, "allowUpstreams") }
+	};
+}
+function parseTransforms(value) {
+	if (value === void 0) return {};
+	if (!isRecord(value)) throw new Error("transforms must be a mapping of transform id to { module, config }");
+	const out = {};
+	for (const [id, spec] of Object.entries(value)) {
+		if (!isRecord(spec)) throw new Error(`transforms.${id} must be a mapping with a module`);
+		const module = requireString(spec.module, `transforms.${id}.module`);
+		out[id] = spec.config === void 0 ? { module } : {
+			module,
+			config: spec.config
+		};
+	}
+	return out;
+}
+function parsePipelines(value) {
+	if (value === void 0) return {};
+	if (!isRecord(value)) throw new Error("pipelines must be a mapping of pipeline id to a list of transform ids");
+	const out = {};
+	for (const [id, stages] of Object.entries(value)) out[id] = requireStringList(stages, `pipelines.${id}`);
+	return out;
+}
+function requireString(value, field) {
+	if (typeof value !== "string" || value === "") throw new Error(`${field} must be a non-empty string`);
+	return value;
+}
+function requireStringList(value, field) {
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item === "")) throw new Error(`${field} must be a list of non-empty strings`);
+	return value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export { composeTransforms as _, parseProxyConfig as a, SESSION_HEADER as c, createTransformProxy as d, openaiResponsesWalker as f, createSessionFacts as g, UnsupportedContentError as h, loadProxyConfig as i, TOKEN_HEADER as l, anthropicWalker as m, configCandidates as n, resolveProxyConfig as o, openaiChatWalker as p, findProxyConfig as r, PIPELINE_HEADER as s, CONFIG_FILE_NAME as t, UPSTREAM_HEADER as u, errorMessage as v, silentLogger as y };