proxitor 0.18.0 → 0.19.1

package/README.md

@@ -197,7 +197,9 @@ 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.
+**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.
 

package/dist/cli.mjs

@@ -16293,7 +16293,8 @@ const modelOverrideSchema = object({
 	cacheControlTtl: ttlSchema.optional(),
 	rewriteBlockTtl: triStateSchema.optional(),
 	sessionId: triStateSchema.optional(),
-	normalizeResponses: triStateSchema.optional(),
+	normalizeResponses: boolean().optional(),
+	normalizeMessages: boolean().optional(),
 	normalizeVolatileSystem: boolean().optional()
 }).strict();
 const proxyConfigSchema = object({
@@ -16313,7 +16314,8 @@ const proxyConfigSchema = object({
 	cacheControlTtl: ttlSchema.optional(),
 	rewriteBlockTtl: triStateSchema.default("skip"),
 	sessionId: triStateSchema.default("auto"),
-	normalizeResponses: 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()
@@ -16491,6 +16493,7 @@ function resolveModelConfig(config, modelName) {
 		rewriteBlockTtl: config.rewriteBlockTtl,
 		sessionId: config.sessionId,
 		normalizeResponses: config.normalizeResponses,
+		normalizeMessages: config.normalizeMessages,
 		normalizeVolatileSystem: config.normalizeVolatileSystem
 	};
 	if (!modelName || !config.modelOverrides) return result;
@@ -16525,6 +16528,7 @@ function applyOverride(result, override) {
 	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. */
@@ -16800,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;
@@ -16809,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;
@@ -16817,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;
@@ -18123,12 +18127,58 @@ 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. */
+/** Hint texts for the normalize-responses on/off toggle — repairs /v1/responses bodies for OpenRouter. */
 const NORMALIZE_RESPONSES_HINTS = {
-	auto: "/v1/responses only (default)",
-	always: "All endpoints",
-	skip: "Off — raw passthrough (OpenRouter may reject)"
+	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"
@@ -18233,12 +18283,18 @@ 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 });
+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.
@@ -18687,12 +18743,19 @@ async function editSessionId(current) {
 	return next;
 }
 async function editNormalizeResponses(current) {
-	const result = await collectNormalizeResponsesTriState(current.normalizeResponses);
+	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);
@@ -18800,21 +18863,40 @@ 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})` : 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}`);
+	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
@@ -18824,6 +18906,11 @@ const FIXES_LEVERS = [{
 	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 (;;) {
@@ -18849,7 +18936,8 @@ async function globalFixesMenu(opts) {
 		noteTitle: "Fixes",
 		backLabel: "← Back",
 		renderNote: () => {
-			return `normalizeResponses: ${readConfigFileRaw(configPath).normalizeResponses ?? "(default → auto)"}`;
+			const raw = readConfigFileRaw(configPath);
+			return [`normalizeResponses: ${raw.normalizeResponses ?? "(default → on)"}`, `normalizeMessages: ${raw.normalizeMessages ?? "(default → off)"}`].join("\n");
 		},
 		onLever: (lever) => lever.global(configPath)
 	});
@@ -18860,7 +18948,7 @@ async function perModelFixesMenu(opts) {
 	await runFixesLeverMenu({
 		noteTitle: `Fixes for "${opts.modelKey}"`,
 		backLabel: "← Back to override edit",
-		renderNote: () => `normalizeResponses: ${current.normalizeResponses ?? "(inherit)"}`,
+		renderNote: () => [`normalizeResponses: ${current.normalizeResponses ?? "(inherit)"}`, `normalizeMessages: ${current.normalizeMessages ?? "(inherit)"}`].join("\n"),
 		onLever: async (lever) => {
 			const next = await lever.perModel(current);
 			if (!overridesEqual(next, current)) {
@@ -18878,7 +18966,7 @@ async function fixesCommand(opts) {
 }
 //#endregion
 //#region src/commands/config/edit.ts
-function nvsHint(value) {
+function toggleHint(value) {
 	if (value === void 0) return "(inherit)";
 	return value ? "on" : "off";
 }
@@ -18891,13 +18979,13 @@ 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.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"}`;
@@ -19694,7 +19782,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.18.0";
+const version = "0.19.1";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -23656,15 +23744,98 @@ 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. Mirrors the other tri-states:
-* `auto` acts only on /v1/responses, `always` acts everywhere, `skip` never.
+* 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(mode, path) {
-	if (mode === "skip") return false;
-	if (mode === "always") return true;
-	return classifyEndpoint(path) === "responses";
+function shouldNormalizeResponses(enabled, path) {
+	return enabled && classifyEndpoint(path) === "responses";
 }
 function isPlainObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -23934,16 +24105,15 @@ var SessionTracker = class {
 };
 //#endregion
 //#region src/proxy/observability/sinks.ts
-const wrap = (code) => (s) => `\x1b[${code}m${s}\x1b[0m`;
-const PAINT = {
-	HIT: wrap("32"),
-	PARTIAL: wrap("33"),
-	MISS: wrap("31"),
-	COLD: wrap("2"),
-	NOUSAGE: wrap("90")
+const STYLE = {
+	HIT: "green",
+	PARTIAL: "yellow",
+	MISS: "red",
+	COLD: "dim",
+	NOUSAGE: "gray"
 };
 function colorizeLabel(label, useColor) {
-	return useColor ? PAINT[label](label) : label;
+	return useColor ? styleText(STYLE[label], label) : label;
 }
 function formatLine(obs, useColor = false) {
 	const { label, hitPct } = obs.outcome;
@@ -24070,6 +24240,7 @@ const injectChain = [
 	parseBody,
 	resolveConfig,
 	injectProvider,
+	normalizeMessagesMiddleware,
 	injectCacheControl,
 	normalizeVolatileSystemMiddleware,
 	normalizeResponsesInputMiddleware,