@skaile/transform-proxy 0.1.0 → 0.2.1

package/dist/{config-BKD-ILIz.mjs → config-Xdn_LYpZ.mjs}

@@ -304,60 +304,60 @@ var UnsupportedContentError = class extends Error {
 	}
 };
 // src/wire/anthropic.ts
-const isObj = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+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 = (signature) => `anthropic:${signature}`;
-function refuse(block) {
+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(transform, text, leaf) {
+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(transform, content, leaf);
+	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(block)) {
+		if (!isObj$2(block)) {
 			out.push(block);
 			continue;
 		}
-		refuse(block);
+		refuse$1(block);
 		out.push(block.type === "text" && typeof block.text === "string" ? {
 			...block,
-			text: await outbound(transform, block.text, leaf)
+			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(value, leaf, transform) {
-	if (typeof value === "string") return outbound(transform, value, leaf);
+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(item, leaf, transform));
+		for (const item of value) out.push(await rewriteStrings$2(item, leaf, transform));
 		return out;
 	}
-	if (isObj(value)) {
+	if (isObj$2(value)) {
 		const out = {};
-		for (const [key, item] of Object.entries(value)) out[key] = await rewriteStrings(item, leaf, transform);
+		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(value, transform) {
+function restoreStrings$1(value, transform) {
 	if (typeof value === "string") return transform.inbound(value);
-	if (Array.isArray(value)) return value.map((item) => restoreStrings(item, transform));
-	if (isObj(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(item, transform);
+		for (const [key, item] of Object.entries(value)) out[key] = restoreStrings$1(item, transform);
 		return out;
 	}
 	return value;
@@ -365,7 +365,7 @@ function restoreStrings(value, transform) {
 /** 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));
+		const cached = ctx.signatures.get(signatureKey$1(block.signature));
 		if (cached !== void 0) return {
 			...block,
 			thinking: cached
@@ -374,25 +374,25 @@ async function rewriteThinking(block, ctx) {
 	if (typeof block.thinking !== "string") return block;
 	return {
 		...block,
-		thinking: await outbound(ctx.transform, block.thinking, { kind: "thinking" })
+		thinking: await outbound$2(ctx.transform, block.thinking, { kind: "thinking" })
 	};
 }
-async function rewriteContent(content, role, toolNames, ctx) {
+async function rewriteContent$2(content, role, toolNames, ctx) {
 	const textKind = role === "assistant" ? "assistant" : "user";
-	if (typeof content === "string") return outbound(ctx.transform, content, { kind: textKind });
+	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(block)) {
+		if (!isObj$2(block)) {
 			out.push(block);
 			continue;
 		}
-		refuse(block);
+		refuse$1(block);
 		switch (block.type) {
 			case "text":
 				out.push(typeof block.text === "string" ? {
 					...block,
-					text: await outbound(ctx.transform, block.text, { kind: textKind })
+					text: await outbound$2(ctx.transform, block.text, { kind: textKind })
 				} : block);
 				break;
 			case "thinking":
@@ -402,7 +402,7 @@ async function rewriteContent(content, role, toolNames, ctx) {
 				const toolName = typeof block.name === "string" ? block.name : void 0;
 				out.push({
 					...block,
-					input: await rewriteStrings(block.input, {
+					input: await rewriteStrings$2(block.input, {
 						kind: "toolCall",
 						toolName
 					}, ctx.transform)
@@ -429,18 +429,23 @@ async function rewriteContent(content, role, toolNames, ctx) {
 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);
+		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;
 }
+/**
+* Appends the instruction after the host's system prompt. Gateways that serve only Claude Code
+* traffic check that the system prompt starts with the Claude Code blocks (TeamClaude answers
+* 429 for Sonnet otherwise), so the host's leading blocks must stay first.
+*/
 function withInstruction(system, instruction) {
 	if (system === void 0) return instruction;
-	if (typeof system === "string") return `${instruction}\n\n${system}`;
-	if (Array.isArray(system)) return [{
+	if (typeof system === "string") return `${system}\n\n${instruction}`;
+	if (Array.isArray(system)) return [...system, {
 		type: "text",
 		text: instruction
-	}, ...system];
+	}];
 	return system;
 }
 function newBlockState(kind, transform) {
@@ -465,7 +470,7 @@ function tailDelta(kind, tail) {
 		partial_json: tail
 	};
 }
-function createStreamTransformer(ctx) {
+function createStreamTransformer$2(ctx) {
 	const blocks = /* @__PURE__ */ new Map();
 	const handle = (block) => {
 		let payload;
@@ -474,12 +479,12 @@ function createStreamTransformer(ctx) {
 		} catch {
 			return block.raw;
 		}
-		if (!isObj(payload)) 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(content)) return block.raw;
+				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));
@@ -489,7 +494,7 @@ function createStreamTransformer(ctx) {
 			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 === 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: {
@@ -508,7 +513,7 @@ function createStreamTransformer(ctx) {
 					});
 				}
 				if (state.kind === "thinking" && delta.type === "signature_delta" && typeof delta.signature === "string") {
-					ctx.signatures.set(signatureKey(delta.signature), state.raw);
+					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, {
@@ -552,31 +557,31 @@ function createStreamTransformer(ctx) {
 }
 const anthropicWalker = {
 	async request(body, ctx) {
-		if (!isObj(body)) return body;
+		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(message) ? {
+			for (const message of body.messages) messages.push(isObj$2(message) ? {
 				...message,
-				content: await rewriteContent(message.content, message.role, toolNames, ctx)
+				content: await rewriteContent$2(message.content, message.role, toolNames, ctx)
 			} : message);
 			out.messages = messages;
 		}
 		return out;
 	},
 	response(body, ctx) {
-		if (!isObj(body) || !Array.isArray(body.content)) return body;
+		if (!isObj$2(body) || !Array.isArray(body.content)) return body;
 		const content = body.content.map((block) => {
-			if (!isObj(block)) return 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(block.signature), block.thinking);
+				if (typeof block.signature === "string") ctx.signatures.set(signatureKey$1(block.signature), block.thinking);
 				return {
 					...block,
 					thinking: ctx.transform.inbound(block.thinking)
@@ -584,7 +589,7 @@ const anthropicWalker = {
 			}
 			if (block.type === "tool_use") return {
 				...block,
-				input: restoreStrings(block.input, ctx.transform)
+				input: restoreStrings$1(block.input, ctx.transform)
 			};
 			return block;
 		});
@@ -593,6 +598,651 @@ const anthropicWalker = {
 			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);
 	}
@@ -600,18 +1250,30 @@ const anthropicWalker = {
 // 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`.
+* 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
-}];
+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" };
@@ -1057,4 +1719,4 @@ function requireStringList(value, field) {
 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 };
+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 };