proxitor 0.17.0 → 0.19.0

package/README.md

@@ -197,6 +197,10 @@ Common flags: `--port`, `--host`, `--config <path>`, `--openrouter-key <key>` /
 
 **Anthropic returns `400` about mixed TTLs when `cacheControlTtl: 1h`.** Set `rewriteBlockTtl: auto` (or `always`) to normalize the client's block-level `cache_control` breakpoints to the same TTL — see the [configuration reference](./docs/configuration.md#prompt-caching).
 
+**OpenRouter returns `400 invalid_prompt | Invalid Responses API request` on `/v1/responses`.** Some clients send Responses `input` items without the `type` field OpenRouter requires. `normalizeResponses: true` (the default; off only for raw passthrough) tags them, lifts `role:"system"` into `instructions`, and adds the `id`/`status` OpenRouter wants on assistant history. It acts on `/v1/responses` only.
+
+**Strict providers reject `role:"system"` inside `/v1/messages`.** Some clients (e.g. an injected `SessionStart` hook payload) place a `role:"system"` item mid-thread in `messages`; the Anthropic Messages API allows only `user`/`assistant` there, so providers like OpenRouter → GLM return `400 ... messages[n].role: Input should be 'user' or 'assistant'`. Enable `normalizeMessages: true` (off by default; Fixes menu or per-model override) to lift each such item's text into the top-level `system` field and drop it from `messages`. It acts on `/v1/messages` only.
+
 **The provider keeps switching between requests.** Make sure `sessionId` is not `skip` — both `auto` (default) and `always` inject a sticky session ID; without it OpenRouter only pins after the first cache hit.
 
 **Config edits don't take effect.** They should — proxitor hot-reloads on save. If the file is invalid the proxy keeps the last valid config; `proxitor config validate` shows what was rejected.

package/dist/cli.mjs

@@ -14,7 +14,7 @@ import { STATUS_CODES, createServer as createServer$1 } from "node:http";
 import { Http2ServerRequest, constants } from "node:http2";
 import { Readable } from "node:stream";
 import { readFile, writeFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -12217,7 +12217,7 @@ const allowsEval = /* @__PURE__*/ cached(() => {
 		return false;
 	}
 });
-function isPlainObject$2(o) {
+function isPlainObject$3(o) {
 	if (isObject(o) === false) return false;
 	const ctor = o.constructor;
 	if (ctor === void 0) return true;
@@ -12228,7 +12228,7 @@ function isPlainObject$2(o) {
 	return true;
 }
 function shallowClone(o) {
-	if (isPlainObject$2(o)) return { ...o };
+	if (isPlainObject$3(o)) return { ...o };
 	if (Array.isArray(o)) return [...o];
 	if (o instanceof Map) return new Map(o);
 	if (o instanceof Set) return new Set(o);
@@ -12311,7 +12311,7 @@ function omit(schema, mask) {
 	}));
 }
 function extend(schema, shape) {
-	if (!isPlainObject$2(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	if (!isPlainObject$3(shape)) throw new Error("Invalid input to extend: expected a plain object");
 	const checks = schema._zod.def.checks;
 	if (checks && checks.length > 0) {
 		const existingShape = schema._zod.def.shape;
@@ -12327,7 +12327,7 @@ function extend(schema, shape) {
 	} }));
 }
 function safeExtend(schema, shape) {
-	if (!isPlainObject$2(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	if (!isPlainObject$3(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
 	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
 		const _shape = {
 			...schema._zod.def.shape,
@@ -13862,7 +13862,7 @@ function mergeValues(a, b) {
 		valid: true,
 		data: a
 	};
-	if (isPlainObject$2(a) && isPlainObject$2(b)) {
+	if (isPlainObject$3(a) && isPlainObject$3(b)) {
 		const bKeys = Object.keys(b);
 		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
 		const newObj = {
@@ -13938,7 +13938,7 @@ const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
 		const input = payload.value;
-		if (!isPlainObject$2(input)) {
+		if (!isPlainObject$3(input)) {
 			payload.issues.push({
 				expected: "record",
 				code: "invalid_type",
@@ -16293,6 +16293,8 @@ const modelOverrideSchema = object({
 	cacheControlTtl: ttlSchema.optional(),
 	rewriteBlockTtl: triStateSchema.optional(),
 	sessionId: triStateSchema.optional(),
+	normalizeResponses: boolean().optional(),
+	normalizeMessages: boolean().optional(),
 	normalizeVolatileSystem: boolean().optional()
 }).strict();
 const proxyConfigSchema = object({
@@ -16312,6 +16314,8 @@ const proxyConfigSchema = object({
 	cacheControlTtl: ttlSchema.optional(),
 	rewriteBlockTtl: triStateSchema.default("skip"),
 	sessionId: triStateSchema.default("auto"),
+	normalizeResponses: boolean().default(true),
+	normalizeMessages: boolean().default(false),
 	normalizeVolatileSystem: boolean().default(false),
 	observability: observabilityConfigSchema,
 	modelOverrides: record(string$1().min(1), modelOverrideSchema).optional()
@@ -16488,6 +16492,8 @@ function resolveModelConfig(config, modelName) {
 		cacheControlTtl: config.cacheControlTtl,
 		rewriteBlockTtl: config.rewriteBlockTtl,
 		sessionId: config.sessionId,
+		normalizeResponses: config.normalizeResponses,
+		normalizeMessages: config.normalizeMessages,
 		normalizeVolatileSystem: config.normalizeVolatileSystem
 	};
 	if (!modelName || !config.modelOverrides) return result;
@@ -16521,6 +16527,8 @@ function applyOverride(result, override) {
 	if (override.cacheControlTtl !== void 0) result.cacheControlTtl = override.cacheControlTtl;
 	if (override.rewriteBlockTtl !== void 0) result.rewriteBlockTtl = override.rewriteBlockTtl;
 	if (override.sessionId !== void 0) result.sessionId = override.sessionId;
+	if (override.normalizeResponses !== void 0) result.normalizeResponses = override.normalizeResponses;
+	if (override.normalizeMessages !== void 0) result.normalizeMessages = override.normalizeMessages;
 	if (override.normalizeVolatileSystem !== void 0) result.normalizeVolatileSystem = override.normalizeVolatileSystem;
 }
 /** Reject base URLs ending in /v1 — paths are forwarded as-is, so /v1 suffix causes doubled paths. */
@@ -16796,7 +16804,7 @@ const LogTypes = {
 	trace: { level: LogLevels.trace },
 	verbose: { level: LogLevels.verbose }
 };
-function isPlainObject$1(value) {
+function isPlainObject$1$1(value) {
 	if (value === null || typeof value !== "object") return false;
 	const prototype = Object.getPrototypeOf(value);
 	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
@@ -16805,7 +16813,7 @@ function isPlainObject$1(value) {
 	return true;
 }
 function _defu(baseObject, defaults, namespace = ".", merger) {
-	if (!isPlainObject$1(defaults)) return _defu(baseObject, {}, namespace, merger);
+	if (!isPlainObject$1$1(defaults)) return _defu(baseObject, {}, namespace, merger);
 	const object = Object.assign({}, defaults);
 	for (const key in baseObject) {
 		if (key === "__proto__" || key === "constructor") continue;
@@ -16813,7 +16821,7 @@ function _defu(baseObject, defaults, namespace = ".", merger) {
 		if (value === null || value === void 0) continue;
 		if (merger && merger(object, key, value, namespace)) continue;
 		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
-		else if (isPlainObject$1(value) && isPlainObject$1(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else if (isPlainObject$1$1(value) && isPlainObject$1$1(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
 		else object[key] = value;
 	}
 	return object;
@@ -16822,11 +16830,11 @@ function createDefu(merger) {
 	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
 }
 const defu = createDefu();
-function isPlainObject(obj) {
+function isPlainObject$2(obj) {
 	return Object.prototype.toString.call(obj) === "[object Object]";
 }
 function isLogObj(arg) {
-	if (!isPlainObject(arg)) return false;
+	if (!isPlainObject$2(arg)) return false;
 	if (!arg.message && !arg.args) return false;
 	if (arg.stack) return false;
 	return true;
@@ -18119,6 +18127,58 @@ const REWRITE_HINTS = {
 	always: "All models",
 	skip: "Leave client block ttl as-is (may mismatch root)"
 };
+/** Hint texts for the normalize-responses on/off toggle — repairs /v1/responses bodies for OpenRouter. */
+const NORMALIZE_RESPONSES_HINTS = {
+	on: "Repair /v1/responses bodies (type tagging, system→instructions, id/status)",
+	off: "Raw passthrough (OpenRouter may reject malformed /v1/responses)"
+};
+async function askNormalizeResponses(message, current, opts) {
+	const options = [{
+		value: true,
+		label: "On",
+		hint: NORMALIZE_RESPONSES_HINTS.on
+	}, {
+		value: false,
+		label: "Off",
+		hint: NORMALIZE_RESPONSES_HINTS.off
+	}];
+	if (opts?.removable) options.push({
+		value: "reset",
+		label: "Reset / inherit",
+		hint: opts.resetHint ?? "Remove override"
+	});
+	return await select({
+		message,
+		initialValue: current ?? (opts?.removable ? "reset" : false),
+		options
+	});
+}
+/** Hint texts for the normalize-messages on/off toggle — lifts stray role:"system" out of /v1/messages. */
+const NORMALIZE_MESSAGES_HINTS = {
+	on: "Lift role:system → top-level system (/v1/messages only)",
+	off: "Raw passthrough (strict providers may reject role:system)"
+};
+async function askNormalizeMessages(message, current, opts) {
+	const options = [{
+		value: true,
+		label: "On",
+		hint: NORMALIZE_MESSAGES_HINTS.on
+	}, {
+		value: false,
+		label: "Off",
+		hint: NORMALIZE_MESSAGES_HINTS.off
+	}];
+	if (opts?.removable) options.push({
+		value: "reset",
+		label: "Reset / inherit",
+		hint: opts.resetHint ?? "Remove override"
+	});
+	return await select({
+		message,
+		initialValue: current ?? (opts?.removable ? "reset" : false),
+		options
+	});
+}
 const NORMALIZE_HINTS = {
 	on: "Rewrite cch → stable prefix cache",
 	off: "Passthrough — rewrite nothing"
@@ -18223,6 +18283,18 @@ async function collectSessionTriState(currentSid) {
 	if (sid === "reset") return { sessionId: { remove: true } };
 	return { sessionId: { value: sid } };
 }
+async function collectNormalizeResponses(currentNr) {
+	const nr = await askNormalizeResponses("Repair /v1/responses bodies", currentNr, { removable: true });
+	if (typeof nr === "symbol") return null;
+	if (nr === "reset") return { normalizeResponses: { remove: true } };
+	return { normalizeResponses: { value: nr } };
+}
+async function collectNormalizeMessages(currentNm) {
+	const nm = await askNormalizeMessages("Lift role:system out of /v1/messages", currentNm, { removable: true });
+	if (typeof nm === "symbol") return null;
+	if (nm === "reset") return { normalizeMessages: { remove: true } };
+	return { normalizeMessages: { value: nm } };
+}
 /**
 * Collects cacheControl mode, TTL, and rewriteBlockTtl.
 * Mode-cancel aborts; TTL-cancel keeps existing TTL; rewrite-cancel keeps existing rewrite.
@@ -18670,6 +18742,20 @@ async function editSessionId(current) {
 	applyField(next, "sessionId", result.sessionId);
 	return next;
 }
+async function editNormalizeResponses(current) {
+	const result = await collectNormalizeResponses(current.normalizeResponses);
+	if (result === null) return current;
+	const next = { ...current };
+	applyField(next, "normalizeResponses", result.normalizeResponses);
+	return next;
+}
+async function editNormalizeMessages(current) {
+	const result = await collectNormalizeMessages(current.normalizeMessages);
+	if (result === null) return current;
+	const next = { ...current };
+	applyField(next, "normalizeMessages", result.normalizeMessages);
+	return next;
+}
 async function editCacheControl(current, configPath) {
 	const globalTtl = readGlobalTtl(configPath);
 	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl, current.rewriteBlockTtl);
@@ -18777,8 +18863,110 @@ async function cachingCommand(opts) {
 	outro("Bye!");
 }
 //#endregion
+//#region src/commands/config/normalize-messages.ts
+async function normalizeMessagesCommand(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	const raw = readConfigFileRaw(configPath).normalizeMessages;
+	const effective = raw ?? DEFAULTS.normalizeMessages;
+	log.info(`Current: normalizeMessages = ${raw === void 0 ? `(default -> ${effective ? "on" : "off"})` : effective}`);
+	const choice = await askNormalizeMessages("Lift stray role:\"system\" out of /v1/messages into top-level system? Fixes 400 rejections from strict Anthropic-format providers (OpenRouter → GLM et al.). Acts on /v1/messages only.", raw, {
+		removable: true,
+		resetHint: `remove (default: ${DEFAULTS.normalizeMessages ? "on" : "off"})`
+	});
+	if (typeof choice === "symbol") return;
+	const fields = {};
+	fields.normalizeMessages = choice === "reset" ? void 0 : choice;
+	setGlobalConfigFields(configPath, fields);
+	const label = choice === "reset" ? `(default: ${DEFAULTS.normalizeMessages})` : choice;
+	log.success(`normalizeMessages set to ${label}`);
+}
+//#endregion
+//#region src/commands/config/normalize-responses.ts
+async function normalizeResponsesCommand(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	const raw = readConfigFileRaw(configPath).normalizeResponses;
+	const effective = raw ?? DEFAULTS.normalizeResponses;
+	log.info(`Current: normalizeResponses = ${raw === void 0 ? `(default -> ${effective ? "on" : "off"})` : effective}`);
+	const choice = await askNormalizeResponses("Repair /v1/responses request bodies for OpenRouter (tag input types, lift role:\"system\" into instructions, synthesize assistant id/status)? Acts on /v1/responses only.", raw, {
+		removable: true,
+		resetHint: `remove (default: ${DEFAULTS.normalizeResponses ? "on" : "off"})`
+	});
+	if (typeof choice === "symbol") return;
+	const fields = {};
+	fields.normalizeResponses = choice === "reset" ? void 0 : choice;
+	setGlobalConfigFields(configPath, fields);
+	const label = choice === "reset" ? `(default: ${DEFAULTS.normalizeResponses})` : choice;
+	log.success(`normalizeResponses set to ${label}`);
+}
+//#endregion
+//#region src/commands/config/fixes-menu.ts
+/** Compatibility fixes for request bodies OpenRouter rejects. Mirrors caching-menu's lever table. */
+const FIXES_LEVERS = [{
+	value: "normalizeResponses",
+	label: "Repair /v1/responses bodies (normalizeResponses)",
+	global: (configPath) => normalizeResponsesCommand({ configPath }),
+	perModel: (current) => editNormalizeResponses(current)
+}, {
+	value: "normalizeMessages",
+	label: "Lift role:system out of /v1/messages (normalizeMessages)",
+	global: (configPath) => normalizeMessagesCommand({ configPath }),
+	perModel: (current) => editNormalizeMessages(current)
+}];
+async function runFixesLeverMenu(opts) {
+	for (;;) {
+		note(opts.renderNote(), opts.noteTitle);
+		const choice = await select({
+			message: "Tune which fix?",
+			options: [...FIXES_LEVERS.map((lever) => ({
+				value: lever.value,
+				label: lever.label
+			})), {
+				value: "back",
+				label: opts.backLabel
+			}]
+		});
+		if (isCancel(choice) || choice === "back") return;
+		const chosen = FIXES_LEVERS.find((l) => l.value === choice);
+		if (chosen) await opts.onLever(chosen);
+	}
+}
+async function globalFixesMenu(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	await runFixesLeverMenu({
+		noteTitle: "Fixes",
+		backLabel: "← Back",
+		renderNote: () => {
+			const raw = readConfigFileRaw(configPath);
+			return [`normalizeResponses: ${raw.normalizeResponses ?? "(default → on)"}`, `normalizeMessages: ${raw.normalizeMessages ?? "(default → off)"}`].join("\n");
+		},
+		onLever: (lever) => lever.global(configPath)
+	});
+}
+/** Self-persists each lever; returns the latest override. */
+async function perModelFixesMenu(opts) {
+	let current = opts.current;
+	await runFixesLeverMenu({
+		noteTitle: `Fixes for "${opts.modelKey}"`,
+		backLabel: "← Back to override edit",
+		renderNote: () => [`normalizeResponses: ${current.normalizeResponses ?? "(inherit)"}`, `normalizeMessages: ${current.normalizeMessages ?? "(inherit)"}`].join("\n"),
+		onLever: async (lever) => {
+			const next = await lever.perModel(current);
+			if (!overridesEqual(next, current)) {
+				setModelOverride(opts.configPath, opts.modelKey, next);
+				current = next;
+			}
+		}
+	});
+	return current;
+}
+async function fixesCommand(opts) {
+	intro("Proxitor · Fixes");
+	await globalFixesMenu(opts);
+	outro("Bye!");
+}
+//#endregion
 //#region src/commands/config/edit.ts
-function nvsHint(value) {
+function toggleHint(value) {
 	if (value === void 0) return "(inherit)";
 	return value ? "on" : "off";
 }
@@ -18791,12 +18979,16 @@ function formatOverrideHint(override) {
 	}
 	if (override.sessionId) parts.push(`session: ${override.sessionId}`);
 	if (override.cacheControl) parts.push(`cache: ${override.cacheControl}`);
-	if (override.normalizeVolatileSystem !== void 0) parts.push(`normalize: ${nvsHint(override.normalizeVolatileSystem)}`);
+	if (override.normalizeVolatileSystem !== void 0) parts.push(`normalize: ${toggleHint(override.normalizeVolatileSystem)}`);
+	if (override.normalizeResponses !== void 0) parts.push(`fix: ${toggleHint(override.normalizeResponses)}`);
 	if (override.headers) parts.push(`${Object.keys(override.headers).length} header(s)`);
 	return parts.join(", ") || "(empty)";
 }
 function formatCachingHint(current) {
-	return `cc ${current.cacheControl ?? "inherit"} · ttl ${current.cacheControlTtl ? describeTtl(current.cacheControlTtl) : "inherit"} · sid ${current.sessionId ?? "inherit"} · nvs ${nvsHint(current.normalizeVolatileSystem)}`;
+	return `cc ${current.cacheControl ?? "inherit"} · ttl ${current.cacheControlTtl ? describeTtl(current.cacheControlTtl) : "inherit"} · sid ${current.sessionId ?? "inherit"} · nvs ${toggleHint(current.normalizeVolatileSystem)}`;
+}
+function formatFixesHint(current) {
+	return `normalizeResponses: ${current.normalizeResponses ?? "inherit"}`;
 }
 async function editProvider(modelKey, current, client) {
 	const isPattern = modelKey.includes("*");
@@ -18851,6 +19043,11 @@ async function editOverrideCommand(client, configPath) {
 					label: "💾 Caching",
 					hint: formatCachingHint(current)
 				},
+				{
+					value: "fixes",
+					label: "🛠 Fixes",
+					hint: formatFixesHint(current)
+				},
 				{
 					value: "done",
 					label: "✓ Done"
@@ -18866,6 +19063,14 @@ async function editOverrideCommand(client, configPath) {
 			});
 			continue;
 		}
+		if (field === "fixes") {
+			current = await perModelFixesMenu({
+				modelKey,
+				current,
+				configPath: resolvedConfigPath
+			});
+			continue;
+		}
 		const before = current;
 		current = await editProvider(modelKey, current, client);
 		if (!overridesEqual(current, before)) setModelOverride(resolvedConfigPath, modelKey, current);
@@ -19493,6 +19698,10 @@ async function runConfigMenu(client) {
 					value: "caching",
 					label: "💾  Caching"
 				},
+				{
+					value: "fixes",
+					label: "🛠  Fixes"
+				},
 				{
 					value: "_sep2",
 					label: "── Model Overrides ──",
@@ -19547,6 +19756,9 @@ async function runConfigMenu(client) {
 			case "caching":
 				await globalCachingMenu();
 				break;
+			case "fixes":
+				await globalFixesMenu();
+				break;
 			case "add":
 				await addOverrideCommand({ client });
 				break;
@@ -19570,7 +19782,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.17.0";
+const version = "0.19.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -23426,7 +23638,12 @@ function rewriteBlockTtls(body, ttl, isAnthropic) {
 	visitBlocks(body.system);
 	visitBlocks(body.tools);
 	const messages = body.messages;
-	for (const m of messages ?? []) visitBlocks(m?.content);
+	for (const m of messages ?? []) {
+		if (m === null || typeof m !== "object" || Array.isArray(m)) continue;
+		rewriteNode(m);
+		visitBlocks(m.content);
+		visitBlocks(m.tool_calls);
+	}
 	return mutated;
 }
 //#endregion
@@ -23527,6 +23744,188 @@ const injectSessionId = createMiddleware(async (c, next) => {
 	await next();
 });
 //#endregion
+//#region src/proxy/utils/messages-system.ts
+/**
+* Whether to lift stray `role:"system"` items out of `messages`. The lift is
+* only valid on `/v1/messages` (where `system` is a top-level field) — never on
+* chat-completions (system belongs in `messages`) or responses — so it is gated
+* by endpoint regardless of the on/off setting.
+*/
+function shouldNormalizeMessages(enabled, path) {
+	return enabled && classifyEndpoint(path) === "messages";
+}
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Flatten a message content value (string or block array) to plain text. */
+function contentToText$1(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return void 0;
+	const parts = [];
+	for (const block of content) {
+		const text = isPlainObject$1(block) ? block.text : void 0;
+		if (typeof text === "string") parts.push(text);
+	}
+	return parts.length > 0 ? parts.join("\n") : void 0;
+}
+/**
+* Append lifted system text to a top-level `system` value, preserving its form:
+* a block array stays an array (new `{type:"text"}` block), a string stays a
+* string, and a missing system starts as a plain string. A stray single-block
+* object (malformed but parseable) is wrapped as a one-element array so its
+* content is never silently discarded.
+*/
+function appendSystemText(current, text) {
+	if (Array.isArray(current)) return [...current, {
+		type: "text",
+		text
+	}];
+	if (typeof current === "string") return current.length > 0 ? `${current}\n\n${text}` : text;
+	if (isPlainObject$1(current)) return [current, {
+		type: "text",
+		text
+	}];
+	return text;
+}
+/**
+* Lift every `role:"system"` item in `messages` into the top-level `system`
+* field. The Anthropic Messages API allows only `user`/`assistant` in
+* `messages` — a stray `role:"system"` (e.g. injected hook output like a
+* SessionStart payload) is rejected by strict Anthropic-format providers
+* (OpenRouter → GLM et al.) with a 400 on `messages[n].role`. System content
+* belongs in the top-level `system`, so its text is merged there and the item
+* is dropped from `messages`, which also preserves user/assistant alternation.
+* Items with no extractable text are dropped. Idempotent; returns whether the
+* body changed.
+*/
+function liftSystemMessages(body) {
+	const messages = body.messages;
+	if (!Array.isArray(messages)) return false;
+	let system = body.system;
+	const next = [];
+	let mutated = false;
+	for (const raw of messages) {
+		if (isPlainObject$1(raw) && raw.role === "system") {
+			const text = contentToText$1(raw.content);
+			if (text !== void 0) system = appendSystemText(system, text);
+			mutated = true;
+			continue;
+		}
+		next.push(raw);
+	}
+	if (mutated) {
+		body.messages = next;
+		if (system !== body.system) body.system = system;
+	}
+	return mutated;
+}
+//#endregion
+//#region src/proxy/middleware/normalize-messages.ts
+/** Lift stray role:"system" items from messages into top-level system (see liftSystemMessages); no-op for non-messages endpoints. */
+const normalizeMessagesMiddleware = createMiddleware(async (c, next) => {
+	const parsedBody = c.var.parsedBody;
+	if (parsedBody && shouldNormalizeMessages(c.var.resolvedConfig.normalizeMessages, c.req.path) && liftSystemMessages(parsedBody)) c.set("bodyMutated", true);
+	await next();
+});
+//#endregion
+//#region src/proxy/utils/responses-input.ts
+/**
+* Whether to normalize a Responses-api body. The lift is only valid on
+* /v1/responses — never on messages or chat-completions — so it is gated by
+* endpoint regardless of the on/off setting.
+*/
+function shouldNormalizeResponses(enabled, path) {
+	return enabled && classifyEndpoint(path) === "responses";
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Flatten a Responses content value (string or block array) to plain text. */
+function contentToText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return void 0;
+	const parts = [];
+	for (const block of content) {
+		const text = isPlainObject(block) ? block.text : void 0;
+		if (typeof text === "string") parts.push(text);
+	}
+	return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function appendInstructions(current, text) {
+	return typeof current === "string" ? `${current}\n\n${text}` : text;
+}
+/** Tag a role-bearing message item and complete assistant-history metadata. */
+function tagMessageItem(obj) {
+	let changed = false;
+	if (typeof obj.role === "string" && obj.type === void 0) {
+		obj.type = "message";
+		changed = true;
+	}
+	if (obj.type === "message" && obj.role === "assistant") {
+		if (obj.id === void 0) {
+			obj.id = `msg_${randomUUID().slice(0, 12)}`;
+			changed = true;
+		}
+		if (obj.status === void 0) {
+			obj.status = "completed";
+			changed = true;
+		}
+	}
+	return changed;
+}
+/**
+* Lift a `role: "system"` item: OpenRouter Responses has no system role in
+* `input`, so its text moves to `instructions`. Items with no extractable text
+* (image-only/empty) can't be represented there and are dropped — keeping them
+* as `role: "system"` would reproduce the rejection this normalizer exists to fix.
+*/
+function handleSystemItem(obj, state) {
+	const text = contentToText(obj.content);
+	if (text !== void 0) state.instructions = appendInstructions(state.instructions, text);
+}
+/**
+* Make a Responses body satisfy OpenRouter's `input` schema. Each item is a
+* `type`-discriminated union, so items missing `type` (OpenAI infers "message")
+* are rejected as `invalid_prompt`. Also relocates `role: "system"` items to
+* `instructions` and synthesizes the `id`/`status` assistant history requires.
+* Idempotent; returns whether the body changed.
+*/
+function normalizeResponsesInput(body) {
+	const input = body.input;
+	if (!Array.isArray(input)) return false;
+	let mutated = false;
+	const state = {
+		instructions: body.instructions,
+		next: []
+	};
+	for (const raw of input) {
+		if (!isPlainObject(raw)) {
+			state.next.push(raw);
+			continue;
+		}
+		if (raw.role === "system") {
+			handleSystemItem(raw, state);
+			mutated = true;
+			continue;
+		}
+		if (tagMessageItem(raw)) mutated = true;
+		state.next.push(raw);
+	}
+	if (mutated) {
+		body.input = state.next;
+		if (state.instructions !== void 0) body.instructions = state.instructions;
+	}
+	return mutated;
+}
+//#endregion
+//#region src/proxy/middleware/normalize-responses-input.ts
+/** Normalize Responses-API input for OpenRouter's schema (see normalizeResponsesInput); no-op for chat/messages. */
+const normalizeResponsesInputMiddleware = createMiddleware(async (c, next) => {
+	const parsedBody = c.var.parsedBody;
+	if (parsedBody && shouldNormalizeResponses(c.var.resolvedConfig.normalizeResponses, c.req.path) && normalizeResponsesInput(parsedBody)) c.set("bodyMutated", true);
+	await next();
+});
+//#endregion
 //#region src/proxy/middleware/normalize-volatile-system.ts
 /** Normalize Claude Code's per-request volatile hashes in system[0] to constants; they drift every turn and break prefix-cache for non-Anthropic providers:
 *  - `cch=…` per-turn hash
@@ -23842,8 +24241,10 @@ const injectChain = [
 	parseBody,
 	resolveConfig,
 	injectProvider,
+	normalizeMessagesMiddleware,
 	injectCacheControl,
 	normalizeVolatileSystemMiddleware,
+	normalizeResponsesInputMiddleware,
 	injectSessionId
 ];
 function createProxyServer(source, onReady) {
@@ -24075,6 +24476,14 @@ const configCli = (0, import_cjs.subcommands)({
 				await cachingCommand({ configPath: args.configPath });
 			}
 		}),
+		fixes: (0, import_cjs.command)({
+			name: "fixes",
+			description: "Tune compatibility fixes (interactive)",
+			args: { ...configArgs },
+			handler: async (args) => {
+				await fixesCommand({ configPath: args.configPath });
+			}
+		}),
 		edit: (0, import_cjs.command)({
 			name: "edit",
 			description: "Edit an existing model override (interactive)",