@skaile/transform-proxy 0.0.0-stage → 0.1.0

package/dist/config-BKD-ILIz.mjs

@@ -0,0 +1,1060 @@
+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 = (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 = (signature) => `anthropic:${signature}`;
+function refuse(block) {
+	if (typeof block.type === "string" && REFUSED_BLOCKS[block.type] === true) throw new UnsupportedContentError(`Anthropic ${block.type} content cannot be transformed`);
+}
+async function outbound(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(transform, content, leaf);
+	if (!Array.isArray(content)) return content;
+	const out = [];
+	for (const block of content) {
+		if (!isObj(block)) {
+			out.push(block);
+			continue;
+		}
+		refuse(block);
+		out.push(block.type === "text" && typeof block.text === "string" ? {
+			...block,
+			text: await outbound(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(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;
+}
+/** Every string leaf of a JSON value, restored inbound. */
+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(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = restoreStrings(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(block.signature));
+		if (cached !== void 0) return {
+			...block,
+			thinking: cached
+		};
+	}
+	if (typeof block.thinking !== "string") return block;
+	return {
+		...block,
+		thinking: await outbound(ctx.transform, block.thinking, { kind: "thinking" })
+	};
+}
+async function rewriteContent(content, role, toolNames, ctx) {
+	const textKind = role === "assistant" ? "assistant" : "user";
+	if (typeof content === "string") return outbound(ctx.transform, content, { kind: textKind });
+	if (!Array.isArray(content)) return content;
+	const out = [];
+	for (const block of content) {
+		if (!isObj(block)) {
+			out.push(block);
+			continue;
+		}
+		refuse(block);
+		switch (block.type) {
+			case "text":
+				out.push(typeof block.text === "string" ? {
+					...block,
+					text: await outbound(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(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(message) || !Array.isArray(message.content)) continue;
+		for (const block of message.content) if (isObj(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(ctx) {
+	const blocks = /* @__PURE__ */ new Map();
+	const handle = (block) => {
+		let payload;
+		try {
+			payload = JSON.parse(block.data);
+		} catch {
+			return block.raw;
+		}
+		if (!isObj(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(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(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(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(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(message) ? {
+				...message,
+				content: await rewriteContent(message.content, message.role, toolNames, ctx)
+			} : message);
+			out.messages = messages;
+		}
+		return out;
+	},
+	response(body, ctx) {
+		if (!isObj(body) || !Array.isArray(body.content)) return body;
+		const content = body.content.map((block) => {
+			if (!isObj(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(block.signature), block.thinking);
+				return {
+					...block,
+					thinking: ctx.transform.inbound(block.thinking)
+				};
+			}
+			if (block.type === "tool_use") return {
+				...block,
+				input: restoreStrings(block.input, ctx.transform)
+			};
+			return block;
+		});
+		return {
+			...body,
+			content
+		};
+	},
+	stream(ctx) {
+		return createStreamTransformer(ctx);
+	}
+};
+// src/routes.ts
+/**
+* The route table. Routes are matched in order, so longer suffixes come first.
+* Add the OpenAI walkers here (`/chat/completions`, `/responses`) when they exist. Until then
+* those paths, and embeddings, answer 404 `unsupported_route`.
+*/
+const WIRE_ROUTES = [{
+	suffix: "/messages/count_tokens",
+	wire: anthropicWalker,
+	rewriteResponse: false
+}, {
+	suffix: "/messages",
+	wire: anthropicWalker,
+	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 { silentLogger as _, parseProxyConfig as a, SESSION_HEADER as c, createTransformProxy as d, anthropicWalker as f, errorMessage as g, composeTransforms as h, loadProxyConfig as i, TOKEN_HEADER as l, createSessionFacts as m, configCandidates as n, resolveProxyConfig as o, UnsupportedContentError as p, findProxyConfig as r, PIPELINE_HEADER as s, CONFIG_FILE_NAME as t, UPSTREAM_HEADER as u };