@oh-my-pi/pi-ai 18.12.0 → 18.12.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [18.12.1] - 2026-10-17
+
+### Fixed
+
+- Fixed every request failing behind a TLS-inspecting proxy that refuses compressed uploads: a 400/403/415 whose body is not JSON, or the Anthropic API's "request body is not valid JSON" after a proxy drops `Content-Encoding`, now resends the body uncompressed and stops compressing for that host ([#16108](https://github.com/can1357/oh-my-pi/pull/16108) by [@alphastorm](https://github.com/alphastorm))
+
 ## [18.12.0] - 2026-10-17
 
 ### Breaking Changes
@@ -2336,25 +2342,4 @@
 
 - Removed the `partial-json` dependency; streaming JSON parsing now uses the in-house `RelaxedJson` parser.
 
-## [16.1.9] - 2026-06-21
-
-### Added
-
-- Added `llama.cpp` to the interactive `/login` provider list, accepting an optional API key while defaulting to local no-auth mode.
-
-### Changed
-
-- Optimized generated AI tool schemas by collapsing verbose `anyOf` unions into standard `enum` types
-
-### Fixed
-
-- Fixed tool-call argument validation dropping nested keys that were accidentally double-encoded
-- Fixed the `moonshot` provider being locked to the international Kimi host (`api.moonshot.ai`): OpenAI-completions requests now honor a `MOONSHOT_BASE_URL` override so users can reach the Kimi China platform (`api.moonshot.cn`), which rejects keys issued for the international endpoint. ([#2883](https://github.com/can1357/oh-my-pi/issues/2883))
-- Fixed tool-call argument validation dropping fields whose object keys were accidentally JSON-encoded a second time (e.g. `{ "\"op\"": "done" }`), which surfaced as spurious missing-required errors. A schema-agnostic pre-validation pass now recursively unwraps such double-encoded keys — through arrays and nested objects, and again after a JSON-string container is parsed — before the unrecognized-key repair can delete them.
-
-### Removed
-
-- Removed the `setNextRequestDebugPath`, `clearNextRequestDebugPath`, and `getNextRequestDebugPath` utility functions for request debugging, as request/response recording now relies exclusively on the `PI_REQ_DEBUG` environment variable.
-- Removed Wafer Pass (`wafer-pass`) login support; Wafer Serverless remains available as `wafer-serverless`.
-
-Older entries are archived in [packages/ai/CHANGELOG.md@50ec66f75d57](https://github.com/can1357/oh-my-pi/blob/50ec66f75d57ad55838a9fe4da5e66f29af4d73c/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@bb602d67c9b6](https://github.com/can1357/oh-my-pi/blob/bb602d67c9b685535bbf8ef1a1cc9de3c944ede4/packages/ai/CHANGELOG.md).

package/dist/types/utils/request-compression.d.ts

@@ -9,10 +9,13 @@ import type { FetchImpl, Model } from "../types.js";
  * Install it beneath any body rewriter or signer (e.g. the cch attestation
  * patch): those must see the uncompressed bytes. Other hosts, small bodies,
  * bodies that already carry `Content-Encoding`, and `PI_REQUEST_COMPRESSION=0`
- * pass through untouched. A possible rejection is resent uncompressed once;
- * only when that resend succeeds is the encoding latched off for the host, so
- * a genuine 400 never disables compression.
+ * pass through untouched. A possible rejection — the host's decode error, or a
+ * non-JSON 400/403/415 from a proxy in front of it — is resent uncompressed
+ * once; only when that resend succeeds is the encoding latched off for the
+ * host, so a genuine 400 never disables compression. When a non-JSON refusal
+ * recurs uncompressed with the same status and a non-JSON body, that status
+ * stops being re-checked for the host.
  */
 export declare function wrapFetchForRequestCompression(base: FetchImpl, model: Model): FetchImpl;
-/** Test hook: clears every per-host rejection latch. */
+/** Test hook: clears every per-host latch. */
 export declare function resetRequestCompressionForTesting(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.12.0",
+	"version": "18.12.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.12.0",
-		"@oh-my-pi/pi-catalog": "18.12.0",
-		"@oh-my-pi/pi-natives": "18.12.0",
-		"@oh-my-pi/pi-utils": "18.12.0",
-		"@oh-my-pi/pi-wire": "18.12.0"
+		"@oh-my-pi/omptype": "18.12.1",
+		"@oh-my-pi/pi-catalog": "18.12.1",
+		"@oh-my-pi/pi-natives": "18.12.1",
+		"@oh-my-pi/pi-utils": "18.12.1",
+		"@oh-my-pi/pi-wire": "18.12.1"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/utils/request-compression.ts

@@ -32,6 +32,17 @@ const ZSTD_LEVEL = 3;
  */
 const rejectedEncodings = new Set<string>();
 
+/**
+ * `<origin> <status>` pairs where a non-JSON refusal of a compressed body
+ * recurred on the uncompressed resend: something in front of the host refuses
+ * every request (a blocking proxy, an edge challenge), not the encoding. Later
+ * refusals with that status skip the resend instead of doubling each attempt.
+ */
+const encodingUnrelatedRefusals = new Set<string>();
+
+/** Why a failed compressed request may be an encoding rejection. */
+type RejectionSuspect = "host" | "proxy";
+
 type RequestHeaders = RequestInit["headers"];
 
 function requestUrl(input: string | URL | Request): string | undefined {
@@ -67,16 +78,43 @@ function compress(body: string | ArrayBufferView, encoding: RequestBodyEncoding)
 	return encoding === "zstd" ? Bun.zstdCompress(bytes, { level: ZSTD_LEVEL }) : gzip(bytes, { level: GZIP_LEVEL });
 }
 
-async function mayBeEncodingRejection(response: Response, policy: RequestCompressionPolicy): Promise<boolean> {
-	if (response.status !== 400 && response.status !== 415) return false;
-	if (!policy.rejection) return true;
+/** Reads a clone of {@link response}'s body; `undefined` when it cannot be read. */
+async function bodyText(response: Response): Promise<string | undefined> {
 	try {
-		return policy.rejection.test(await response.clone().text());
+		return await response.clone().text();
+	} catch {
+		return undefined;
+	}
+}
+
+function isJson(text: string): boolean {
+	try {
+		JSON.parse(text);
+		return true;
 	} catch {
 		return false;
 	}
 }
 
+/**
+ * `host`: a JSON 400/415 matching the host's rejection pattern (or any JSON
+ * 400/415 when none is assigned). `proxy`: a 400/403/415 whose body is not JSON,
+ * empty included — provider APIs answer errors in JSON, so the body is presumed
+ * to come from a proxy or TLS-inspecting gateway that may refuse a compressed
+ * upload the host itself decodes.
+ */
+async function suspectEncodingRejection(
+	response: Response,
+	policy: RequestCompressionPolicy,
+): Promise<RejectionSuspect | undefined> {
+	if (response.status !== 400 && response.status !== 403 && response.status !== 415) return undefined;
+	const body = await bodyText(response);
+	if (body === undefined) return undefined;
+	if (!isJson(body)) return "proxy";
+	if (response.status === 403) return undefined;
+	return (policy.rejection?.test(body) ?? true) ? "host" : undefined;
+}
+
 /**
  * Compresses request bodies from {@link model} to its provider's own endpoint
  * when its catalog rules declare encodings the endpoint decodes
@@ -87,9 +125,12 @@ async function mayBeEncodingRejection(response: Response, policy: RequestCompres
  * Install it beneath any body rewriter or signer (e.g. the cch attestation
  * patch): those must see the uncompressed bytes. Other hosts, small bodies,
  * bodies that already carry `Content-Encoding`, and `PI_REQUEST_COMPRESSION=0`
- * pass through untouched. A possible rejection is resent uncompressed once;
- * only when that resend succeeds is the encoding latched off for the host, so
- * a genuine 400 never disables compression.
+ * pass through untouched. A possible rejection — the host's decode error, or a
+ * non-JSON 400/403/415 from a proxy in front of it — is resent uncompressed
+ * once; only when that resend succeeds is the encoding latched off for the
+ * host, so a genuine 400 never disables compression. When a non-JSON refusal
+ * recurs uncompressed with the same status and a non-JSON body, that status
+ * stops being re-checked for the host.
  */
 export function wrapFetchForRequestCompression(base: FetchImpl, model: Model): FetchImpl {
 	const wrapped: FetchImpl = async (input, init) => {
@@ -128,7 +169,10 @@ export function wrapFetchForRequestCompression(base: FetchImpl, model: Model): F
 			body: compressed,
 			headers: withContentEncoding(init?.headers, encoding),
 		});
-		if (!(await mayBeEncodingRejection(response, policy))) return response;
+		const suspect = await suspectEncodingRejection(response, policy);
+		if (!suspect) return response;
+		const refusal = `${origin} ${response.status}`;
+		if (suspect === "proxy" && encodingUnrelatedRefusals.has(refusal)) return response;
 
 		await response.body?.cancel().catch(() => {});
 		const plain = await base(input, init);
@@ -139,6 +183,11 @@ export function wrapFetchForRequestCompression(base: FetchImpl, model: Model): F
 				encoding,
 				status: response.status,
 			});
+		} else if (suspect === "proxy" && plain.status === response.status) {
+			// A JSON body means the resend reached the provider; its own error says
+			// nothing about whether the proxy refuses every request.
+			const plainBody = await bodyText(plain);
+			if (plainBody !== undefined && !isJson(plainBody)) encodingUnrelatedRefusals.add(refusal);
 		}
 		return plain;
 	};
@@ -146,7 +195,8 @@ export function wrapFetchForRequestCompression(base: FetchImpl, model: Model): F
 	return wrapped;
 }
 
-/** Test hook: clears every per-host rejection latch. */
+/** Test hook: clears every per-host latch. */
 export function resetRequestCompressionForTesting(): void {
 	rejectedEncodings.clear();
+	encodingUnrelatedRefusals.clear();
 }