cartethyia 2.7.9 → 2.8.1

package/src/protocol/response/omp-tool-call-markup.ts

@@ -7,6 +7,7 @@
  * interpreted. Calls are returned only when their names were declared on the
  * request; an undeclared name is never promoted into executable tool input.
  */
+import { MarkupStreamParser } from "../markup-stream-parser";
 export interface OmpTextToolCall {
   readonly id: string;
   readonly name: string;
@@ -29,77 +30,49 @@ const TOOL_NAME_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_.:-]{0,63}$/;
  * The parser holds a possible envelope across SSE deltas, so a split opening
  * tag, argument tag, or closing tag is never emitted as visible prose. At
  * end-of-stream an unterminated envelope is dropped, not executed or leaked.
+ *
+ * The stateful prefix-buffer loop is the shared {@link MarkupStreamParser}
+ * scaffold; this class supplies the OMP grammar as a thin configuration.
  */
 export class OmpToolCallMarkupParser {
-  readonly #allowedNames: ReadonlySet<string>;
-  #pending = "";
-  #callSequence = 0;
+  readonly #parser: MarkupStreamParser<OmpTextToolCall>;
 
   constructor(allowedNames: ReadonlySet<string>) {
-    this.#allowedNames = allowedNames;
+    this.#parser = new MarkupStreamParser<OmpTextToolCall>({
+      openers: [OPEN_PREFIX],
+      classifyOpener: (pending, openIndex) => {
+        const remainder = pending.slice(openIndex);
+        const opening = OPEN_PATTERN.exec(remainder);
+        if (opening === null || opening[1] === undefined) {
+          if (couldBeOpening(remainder)) return { kind: "hold" };
+          return { kind: "literal" };
+        }
+        const marker = opening[1];
+        const closeTag = `</tool_calls:${marker}>`;
+        return {
+          kind: "found",
+          closer: closeTag,
+          parse: (block) => {
+            const parsed = parseEnvelope(block, marker);
+            if (parsed === undefined) return undefined;
+            if (parsed.some((call) => !allowedNames.has(call.name))) {
+              // A syntactically valid call to an undeclared tool is model
+              // text, not authority to invoke a tool the client did not offer.
+              return undefined;
+            }
+            return parsed;
+          },
+          callId: (call, _index, seq) => ({ ...call, id: `call_omp_${marker}_${seq}` }),
+        };
+      },
+      flush: (pending) =>
+        couldBeOpening(pending) || OPEN_PATTERN.test(pending) ? "" : pending,
+    });
   }
 
   /** Feeds one content or reasoning delta and returns only settled text. */
   push(chunk: string): OmpTextToolCallResult {
-    this.#pending += chunk;
-    let cursor = 0;
-    let text = "";
-    const calls: OmpTextToolCall[] = [];
-
-    for (;;) {
-      const openIndex = this.#pending.indexOf(OPEN_PREFIX, cursor);
-      if (openIndex < 0) {
-        const safeEnd = this.#settledEnd(cursor);
-        text += this.#pending.slice(cursor, safeEnd);
-        cursor = safeEnd;
-        break;
-      }
-
-      text += this.#pending.slice(cursor, openIndex);
-      const remainder = this.#pending.slice(openIndex);
-      const opening = OPEN_PATTERN.exec(remainder);
-      if (opening === null || opening[1] === undefined) {
-        if (this.#couldBeOpening(remainder)) {
-          cursor = openIndex;
-          break;
-        }
-        text += "<";
-        cursor = openIndex + 1;
-        continue;
-      }
-
-      const marker = opening[1];
-      const openTag = opening[0];
-      const closeTag = `</tool_calls:${marker}>`;
-      const closeIndex = this.#pending.indexOf(closeTag, openIndex + openTag.length);
-      if (closeIndex < 0) {
-        cursor = openIndex;
-        break;
-      }
-
-      const envelopeEnd = closeIndex + closeTag.length;
-      const block = this.#pending.slice(openIndex, envelopeEnd);
-      const parsed = parseEnvelope(block, marker);
-      if (parsed === undefined) {
-        text += block;
-      } else if (parsed.some((call) => !this.#allowedNames.has(call.name))) {
-        // A syntactically valid call to an undeclared tool is model text, not
-        // authority to invoke a tool the client did not offer.
-        text += block;
-      } else {
-        for (const call of parsed) {
-          calls.push({
-            id: `call_omp_${marker}_${this.#callSequence++}`,
-            name: call.name,
-            arguments: call.arguments,
-          });
-        }
-      }
-      cursor = envelopeEnd;
-    }
-
-    this.#pending = this.#pending.slice(cursor);
-    return { text, calls };
+    return this.#parser.push(chunk);
   }
 
   /**
@@ -107,31 +80,15 @@ export class OmpToolCallMarkupParser {
    * an unfinished envelope is deliberately discarded rather than leaked.
    */
   flush(): OmpTextToolCallResult {
-    const pending = this.#pending;
-    this.#pending = "";
-    if (this.#couldBeOpening(pending) || OPEN_PATTERN.test(pending)) {
-      return { text: "", calls: [] };
-    }
-    return { text: pending, calls: [] };
-  }
-
-  #settledEnd(start: number): number {
-    const remaining = this.#pending.slice(start);
-    const maxPrefixLength = Math.min(OPEN_PREFIX.length - 1, remaining.length);
-    for (let length = maxPrefixLength; length > 0; length -= 1) {
-      if (OPEN_PREFIX.startsWith(remaining.slice(-length))) {
-        return this.#pending.length - length;
-      }
-    }
-    return this.#pending.length;
+    return this.#parser.flush();
   }
+}
 
-  #couldBeOpening(value: string): boolean {
-    if (value.length < OPEN_PREFIX.length) return OPEN_PREFIX.startsWith(value);
-    if (!value.startsWith(OPEN_PREFIX)) return false;
-    const suffix = value.slice(OPEN_PREFIX.length);
-    return /^[0-9a-f]{0,8}$/.test(suffix) || /^[0-9a-f]{8}$/.test(suffix) && !value.endsWith(">");
-  }
+function couldBeOpening(value: string): boolean {
+  if (value.length < OPEN_PREFIX.length) return OPEN_PREFIX.startsWith(value);
+  if (!value.startsWith(OPEN_PREFIX)) return false;
+  const suffix = value.slice(OPEN_PREFIX.length);
+  return /^[0-9a-f]{0,8}$/.test(suffix) || /^[0-9a-f]{8}$/.test(suffix) && !value.endsWith(">");
 }
 
 /**

package/src/protocol/response/responses.ts

@@ -274,7 +274,16 @@ export function parseResponsesResponseToEvents(
     canonicalTerminal({
       sequenceNumber: events.length + 1,
       responseId: id,
-      state: status === "cancelled" ? "aborted" : status === "failed" ? "failed" : "complete",
+      // `incomplete` maps to `aborted` (not `complete`): the surface encoder
+      // turns `aborted` into `response.incomplete`, while `complete` would
+      // emit `response.completed` for a response the upstream declared
+      // unfinished (max output tokens / content filter).
+      state:
+        status === "cancelled" || status === "incomplete"
+          ? "aborted"
+          : status === "failed"
+            ? "failed"
+            : "complete",
       stopReason: respJsonStopReason,
       providerStopReason: respJsonProviderStopReason,
       usage: usageFromProvider(usage),
@@ -740,8 +749,15 @@ export async function* decodeResponsesSseStream(
   const truncated = status === undefined;
   yield canonicalTerminal({
     sequenceNumber: seq++,
+    // `incomplete` maps to `aborted` (not `complete`): the surface encoder
+    // turns `aborted` into `response.incomplete`, while `complete` would
+    // emit `response.completed` for a stream the upstream declared unfinished.
     state:
-      status === "cancelled" ? "aborted" : status === "failed" || truncated ? "failed" : "complete",
+      status === "cancelled" || status === "incomplete"
+        ? "aborted"
+        : status === "failed" || truncated
+          ? "failed"
+          : "complete",
     stopReason: responsesStopReason,
     providerStopReason: responsesProviderStopReason,
     usage: usageFromProvider(rawUsage),

package/src/protocol/stop-reason.ts

@@ -1,4 +1,4 @@
-import type { CanonicalStopReason } from "./canonical-model";
+import type { CanonicalStopReason, CanonicalTerminalEvent } from "./canonical-model";
 
 /**
  * Canonical stop reason mapped onto each surface's wire vocabulary.
@@ -56,6 +56,28 @@ export function chatFinishReason(reason: CanonicalStopReason | undefined): strin
   return canonicalStopReasonToWire("chat", reason, "stop");
 }
 
+/**
+ * Completion's finish_reason, or `null` when the terminal recorded none.
+ *
+ * Completion inherits chat's wire vocabulary (`length`, `content_filter`,
+ * `stop`) but keeps its own convention: a terminal that is not complete
+ * (failed/aborted) already surfaced its failure elsewhere, so it yields
+ * `null` rather than a stop word, and a complete terminal flattens every
+ * reason other than `length`/`content_filter` to `stop`. The sync adapter and
+ * the streaming encoder both derive through this function so the two halves
+ * of the completion surface cannot drift.
+ */
+export function completionFinishReason(
+  reason: CanonicalStopReason | undefined,
+  state: CanonicalTerminalEvent["state"],
+): string | null {
+  if (state !== "complete") return null;
+  if (reason === "length" || reason === "content_filter") {
+    return canonicalStopReasonToWire("chat", reason, "stop");
+  }
+  return "stop";
+}
+
 /** Messages' stop_reason, or `null` when the terminal recorded none. */
 export function messagesStopReason(reason: CanonicalStopReason | undefined): string | null {
   return reason === undefined ? null : canonicalStopReasonToWire("messages", reason, "end_turn");

package/src/protocol/think-split.ts

@@ -152,6 +152,118 @@ function pairedClose(
   return undefined;
 }
 
+/**
+ * Stateful strip of paired thinking tags that preserves source order.
+ *
+ * The reasoning channel (e.g. Chat `reasoning_content`) is one stream where
+ * every byte — tagged or not — is thought. The two-bucket split used by
+ * `ThinkSplitter` (`{ text, reasoning }`) cannot express interleaving, so a
+ * call site that joins `${reasoning}${text}` reorders the stream: untagged
+ * prose that preceded a `<think>` span lands after it. This stripper instead
+ * emits the whole settled content with paired tags removed, in source order,
+ * while keeping `ThinkSplitter`'s stateful guarantees: a tag split across two
+ * deltas is recognized, code spans are left alone, and an unclosed span fails
+ * open at the cap.
+ */
+export class ThinkingTagStripper {
+  #buffer = "";
+  #codeTicks = 0;
+  #codeFenced = false;
+  /** True once an opening tag has been seen and its close has not arrived yet. */
+  #inUnclosedSpan = false;
+  /** The opening tag currently held, restored verbatim on fail-open/flush. */
+  #openMarker = "";
+
+  /** Feeds a chunk; returns settled content with paired tags removed, in order. */
+  push(chunk: string): string {
+    this.#buffer += stripNul(chunk);
+    let out = "";
+    for (;;) {
+      if (this.#inUnclosedSpan) {
+        const closed = this.#findTag(CLOSE_TAGS);
+        if (closed === undefined) break;
+        out += this.#buffer.slice(0, closed.index);
+        this.#buffer = this.#buffer.slice(closed.index + closed.length);
+        this.#codeTicks = closed.codeTicks;
+        this.#codeFenced = closed.codeFenced;
+        this.#inUnclosedSpan = false;
+        this.#openMarker = "";
+        continue;
+      }
+      const opened = this.#findTag(OPEN_TAGS);
+      if (opened === undefined) break;
+      out += this.#buffer.slice(0, opened.index);
+      this.#openMarker = this.#buffer.slice(opened.index, opened.index + opened.length);
+      this.#buffer = this.#buffer.slice(opened.index + opened.length);
+      this.#codeTicks = opened.codeTicks;
+      this.#codeFenced = opened.codeFenced;
+      this.#inUnclosedSpan = true;
+    }
+    if (this.#inUnclosedSpan) {
+      // No close yet: hold the whole span content — including any text after it
+      // — until a later close or `flush()`. Streaming it now would release the
+      // span content before its opening tag on fail-open.
+      if (this.#buffer.length > MAX_THINK_BLOCK_BYTES) {
+        out += this.#openMarker + this.#buffer;
+        this.#buffer = "";
+        this.#inUnclosedSpan = false;
+        this.#openMarker = "";
+      }
+      return out;
+    }
+    const held = danglingTagPrefix(this.#buffer);
+    const settled = held.length > 0 ? this.#buffer.slice(0, -held.length) : this.#buffer;
+    this.#buffer = held;
+    return out + settled;
+  }
+
+  /** Releases content held back for a tag that never completed. */
+  flush(): string {
+    const rest = this.#buffer;
+    this.#buffer = "";
+    this.#codeTicks = 0;
+    this.#codeFenced = false;
+    if (this.#inUnclosedSpan) {
+      // An open tag that never closed is not evidence of reasoning — restore it
+      // byte-for-byte and release the whole tail as-is.
+      const marker = this.#openMarker;
+      this.#inUnclosedSpan = false;
+      this.#openMarker = "";
+      return marker + rest;
+    }
+    return rest;
+  }
+
+  #findTag(tags: readonly string[]): TagMatch | undefined {
+    const buffer = this.#buffer;
+    let ticks = this.#codeTicks;
+    let fenced = this.#codeFenced;
+    for (let i = 0; i < buffer.length; i++) {
+      const char = buffer[i];
+      if (char === "`") {
+        let run = 1;
+        while (buffer[i + run] === "`") run++;
+        if (ticks === 0) {
+          ticks = run;
+          fenced = run >= 3;
+        } else if (run === ticks) {
+          ticks = 0;
+          fenced = false;
+        }
+        i += run - 1;
+        continue;
+      }
+      if (char === "\n" && ticks > 0 && !fenced) ticks = 0;
+      if (char !== "<" || ticks > 0) continue;
+      for (const tag of tags) {
+        if (!buffer.startsWith(tag, i)) continue;
+        return { index: i, length: tag.length, codeTicks: ticks, codeFenced: fenced };
+      }
+    }
+    return undefined;
+  }
+}
+
 /** The longest suffix of `text` that is a proper prefix of any tag. */
 function danglingTagPrefix(text: string): string {
   const tags = [...OPEN_TAGS, ...CLOSE_TAGS];

package/src/protocol/translation/dialect/qwen.ts

@@ -12,77 +12,45 @@
  * rest as text, mirroring the DSML/OMP scanners used for other families.
  */
 import type { InbandScanner, InbandScanResult } from "./inband";
+import { MarkupStreamParser } from "../../markup-stream-parser";
 
 const OPEN_TAG = "<tool_call>";
 const CLOSE_TAG = "</tool_call>";
 
 export class QwenToolCallScanner implements InbandScanner {
-  readonly #allowedNames: ReadonlySet<string>;
-  #pending = "";
-  #sequence = 0;
+  readonly #parser: MarkupStreamParser<InbandScanResult["calls"][number]>;
 
   constructor(allowedNames: ReadonlySet<string>) {
-    this.#allowedNames = allowedNames;
+    this.#parser = new MarkupStreamParser<InbandScanResult["calls"][number]>({
+      openers: [OPEN_TAG],
+      classifyOpener: (_pending, _openIndex, opener) => {
+        if (opener !== OPEN_TAG) return { kind: "literal" };
+        return {
+          kind: "found",
+          closer: CLOSE_TAG,
+          parse: (block) => {
+            const inner = block.slice(OPEN_TAG.length, -CLOSE_TAG.length).trim();
+            const parsed = parseToolCall(inner);
+            if (parsed === undefined) return undefined;
+            if (!allowedNames.has(parsed.name)) {
+              // An undeclared tool is model text, not authority to invoke it.
+              return undefined;
+            }
+            return [parsed];
+          },
+          callId: (call, _index, seq) => ({ ...call, id: `call_qwen_${seq}` }),
+        };
+      },
+      flush: (pending) => (isPossibleOpener(pending) ? "" : pending),
+    });
   }
 
   push(chunk: string): InbandScanResult {
-    this.#pending += chunk;
-    let cursor = 0;
-    let text = "";
-    const calls: Array<InbandScanResult["calls"][number]> = [];
-    for (;;) {
-      const open = this.#pending.indexOf(OPEN_TAG, cursor);
-      if (open < 0) {
-        // Hold a possible pending opener at the tail; settle everything before it.
-        text += this.#pending.slice(cursor, this.#settledEnd(this.#pending.length));
-        cursor = this.#settledEnd(this.#pending.length);
-        break;
-      }
-      text += this.#pending.slice(cursor, open);
-      const bodyStart = open + OPEN_TAG.length;
-      const close = this.#pending.indexOf(CLOSE_TAG, bodyStart);
-      if (close < 0) {
-        // Unterminated block: hold from the opener on and settle what preceded it.
-        cursor = open;
-        break;
-      }
-      const inner = this.#pending.slice(bodyStart, close).trim();
-      const parsed = parseToolCall(inner);
-      if (parsed !== undefined) {
-        if (this.#allowedNames.has(parsed.name)) {
-          calls.push({
-            id: `call_qwen_${this.#sequence++}`,
-            name: parsed.name,
-            arguments: parsed.arguments,
-          });
-        } else {
-          // An undeclared tool is model text, not authority to invoke it.
-          text += this.#pending.slice(open, close + CLOSE_TAG.length);
-        }
-      } else {
-        text += this.#pending.slice(open, close + CLOSE_TAG.length);
-      }
-      cursor = close + CLOSE_TAG.length;
-    }
-    this.#pending = this.#pending.slice(cursor);
-    return { text, calls };
+    return this.#parser.push(chunk);
   }
 
   flush(): InbandScanResult {
-    const pending = this.#pending;
-    this.#pending = "";
-    if (isPossibleOpener(pending)) return { text: "", calls: [] };
-    return { text: pending, calls: [] };
-  }
-
-  #settledEnd(end: number): number {
-    // Keep a trailing fragment that could be the start of an opener.
-    const tail = this.#pending.slice(0, end);
-    const maxPrefix = Math.min(OPEN_TAG.length - 1, tail.length);
-    for (let len = maxPrefix; len > 0; len -= 1) {
-      if (OPEN_TAG.startsWith(tail.slice(-len))) return end - len;
-    }
-    return end;
+    return this.#parser.flush();
   }
 }
 

package/src/protocol/translation/quirks.ts

@@ -158,6 +158,21 @@ const PARAM_QUIRKS: readonly ParamQuirk[] = [
     // confirms that the selected-model request must not carry temperature.
     stripControls: ["temperature"],
   },
+  {
+    provider: "nvidia",
+    // NVIDIA NIM rejects a set of cross-wire fields with 400 even though the
+    // OpenAI-compatible chat wire permits them. Stripping them here keeps the
+    // dispatch on the same wire shape the upstream accepts.
+    stripControls: [
+      "extension:client_metadata",
+      "extension:prompt_cache_key",
+      "service_tier",
+      "extension:anthropic_beta",
+      "extension:thinking_budget",
+      "extension:metadata_user_id",
+      "extension:custom_field",
+    ],
+  },
   {
     provider: "anthropic",
     matchModel: rejectsSamplingParams,

package/src/protocol/upstream/send-claude-messages.ts

@@ -9,7 +9,7 @@ import { GatewayError } from '../gateway-error';
 import { applyRouteUserAgent, type ProviderDispatchContext } from "../../providers/provider-contracts";
 import { abortGatewayError, createUpstreamDeadlineLifecycle } from '../../providers/operations/upstream-deadline';
 import { mapClaudeHttpError } from '../messages-errors';
-import { isRecord } from '../codecs';
+import { isRecord, toolAliasesFor } from '../codecs';
 import { upstreamMessageAsIs, MAX_UPSTREAM_ERROR_BYTES } from '../../transport/failure-policy';
 import { parseClaudeSseStream, claudeResponseToEvents } from '../response/messages';
 
@@ -60,7 +60,7 @@ export async function* sendClaudeMessagesRequest(
         {},
         "upstream",
       );
-    yield* parseClaudeSseStream(response.body, context.abort_signal, isOAuth);
+    yield* parseClaudeSseStream(response.body, context.abort_signal, isOAuth, toolAliasesFor(request));
     return;
   }
   const body = await response.text().catch(() => "");

package/src/providers/adapters/compatible-adapter.ts

@@ -17,6 +17,7 @@ import { resolveDialect } from "../../protocol/translation/dialect/resolver";
 import { resolveThinkingForModel } from "../../protocol/translation/dialect/thinking-ladder";
 import type { DialectPolicy } from "../../protocol/translation/dialect/types";
 import { postUpstreamJson } from "../../protocol/upstream/post-json";
+import { gzipSync } from "node:zlib";
 import { GATEWAY_USER_AGENT } from "../operations/gateway-user-agent";
 import { resolvePromptCacheKey } from "../operations/session-resolution";
 import {
@@ -28,6 +29,24 @@ import {
 } from "../../protocol/codecs";
 const TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
 
+/**
+ * Whether an upstream error body is the channel-check rejection the CodeBuddy
+ * console fallback recovers from. Ported from the donor gateway
+ * (`codebuddy2api/upstream_compat.is_channel_check_error`): it requires both
+ * a channel-check business code (`11128` / `11-128`) and one of the
+ * explanatory texts. A bare code match swept unrelated failures into a retry.
+ */
+export function isBuddyChannelCheckError(raw: string): boolean {
+  if (!/code["']?\s*:\s*["']?(?:11128|11-128)/i.test(raw)) return false;
+  const lower = raw.toLowerCase();
+  return (
+    lower.includes("渠道校验") || // 渠道校验
+    lower.includes("channel verification") ||
+    lower.includes("official client") ||
+    lower.includes("illegal api invocation from an unapproved channel")
+  );
+}
+
 /**
  * Provider ids that understand the OpenAI-style `service_tier` control. Only
  * these upstreams accept the field; every other OpenAI-compatible provider
@@ -111,8 +130,21 @@ export interface OpenAICompatibleAdapterConfig {
    * stamps `Content-Encoding: zstd` — the Grok Build CLI does this via its
    * sampler (`request_compression.rs`), and the proxy accepts it (verified
    * live 2026-11-02). Falls back to plain JSON if the runtime lacks zstd.
+   * `"gzip"` compresses with `gzipSync` and stamps `Content-Encoding: gzip`
+   * — the CodeBuddy CLI contract (donor `codebuddy2api`): the CLI profiles
+   * always compress; the CN desktop profile compresses requests >= 1024 B.
+   * The caller must also send `Accept-Encoding: identity` (the compressed
+   * body and the uncompressed response are independent choices).
+   */
+  readonly request_compression?: "json" | "zstd" | "gzip";
+  /**
+   * One retry against this path when the primary chat endpoint answers a
+   * channel-check 400 (`11128` / `11-128`). Matches the donor gateway's
+   * `/console/chat/completions` fallback for the international profile: the
+   * primary `v2` endpoint rejects requests that do not carry the channel
+   * marker, and a single console retry is the reference's recovery.
    */
-  readonly request_compression?: "json" | "zstd";
+  readonly channel_fallback_path?: string;
   /**
    * Stamps `user-agent: Cartethyia/<version>` on every dispatch. Explicit
    * opt-in per provider spec — never a default — so first-party cloaking
@@ -216,6 +248,13 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
     // here — alongside the other request headers — so auth/proxy layers see the
     // final shape before the transport runs.
     if (this.config.request_compression === "zstd") headers["content-encoding"] = "zstd";
+    else if (this.config.request_compression === "gzip") {
+      headers["content-encoding"] = "gzip";
+      // The compressed request and the response encoding are independent; the
+      // reference requests the identity response encoding so the stream arrives
+      // uncompressed (matching `Accept-Encoding: identity` in the donor).
+      headers["accept-encoding"] = "identity";
+    }
     Object.assign(headers, filterProviderCustomHeaders(context.credential.custom_headers));
     applyRouteUserAgent(headers, context.credential, context.user_agent);
     return headers;
@@ -271,6 +310,11 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       // plus `message_delta.usage` — so nothing is lost by omitting it.
       const existing = payload["stream_options"] as Record<string, unknown> | undefined;
       payload["stream_options"] = { ...(existing ?? {}), include_usage: true };
+    } else if (!effectiveRequest.stream && payload["stream_options"] !== undefined) {
+      // A non-streaming request must not carry `stream_options`: several
+      // OpenAI-compatible upstreams (NVIDIA NIM, DeepSeek) reject the body
+      // with 400 "Stream options can only be defined when stream=True".
+      delete payload["stream_options"];
     }
     // Apply structured_output configuration
     if (this.config.structured_output?.enabled) {
@@ -330,18 +374,38 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       return u.toString();
     })();
     const outboundFetch = context.outbound_fetch ?? this.config.fetch ?? globalThis.fetch;
-    const upstream = await postUpstreamJson(
-      fetchUrl,
-      headers,
-      payload as Record<string, unknown>,
-      context,
-      outboundFetch,
-      // zstd body encoding: matches the Grok Build CLI's
-      // `request_compression` (zstd with a JSON fallback when unavailable).
+    const bodyEncoder =
       this.config.request_compression === "zstd" && typeof Bun?.zstdCompressSync === "function"
-        ? (p) => Bun.zstdCompressSync(Buffer.from(JSON.stringify(p))) as Uint8Array<ArrayBuffer>
-        : undefined,
-    );
+        ? (p: Record<string, unknown>) => Bun.zstdCompressSync(Buffer.from(JSON.stringify(p))) as Uint8Array<ArrayBuffer>
+        : this.config.request_compression === "gzip"
+          ? (p: Record<string, unknown>) => gzipSync(Buffer.from(JSON.stringify(p)), { level: 6 })
+          : undefined;
+    const channelFallback =
+      this.config.channel_fallback_path !== undefined &&
+      endpointPath !== this.config.channel_fallback_path
+        ? joinUrl(this.config.resolveBaseUrl?.(context) ?? this.config.base_url, this.config.channel_fallback_path)
+        : undefined;
+    const upstream = await postUpstreamJson(fetchUrl, headers, payload as Record<string, unknown>, context, outboundFetch, bodyEncoder);
+    if (channelFallback !== undefined && upstream.res.status === 400) {
+      // Read the body only for a 400 that could still be retried. The channel
+      // check is the one refusal the console endpoint recovers from; a rejected
+      // body is consumed here so the fallback attempt carries a fresh stream.
+      const raw = await upstream.res.text().catch(() => "");
+      upstream.release();
+      if (isBuddyChannelCheckError(raw)) {
+        const retry = await postUpstreamJson(channelFallback, headers, payload as Record<string, unknown>, context, outboundFetch, bodyEncoder);
+        retry.release();
+        return retry.res;
+      }
+      // Not a channel check — reconstruct the 400 response so downstream error
+      // classification still sees the upstream's body. A `Response` body can be
+      // consumed once, so rebuild it from the captured text.
+      return new Response(raw, {
+        status: 400,
+        statusText: upstream.res.statusText,
+        headers: { "content-type": "application/json" },
+      });
+    }
     upstream.release();
     return upstream.res;
   }