@code-yeongyu/senpi-ai 2026.10.18 → 2026.10.19

package/dist/types.d.ts

@@ -1008,6 +1008,12 @@ export interface AnthropicMessagesCompat {
      * the payload. Default: true only for the first-party Anthropic endpoint.
      */
     supportsWebSearch?: boolean;
+    /**
+     * Whether request bodies of 4096+ characters are sent with `Content-Encoding: gzip`. A refused encoding
+     * (415, a proxy's 400/403, or the origin failing to parse the body) is resent uncompressed once and that
+     * origin stays uncompressed for the process. Default: true only for the first-party Anthropic endpoint.
+     */
+    supportsGzipRequestBody?: boolean;
 }
 /** Compatibility settings for Amazon Bedrock models. */
 export interface BedrockCompat {

package/dist/utils/gzip-request-body.d.ts

@@ -0,0 +1,11 @@
+export declare const GZIP_REQUEST_BODY_MIN_CHARS = 4096;
+type Fetch = typeof globalThis.fetch;
+/**
+ * Wraps `fetch` so request bodies of at least {@link GZIP_REQUEST_BODY_MIN_CHARS} characters go out with
+ * `Content-Encoding: gzip`. The JSON gets random trailing whitespace before compression so the encrypted
+ * length does not reveal how well the content compressed. When an origin refuses the encoding, the same
+ * request is resent uncompressed and that origin stays uncompressed for the rest of the process.
+ */
+export declare function withGzipRequestBodies(baseFetch?: Fetch): Fetch;
+export {};
+//# sourceMappingURL=gzip-request-body.d.ts.map

package/dist/utils/gzip-request-body.js

@@ -0,0 +1,108 @@
+export const GZIP_REQUEST_BODY_MIN_CHARS = 4096;
+const REJECTION_BODY_READ_LIMIT = 8192;
+const MAX_LENGTH_PADDING = 256;
+// The messages Anthropic returns when it could not decode a body as JSON; Claude Code 2.1.302 matches the same
+// two strings to detect a refused gzip body.
+const ORIGIN_JSON_PARSE_FAILURES = [
+    "The request body is not valid JSON",
+    "Failed to parse request: could not parse request body as JSON",
+];
+const wrappedFetches = new WeakMap();
+const uncompressedOrigins = new Set();
+function loadNodeZlib() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun))
+        return undefined;
+    return process.getBuiltinModule?.("node:zlib");
+}
+function originOf(input) {
+    const url = input instanceof Request ? input.url : String(input);
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return url;
+    }
+}
+function lengthPadding() {
+    const count = Math.floor(Math.random() * (MAX_LENGTH_PADDING + 1));
+    let padding = "\n";
+    for (let index = 0; index < count; index++)
+        padding += Math.random() < 0.5 ? " " : "\t";
+    return padding;
+}
+async function readBodyPrefix(response) {
+    const reader = response.clone().body?.getReader();
+    if (!reader)
+        return "";
+    const decoder = new TextDecoder();
+    let text = "";
+    try {
+        while (text.length < REJECTION_BODY_READ_LIMIT) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            text += decoder.decode(value, { stream: true });
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    return text;
+}
+function isFromAnthropic(response) {
+    return response.headers.get("request-id")?.startsWith("req_") === true;
+}
+/**
+ * Whether a non-OK answer to a gzip request means the body encoding itself was refused: a 415, a 400/403
+ * from a hop that is not Anthropic (a proxy that cannot decode it), or Anthropic reporting that it could
+ * not parse the body as JSON. Other API errors (bad request, rate limits, auth) are returned as they are.
+ * A misfire (an unrelated proxy 400/403) costs one uncompressed resend of a request that was never processed
+ * and turns gzip off for that origin; it cannot double-bill.
+ */
+async function isGzipRejection(response) {
+    if (response.status === 415)
+        return true;
+    if (response.status !== 400 && response.status !== 403)
+        return false;
+    if (!isFromAnthropic(response))
+        return true;
+    if (response.status !== 400)
+        return false;
+    const body = await readBodyPrefix(response);
+    return ORIGIN_JSON_PARSE_FAILURES.some((message) => body.includes(message));
+}
+/**
+ * Wraps `fetch` so request bodies of at least {@link GZIP_REQUEST_BODY_MIN_CHARS} characters go out with
+ * `Content-Encoding: gzip`. The JSON gets random trailing whitespace before compression so the encrypted
+ * length does not reveal how well the content compressed. When an origin refuses the encoding, the same
+ * request is resent uncompressed and that origin stays uncompressed for the rest of the process.
+ */
+export function withGzipRequestBodies(baseFetch = globalThis.fetch) {
+    const existing = wrappedFetches.get(baseFetch);
+    if (existing)
+        return existing;
+    const zlib = loadNodeZlib();
+    const wrapped = async (input, init) => {
+        const body = init?.body;
+        const origin = originOf(input);
+        if (zlib === undefined ||
+            typeof body !== "string" ||
+            body.length < GZIP_REQUEST_BODY_MIN_CHARS ||
+            uncompressedOrigins.has(origin)) {
+            return baseFetch(input, init);
+        }
+        const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+        headers.set("content-encoding", "gzip");
+        headers.delete("content-length");
+        const compressed = zlib.gzipSync(body + lengthPadding());
+        const response = await baseFetch(input, { ...init, headers, body: new Uint8Array(compressed) });
+        if (response.ok || !(await isGzipRejection(response)))
+            return response;
+        uncompressedOrigins.add(origin);
+        await response.body?.cancel();
+        return baseFetch(input, init);
+    };
+    wrappedFetches.set(baseFetch, wrapped);
+    return wrapped;
+}
+//# sourceMappingURL=gzip-request-body.js.map

package/dist/utils/prompt-cache-ttl.js

@@ -81,6 +81,7 @@ export function getAnthropicCompat(model) {
         // blocks on the next request (kimi-coding 400s with `tool_call_id is not
         // found`).
         supportsWebSearch: model.compat?.supportsWebSearch ?? isAnthropicApiBaseUrl(model.baseUrl),
+        supportsGzipRequestBody: model.compat?.supportsGzipRequestBody ?? isAnthropicApiBaseUrl(model.baseUrl),
     };
 }
 /**

package/dist/utils/provider-failure-description.d.ts

@@ -1,4 +1,9 @@
 import { type ProviderStallDescriptionOptions } from "./retry.ts";
+/**
+ * Opens the sentence an adapter adds when its own account-limit text already names the next step
+ * (senpi#3615). Such text is shown as written instead of the generic switch-provider advice.
+ */
+export declare const ACCOUNT_LIMIT_NEXT_STEP_LEAD = "To keep going now, ";
 /**
  * Session-internal replay-suppression signal, read off the error text by the
  * retry predicates. A failover lane stamps it when replaying the turn could

package/dist/utils/provider-failure-description.js

@@ -1,5 +1,11 @@
 import { describeProviderStallForUser, formatStallDuration, isAnthropicThirdPartyBillingMessage, } from "./retry.js";
 const CLAUDE_EXTRA_USAGE_URL = "https://claude.ai/settings/usage";
+/**
+ * Opens the sentence an adapter adds when its own account-limit text already names the next step
+ * (senpi#3615). Such text is shown as written instead of the generic switch-provider advice.
+ */
+export const ACCOUNT_LIMIT_NEXT_STEP_LEAD = "To keep going now, ";
+const RETRY_AFTER_MARKER = /\s*\(retry-after-ms: \d+\)$/;
 /**
  * senpi#3259: the billing path is the whole story. On the direct `anthropic` provider a Claude
  * subscription token is billed as a third-party app, so the fix is the Agent SDK lane; on the
@@ -61,6 +67,8 @@ export function describeProviderFailureForUser(errorMessage, options = {}) {
         return describeAnthropicThirdPartyBilling(options.model?.split("/")[0]);
     }
     if (options.usageLimit === "account") {
+        if (message.includes(ACCOUNT_LIMIT_NEXT_STEP_LEAD))
+            return message.replace(RETRY_AFTER_MARKER, "");
         const provider = options.model?.split("/")[0];
         const reset = /\bresets?\s+([^"}\n]+)/i
             .exec(message)?.[1]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.10.18",
+	"version": "2026.10.19",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -88,7 +88,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "0.127.0",
 		"@aws-sdk/client-bedrock-runtime": "3.1136.0",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.18",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.19",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"google-auth-library": "10.6.2",