proxitor 0.17.0 → 0.18.0

package/README.md

@@ -197,6 +197,8 @@ 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: auto` (the default) tags them, lifts `role:"system"` into `instructions`, and adds the `id`/`status` OpenRouter wants on assistant history. Set it to `skip` only for raw passthrough.
+
 **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,7 @@ const modelOverrideSchema = object({
 	cacheControlTtl: ttlSchema.optional(),
 	rewriteBlockTtl: triStateSchema.optional(),
 	sessionId: triStateSchema.optional(),
+	normalizeResponses: triStateSchema.optional(),
 	normalizeVolatileSystem: boolean().optional()
 }).strict();
 const proxyConfigSchema = object({
@@ -16312,6 +16313,7 @@ const proxyConfigSchema = object({
 	cacheControlTtl: ttlSchema.optional(),
 	rewriteBlockTtl: triStateSchema.default("skip"),
 	sessionId: triStateSchema.default("auto"),
+	normalizeResponses: triStateSchema.default("auto"),
 	normalizeVolatileSystem: boolean().default(false),
 	observability: observabilityConfigSchema,
 	modelOverrides: record(string$1().min(1), modelOverrideSchema).optional()
@@ -16488,6 +16490,7 @@ function resolveModelConfig(config, modelName) {
 		cacheControlTtl: config.cacheControlTtl,
 		rewriteBlockTtl: config.rewriteBlockTtl,
 		sessionId: config.sessionId,
+		normalizeResponses: config.normalizeResponses,
 		normalizeVolatileSystem: config.normalizeVolatileSystem
 	};
 	if (!modelName || !config.modelOverrides) return result;
@@ -16521,6 +16524,7 @@ 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.normalizeVolatileSystem !== void 0) result.normalizeVolatileSystem = override.normalizeVolatileSystem;
 }
 /** Reject base URLs ending in /v1 — paths are forwarded as-is, so /v1 suffix causes doubled paths. */
@@ -16822,11 +16826,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 +18123,12 @@ const REWRITE_HINTS = {
 	always: "All models",
 	skip: "Leave client block ttl as-is (may mismatch root)"
 };
+/** Shared hint texts for the normalize-responses tri-state — used in the Fixes menu + override editor. */
+const NORMALIZE_RESPONSES_HINTS = {
+	auto: "/v1/responses only (default)",
+	always: "All endpoints",
+	skip: "Off — raw passthrough (OpenRouter may reject)"
+};
 const NORMALIZE_HINTS = {
 	on: "Rewrite cch → stable prefix cache",
 	off: "Passthrough — rewrite nothing"
@@ -18223,6 +18233,12 @@ async function collectSessionTriState(currentSid) {
 	if (sid === "reset") return { sessionId: { remove: true } };
 	return { sessionId: { value: sid } };
 }
+async function collectNormalizeResponsesTriState(currentNr) {
+	const nr = await askTriState("normalizeResponses mode", currentNr, NORMALIZE_RESPONSES_HINTS, { removable: true });
+	if (typeof nr === "symbol") return null;
+	if (nr === "reset") return { normalizeResponses: { remove: true } };
+	return { normalizeResponses: { value: nr } };
+}
 /**
 * Collects cacheControl mode, TTL, and rewriteBlockTtl.
 * Mode-cancel aborts; TTL-cancel keeps existing TTL; rewrite-cancel keeps existing rewrite.
@@ -18670,6 +18686,13 @@ async function editSessionId(current) {
 	applyField(next, "sessionId", result.sessionId);
 	return next;
 }
+async function editNormalizeResponses(current) {
+	const result = await collectNormalizeResponsesTriState(current.normalizeResponses);
+	if (result === null) return current;
+	const next = { ...current };
+	applyField(next, "normalizeResponses", result.normalizeResponses);
+	return next;
+}
 async function editCacheControl(current, configPath) {
 	const globalTtl = readGlobalTtl(configPath);
 	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl, current.rewriteBlockTtl);
@@ -18777,6 +18800,83 @@ async function cachingCommand(opts) {
 	outro("Bye!");
 }
 //#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})` : effective}`);
+	const result = await askTriState("normalizeResponses mode", raw, NORMALIZE_RESPONSES_HINTS, { removable: true });
+	if (typeof result === "symbol") return;
+	if (result === "reset") {
+		setGlobalConfigField(configPath, "normalizeResponses", void 0);
+		log.success("normalizeResponses reset to default (auto)");
+		return;
+	}
+	setGlobalConfigField(configPath, "normalizeResponses", result);
+	log.success(`normalizeResponses set to ${result}`);
+}
+//#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)
+}];
+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: () => {
+			return `normalizeResponses: ${readConfigFileRaw(configPath).normalizeResponses ?? "(default → auto)"}`;
+		},
+		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)"}`,
+		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) {
 	if (value === void 0) return "(inherit)";
@@ -18792,12 +18892,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.normalizeResponses) parts.push(`fix: ${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)}`;
 }
+function formatFixesHint(current) {
+	return `normalizeResponses: ${current.normalizeResponses ?? "inherit"}`;
+}
 async function editProvider(modelKey, current, client) {
 	const isPattern = modelKey.includes("*");
 	const mode = await selectRoutingMode("Routing mode");
@@ -18851,6 +18955,11 @@ async function editOverrideCommand(client, configPath) {
 					label: "💾 Caching",
 					hint: formatCachingHint(current)
 				},
+				{
+					value: "fixes",
+					label: "🛠 Fixes",
+					hint: formatFixesHint(current)
+				},
 				{
 					value: "done",
 					label: "✓ Done"
@@ -18866,6 +18975,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 +19610,10 @@ async function runConfigMenu(client) {
 					value: "caching",
 					label: "💾  Caching"
 				},
+				{
+					value: "fixes",
+					label: "🛠  Fixes"
+				},
 				{
 					value: "_sep2",
 					label: "── Model Overrides ──",
@@ -19547,6 +19668,9 @@ async function runConfigMenu(client) {
 			case "caching":
 				await globalCachingMenu();
 				break;
+			case "fixes":
+				await globalFixesMenu();
+				break;
 			case "add":
 				await addOverrideCommand({ client });
 				break;
@@ -19570,7 +19694,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.17.0";
+const version = "0.18.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -23426,7 +23550,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 +23656,105 @@ const injectSessionId = createMiddleware(async (c, next) => {
 	await next();
 });
 //#endregion
+//#region src/proxy/utils/responses-input.ts
+/**
+* Whether to normalize a Responses-api body. Mirrors the other tri-states:
+* `auto` acts only on /v1/responses, `always` acts everywhere, `skip` never.
+*/
+function shouldNormalizeResponses(mode, path) {
+	if (mode === "skip") return false;
+	if (mode === "always") return true;
+	return 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
@@ -23844,6 +24072,7 @@ const injectChain = [
 	injectProvider,
 	injectCacheControl,
 	normalizeVolatileSystemMiddleware,
+	normalizeResponsesInputMiddleware,
 	injectSessionId
 ];
 function createProxyServer(source, onReady) {
@@ -24075,6 +24304,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)",