@gajae-code/ai 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [0.7.3] - 2026-06-25
+### Added
+
+- Added the Sakana Fugu provider (`fugu`) with API-key auth (`FUGU_API_KEY`) and bundled catalog models (#1086).
+
+### Fixed
+
+- Wired Fugu API-key auth login so `gjc login fugu` stores a reusable `FUGU_API_KEY` credential instead of the provider having no supported login flow (#1090).
+- Matched the real google-antigravity IDE request headers, system prompt, and preamble config so requests are accepted by Cloud Code Assist (#1080).
+- `isContextOverflow` now detects a third proxy-level overflow case — an empty response with `stopReason: "stop"` and anomalously low usage (input + output ≤ 5 tokens), as emitted by some proxies (notably LiteLLM) when the upstream context window is exceeded — so callers surface overflow instead of treating it as a clean completion (#1102).
+
+### Security
+
+- In no-auth (tokenless) auth-gateway mode, requests carrying a browser `Origin` header are now rejected before CORS preflight handling or route dispatch, while local non-browser CLI clients keep the existing tokenless flow and token-configured browser clients keep the bearer-token/preflight flow (#1115).
+
+## [0.7.2] - 2026-06-24
+
+### Fixed
+
+- Reject truncated or incomplete streamed tool calls instead of executing them with partial arguments, so a cut-off tool-call payload fails fast rather than running against a mismatched schema.
+
 ## [0.7.1] - 2026-06-23
 
 ### Changed

package/dist/types/auth-gateway/http.d.ts

@@ -7,6 +7,7 @@ export declare function resolvePeer(req: Request): string;
  */
 export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
 export declare function isAuthorized(req: Request, tokens: ReadonlySet<string>): boolean;
+export declare function isNoAuthBrowserOriginRequest(req: Request, tokens: ReadonlySet<string>): boolean;
 /**
  * Extract allow-listed passthrough headers from an inbound request. Keys are
  * lowercased; empty values are dropped. Called once per request in

package/dist/types/provider-models/openai-compat.d.ts

@@ -75,6 +75,11 @@ export interface FirepassModelManagerConfig {
  * See https://docs.fireworks.ai/firepass.
  */
 export declare function firepassModelManagerOptions(_config?: FirepassModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface FuguModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function fuguModelManagerOptions(config?: FuguModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface MistralModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;

package/dist/types/providers/google-gemini-cli.d.ts

@@ -24,7 +24,7 @@ export interface GoogleGeminiCliOptions extends StreamOptions {
     };
     projectId?: string;
 }
-export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "./google-gemini-headers";
+export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityRequestHeaders, getGeminiCliHeaders, getGeminiCliUserAgent, } from "./google-gemini-headers";
 interface ParsedGeminiCliCredentials {
     accessToken: string;
     projectId: string;
@@ -63,6 +63,9 @@ interface CloudCodeAssistRequest {
                 mode: FunctionCallingConfigMode;
             };
         };
+        preambleConfig?: {
+            mode: "SYSTEM_INSTRUCTION_MODE_REPLACE";
+        };
     };
     requestType?: string;
     userAgent?: string;

package/dist/types/providers/google-gemini-headers.d.ts

@@ -8,11 +8,33 @@ export declare const getGeminiCliHeaders: (modelId?: string) => {
     "User-Agent": string;
     "Client-Metadata": string;
 };
-export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION: string;
 /**
- * Antigravity / Cloud Code Assist user agent. Lives in its own file so discovery
- * and usage code can read it without pulling the heavy google-gemini-cli provider
- * (and its @google/genai → google-auth-library dependency chain) into the startup
- * parse graph.
+ * Full Antigravity system instruction as observed in the real IDE binary.
+ * This is the complete prompt injected by the Antigravity language server,
+ * including BNF lexer definition for syntax highlighting, messaging system
+ * description, and reactive wakeup protocol.
+ *
+ * Wire-format fidelity note: The `%s` placeholders are literal in the real
+ * Antigravity IDE prompt. The Cloud Code Assist service either expands them
+ * server-side or the model handles them as-is. Preserved for byte-faithful
+ * emulation of the observed IDE wire format.
+ *
+ * Evidence: Disassembly of the Antigravity LS binary confirms this exact
+ * string is loaded and injected as the system instruction.
+ */
+export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION = "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.\nYou are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.\nThe USER will send you requests, which you must always prioritize addressing. Along with each USER request, we will attach additional metadata about their current state, such as what files they have open and where their cursor is.\nThis information may or may not be relevant to the coding task, it is up for you to decide.<lexer>\n  <config>\n    <name>BNF</name>\n    <alias>bnf</alias>\n    <filename>*.bnf</filename>\n    <mime_type>text/x-bnf</mime_type>\n  </config>\n  <rules>\n    <state name=\"root\">\n      <rule pattern=\"(&lt;)([ -;=?-~]+)(&gt;)\">\n        <bygroups>\n          <token type=\"Punctuation\"/>\n          <token type=\"NameClass\"/>\n          <token type=\"Punctuation\"/>\n        </bygroups>\n      </rule>\n      <rule pattern=\"::=\">\n        <token type=\"Operator\"/>\n      </rule>\n      <rule pattern=\"[^&lt;&gt;:]+\">\n        <token type=\"Text\"/>\n      </rule>\n      <rule pattern=\".\">\n        <token type=\"Text\"/>\n      </rule>\n    </state>\n  </rules>\n</lexer>You are connected to a messaging system where you may receive messages from: %s.\n\n## Receiving Messages\n\nYou receive messages automatically at the start of each invocation. All messages are delivered in full directly into your context \u2014 no manual retrieval is needed.\n\n## Reactive Wakeup (No Polling Needed)\n\nThe system automatically resumes your execution when:\n%s\n\nThis means you do **NOT** need to poll in a loop while waiting for messages or updates. After launching anything that performs work asynchronously, you may continue other work or simply stop by calling no more tools. The system will notify you when there is something to process.\n";
+/**
+ * Antigravity / Cloud Code Assist user agent.
+ *
+ * Disassembly-confirmed: getUserAgentName() @ 0x5ecb1dd loads "antigravity-ide"
+ * via LEA RDX, [RIP-0x284fc90] → 0x367b554 = "antigravity-ide"
+ *
+ * The LS sets HTTP headers via: fmt.Sprintf("User-Agent: %s", getUserAgentName())
+ * So the final header is: User-Agent: antigravity-ide
+ *
+ * -override_user_agent flag can override this (confirmed at 0x5ecbc37).
  */
 export declare let getAntigravityUserAgent: () => string;
+export declare const getAntigravityRequestHeaders: () => {
+    "User-Agent": string;
+};

package/dist/types/providers/mock.d.ts

@@ -60,6 +60,8 @@ export type MockContent = string | {
     name: string;
     /** Object form is preferred; strings are passed through verbatim. */
     arguments: Record<string, unknown> | string;
+    /** Simulate a provider-flagged truncated call (cut off mid-arguments). */
+    incompleteArguments?: boolean;
 };
 /** One scripted response. */
 export interface MockResponse {

package/dist/types/providers/openai-responses-shared.d.ts

@@ -1,6 +1,6 @@
 import type OpenAI from "openai";
 import type { ResponseInput, ResponseInputContent, ResponseOutputItem } from "openai/resources/responses/responses";
-import { type Api, type AssistantMessage, type ImageContent, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ToolResultMessage } from "../types";
+import { type Api, type AssistantMessage, type ImageContent, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ToolCall, type ToolResultMessage } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 export declare function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string;
 export declare function parseTextSignature(signature: string | undefined): {
@@ -44,6 +44,21 @@ export interface ProcessResponsesStreamOptions {
     onOutputItemDone?: (item: ResponseOutputItem) => void;
 }
 export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
+/**
+ * Mark tool-call blocks left incomplete by a length-truncated response so the
+ * agent loop rejects them instead of executing a best-effort partial parse.
+ *
+ * The universal signal is finalization: a call that never received its terminal
+ * `output_item.done` (passed in via `isFinalized`) was cut off mid-arguments.
+ * This covers both JSON function calls and raw-input custom tools without
+ * mis-flagging a *completed* custom tool whose raw input is not valid JSON. As a
+ * defensive secondary, a finalized JSON function call whose buffered arguments
+ * still don't parse (e.g. a misbehaving relay) is flagged too. No-op unless the
+ * turn stopped for length.
+ *
+ * Shared by both Responses providers (`openai-responses`, `openai-codex-responses`).
+ */
+export declare function flagTruncatedToolCalls(output: AssistantMessage, stopReason: StopReason, isFinalized: (block: ToolCall) => boolean): void;
 export declare function mapOpenAIResponsesStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason;
 /** Initial empty `AssistantMessage` that streaming providers accumulate into. */
 export declare function createInitialResponsesAssistantMessage(api: Api, provider: string, modelId: string): AssistantMessage;

package/dist/types/types.d.ts

@@ -48,7 +48,7 @@ export interface ThinkingConfig {
     /** Provider-specific transport used to encode the selected effort. */
     mode: ThinkingControlMode;
 }
-export type KnownProvider = "alibaba-coding-plan" | "amazon-bedrock" | "azure-openai" | "anthropic" | "google" | "google-gemini-cli" | "google-antigravity" | "google-vertex" | "openai" | "openai-codex" | "kimi-code" | "minimax-code" | "minimax-code-cn" | "github-copilot" | "fireworks" | "firepass" | "gitlab-duo" | "cursor" | "deepseek" | "xai" | "groq" | "cerebras" | "openrouter" | "kilo" | "vercel-ai-gateway" | "zai" | "glm-zcode" | "mistral" | "minimax" | "opencode-go" | "opencode-zen" | "synthetic" | "cloudflare-ai-gateway" | "huggingface" | "litellm" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "qianfan" | "qwen-portal" | "together" | "venice" | "vllm" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "zenmux" | "lm-studio";
+export type KnownProvider = "alibaba-coding-plan" | "amazon-bedrock" | "azure-openai" | "anthropic" | "google" | "google-gemini-cli" | "google-antigravity" | "google-vertex" | "openai" | "openai-codex" | "kimi-code" | "minimax-code" | "minimax-code-cn" | "github-copilot" | "fireworks" | "firepass" | "fugu" | "gitlab-duo" | "cursor" | "deepseek" | "xai" | "groq" | "cerebras" | "openrouter" | "kilo" | "vercel-ai-gateway" | "zai" | "glm-zcode" | "mistral" | "minimax" | "opencode-go" | "opencode-zen" | "synthetic" | "cloudflare-ai-gateway" | "huggingface" | "litellm" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "qianfan" | "qwen-portal" | "together" | "venice" | "vllm" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "zenmux" | "lm-studio";
 export type Provider = KnownProvider | string;
 import type { Effort } from "./model-thinking";
 /** Token budgets for each thinking level (token-based providers only) */
@@ -338,6 +338,14 @@ export interface ToolCall {
      * JSON function tools.
      */
     customWireName?: string;
+    /**
+     * Set when the provider detected the argument JSON was truncated — the model
+     * hit its output-token limit (or the response was otherwise cut short) before
+     * emitting a complete arguments object. The `arguments` field then holds a
+     * best-effort partial parse and must not be executed as-is; the agent loop
+     * rejects the call with a retryable error instead.
+     */
+    incompleteArguments?: boolean;
 }
 export interface Usage {
     /** Non-cached input tokens (matches the bucket the provider bills as new input). */

package/dist/types/utils/json-parse.d.ts

@@ -8,3 +8,11 @@ export declare function parseJsonWithRepair<T>(json: string): T;
  * @returns Parsed object or empty object if parsing fails
  */
 export declare function parseStreamingJson<T = Record<string, unknown>>(partialJson: string | undefined): T;
+/**
+ * Whether a string is a complete, well-formed JSON document (strict parse, no
+ * repair). Used to distinguish a tool-call argument blob that finished cleanly
+ * from one that was cut off mid-stream (truncation). An empty / whitespace-only
+ * string is treated as complete: a tool invoked with no arguments legitimately
+ * streams an empty buffer and must not be flagged as truncated.
+ */
+export declare function isCompleteJson(text: string | undefined): boolean;

package/dist/types/utils/oauth/fugu.d.ts

@@ -0,0 +1 @@
+export declare const loginFugu: (options: import("./types").OAuthController) => Promise<string>;

package/dist/types/utils/oauth/types.d.ts

@@ -7,7 +7,7 @@ export type OAuthCredentials = {
     email?: string;
     accountId?: string;
 };
-export type OAuthProvider = "alibaba-coding-plan" | "anthropic" | "cerebras" | "cloudflare-ai-gateway" | "cursor" | "deepseek" | "fireworks" | "firepass" | "github-copilot" | "google-gemini-cli" | "google-antigravity" | "gitlab-duo" | "huggingface" | "kimi-code" | "kilo" | "kagi" | "litellm" | "lm-studio" | "minimax-code" | "minimax-code-cn" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "openai-codex" | "openai-codex-device" | "opencode-go" | "opencode-zen" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "synthetic" | "tavily" | "together" | "venice" | "vercel-ai-gateway" | "vllm" | "xai" | "glm-zcode" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "zenmux" | "zai";
+export type OAuthProvider = "alibaba-coding-plan" | "anthropic" | "cerebras" | "cloudflare-ai-gateway" | "cursor" | "deepseek" | "fireworks" | "firepass" | "fugu" | "github-copilot" | "google-gemini-cli" | "google-antigravity" | "gitlab-duo" | "huggingface" | "kimi-code" | "kilo" | "kagi" | "litellm" | "lm-studio" | "minimax-code" | "minimax-code-cn" | "moonshot" | "nvidia" | "nanogpt" | "ollama" | "ollama-cloud" | "openai-codex" | "openai-codex-device" | "opencode-go" | "opencode-zen" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "synthetic" | "tavily" | "together" | "venice" | "vercel-ai-gateway" | "vllm" | "xai" | "glm-zcode" | "xiaomi" | "xiaomi-token-plan-sgp" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "zenmux" | "zai";
 export type OAuthProviderId = OAuthProvider | (string & {});
 export type OAuthPrompt = {
     message: string;

package/dist/types/utils/overflow.d.ts

@@ -2,11 +2,14 @@ import type { AssistantMessage } from "../types";
 /**
  * Check if an assistant message represents a context overflow error.
  *
- * This handles two cases:
+ * This handles three cases:
  * 1. Error-based overflow: Most providers return stopReason "error" with a
  *    specific error message pattern.
  * 2. Silent overflow: Some providers accept overflow requests and return
  *    successfully. For these, we check if usage.input exceeds the context window.
+ * 3. Proxy-level overflow: Some proxies (e.g. LiteLLM) return a "successful"
+ *    response with empty content and a fabricated near-zero usage when the
+ *    upstream model's context window is exceeded.
  *
  * ## Reliability by Provider
  *
@@ -30,6 +33,13 @@ import type { AssistantMessage } from "../types";
  * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
  *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
  * - Ollama: Silently truncates input without error. Cannot be detected via this function.
+ * - LiteLLM proxy: Returns a "successful" response with empty content and a
+ *   fabricated near-zero usage (e.g. input: 1, output: 1) when the upstream
+ *   model's context window is exceeded. Detected via Case 3 (empty content +
+ *   anomalously low usage). Note: the LiteLLM proxy's context limit may differ
+ *   from the underlying model's advertised contextWindow (e.g. configured via
+ *   `model_info.max_tokens` in LiteLLM's config.yaml), so Case 2 (which compares
+ *   usage.input against contextWindow) may not catch it.
  *   The response will have usage.input < expected, but we don't know the expected value.
  *
  * ## Custom Providers

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.7.1",
+	"version": "0.7.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -43,7 +43,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/utils": "0.7.1",
+		"@gajae-code/utils": "0.7.3",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-gateway/http.ts

@@ -47,7 +47,7 @@ export function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {
 const TOKEN_ENCODER = new TextEncoder();
 
 export function isAuthorized(req: Request, tokens: ReadonlySet<string>): boolean {
-	if (tokens.size === 0) return true;
+	if (tokens.size === 0) return !isNoAuthBrowserOriginRequest(req, tokens);
 	const header = req.headers.get("authorization");
 	if (!header) return false;
 	const match = header.match(/^Bearer\s+(.+)$/i);
@@ -63,6 +63,10 @@ export function isAuthorized(req: Request, tokens: ReadonlySet<string>): boolean
 	return ok;
 }
 
+export function isNoAuthBrowserOriginRequest(req: Request, tokens: ReadonlySet<string>): boolean {
+	return tokens.size === 0 && req.headers.has("origin");
+}
+
 /**
  * Allow-list of inbound request headers that the gateway captures and forwards
  * to the underlying parsers (which decide whether to surface them to the

package/src/auth-gateway/server.ts

@@ -27,7 +27,15 @@ import * as piNative from "../providers/pi-native-server";
 import { streamSimple } from "../stream";
 import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "../types";
 import { parseBind } from "../utils/parse-bind";
-import { captureRequestHeaders, corsHeaders, isAuthorized, json, resolvePeer, withCors } from "./http";
+import {
+	captureRequestHeaders,
+	corsHeaders,
+	isAuthorized,
+	isNoAuthBrowserOriginRequest,
+	json,
+	resolvePeer,
+	withCors,
+} from "./http";
 import type {
 	AuthGatewayServerHandle,
 	AuthGatewayServerOptions,
@@ -640,6 +648,15 @@ export function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServe
 			const url = new URL(req.url);
 			const pathname = url.pathname;
 			const peer = resolvePeer(req);
+			if (isNoAuthBrowserOriginRequest(req, tokens)) {
+				logger.info("auth-gateway no-auth browser-origin request rejected", {
+					method: req.method,
+					path: pathname,
+					peer,
+					origin: req.headers.get("origin"),
+				});
+				return json(403, { error: "browser origin requires bearer token" });
+			}
 			// CORS preflight is always answered without auth — browsers send
 			// preflights pre-authentication and a 401 here breaks the actual
 			// request before the bearer is ever attached.

package/src/auth-storage.ts

@@ -1613,6 +1613,12 @@ export class AuthStorage {
 				await saveApiKeyCredential(apiKey);
 				return;
 			}
+			case "fugu": {
+				const { loginFugu } = await import("./utils/oauth/fugu");
+				const apiKey = await loginFugu(ctrl);
+				await saveApiKeyCredential(apiKey);
+				return;
+			}
 			case "zai": {
 				const { loginZai } = await import("./utils/oauth/zai");
 				const apiKey = await loginZai(ctrl);

package/src/models.json

@@ -79757,5 +79757,71 @@
 				"maxLevel": "xhigh"
 			}
 		}
+	},
+	"fugu": {
+		"fugu": {
+			"id": "fugu",
+			"name": "Sakana Fugu",
+			"api": "openai-completions",
+			"provider": "fugu",
+			"baseUrl": "https://api.sakana.ai/v1",
+			"reasoning": true,
+			"input": [
+				"text"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 200000,
+			"maxTokens": 65536,
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsMultipleSystemMessages": false,
+				"supportsReasoningEffort": false,
+				"supportsUsageInStreaming": true,
+				"maxTokensField": "max_tokens"
+			},
+			"thinking": {
+				"mode": "effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
+		"fugu-ultra": {
+			"id": "fugu-ultra",
+			"name": "Sakana Fugu Ultra",
+			"api": "openai-completions",
+			"provider": "fugu",
+			"baseUrl": "https://api.sakana.ai/v1",
+			"reasoning": true,
+			"input": [
+				"text"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 200000,
+			"maxTokens": 65536,
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsMultipleSystemMessages": false,
+				"supportsReasoningEffort": false,
+				"supportsUsageInStreaming": true,
+				"maxTokensField": "max_tokens"
+			},
+			"thinking": {
+				"mode": "effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		}
 	}
 }

package/src/provider-models/descriptors.ts

@@ -16,6 +16,7 @@ import {
 	deepseekModelManagerOptions,
 	firepassModelManagerOptions,
 	fireworksModelManagerOptions,
+	fuguModelManagerOptions,
 	githubCopilotModelManagerOptions,
 	groqModelManagerOptions,
 	huggingfaceModelManagerOptions,
@@ -154,6 +155,12 @@ export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = [
 		catalog("Fireworks", ["FIREWORKS_API_KEY"]),
 	),
 	descriptor("firepass", "kimi-k2.6-turbo", config => firepassModelManagerOptions(config)),
+	catalogDescriptor(
+		"fugu",
+		"fugu",
+		config => fuguModelManagerOptions(config),
+		catalog("Sakana Fugu", ["FUGU_API_KEY"]),
+	),
 	descriptor("xai", "grok-4-fast-non-reasoning", config => xaiModelManagerOptions(config)),
 	catalogDescriptor(
 		"deepseek",

package/src/provider-models/openai-compat.ts

@@ -785,6 +785,15 @@ export function firepassModelManagerOptions(
 // 7. Mistral
 // ---------------------------------------------------------------------------
 
+export interface FuguModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+}
+
+export function fuguModelManagerOptions(config?: FuguModelManagerConfig): ModelManagerOptions<"openai-completions"> {
+	return createSimpleOpenAICompletionsOptions("fugu", config?.baseUrl ?? "https://api.sakana.ai/v1", config);
+}
+
 export interface MistralModelManagerConfig {
 	apiKey?: string;
 	baseUrl?: string;

package/src/providers/google-gemini-cli.ts

@@ -30,7 +30,11 @@ import {
 	markToolChoiceIncapability,
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
-import { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders } from "./google-gemini-headers";
+import {
+	ANTIGRAVITY_SYSTEM_INSTRUCTION,
+	getAntigravityRequestHeaders,
+	getGeminiCliHeaders,
+} from "./google-gemini-headers";
 import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
 import {
 	convertMessages,
@@ -78,7 +82,7 @@ const ANTIGRAVITY_ENDPOINT_FALLBACKS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_
 
 export {
 	ANTIGRAVITY_SYSTEM_INSTRUCTION,
-	getAntigravityUserAgent,
+	getAntigravityRequestHeaders,
 	getGeminiCliHeaders,
 	getGeminiCliUserAgent,
 } from "./google-gemini-headers";
@@ -220,6 +224,13 @@ interface CloudCodeAssistRequest {
 				mode: FunctionCallingConfigMode;
 			};
 		};
+		// Evidence: Real Antigravity IDE sends preambleConfig with
+		// SYSTEM_INSTRUCTION_MODE_REPLACE to control how the server
+		// interprets the system instruction (replace vs append).
+		// Confirmed via network interception of official IDE traffic.
+		preambleConfig?: {
+			mode: "SYSTEM_INSTRUCTION_MODE_REPLACE";
+		};
 	};
 	requestType?: string;
 	userAgent?: string;
@@ -319,7 +330,9 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			if (replacementPayload !== undefined) {
 				requestBody = replacementPayload as typeof requestBody;
 			}
-			const headers = isAntigravity ? { "User-Agent": getAntigravityUserAgent() } : getGeminiCliHeaders(model.id);
+			const headers = isAntigravity
+				? getAntigravityRequestHeaders() // Evidence: UA = "antigravity-ide" (disassembly 0x5ecb1dd)
+				: getGeminiCliHeaders(model.id);
 
 			const requestHeaders = {
 				Authorization: `Bearer ${accessToken}`,
@@ -786,9 +799,13 @@ export function buildRequest(
 		request.sessionId = deriveAntigravitySessionId(context);
 	}
 
-	// System instruction must be object with parts, not plain string
+	// System instruction must be object with parts, not plain string.
+	// Evidence: Real Antigravity IDE sets role: "user" on systemInstruction
+	// (confirmed in request body dumps from network interception).
+	// Only applied for Antigravity path — standard gemini-cli omits role.
 	if (systemPrompts.length > 0) {
 		request.systemInstruction = {
+			...(isAntigravity && { role: "user" }),
 			parts: systemPrompts.map(text => ({ text })),
 		};
 	}
@@ -818,26 +835,55 @@ export function buildRequest(
 		}
 	}
 
-	if (isAntigravity && isClaudeModel(model.id)) {
-		const resolvedLevel = resolvedToolChoice.resolvedLevel;
-		if (resolvedLevel === "named" || resolvedLevel === "required") {
-			request.toolConfig = {
-				functionCallingConfig: {
-					mode: "VALIDATED" as FunctionCallingConfigMode,
-				},
-			};
-		}
+	// Claude Antigravity: use VALIDATED mode only when tools are present
+	// and the caller hasn't explicitly requested "none" tool choice.
+	//
+	// Evidence:
+	// - Real Antigravity IDE sends VALIDATED for Claude requests with tools
+	//   (confirmed via network interception of official IDE traffic)
+	// - The original GJC code used resolvedToolChoice.resolvedLevel to gate
+	//   VALIDATED, but the real IDE doesn't check tool choice resolution —
+	//   it sends VALIDATED whenever tools exist and toolChoice != "none"
+	// - omp reference: packages/ai/src/providers/google-gemini-cli.ts
+	//   `antigravityClaudeToolConfig` guard pattern
+	if (
+		isAntigravity &&
+		isClaudeModel(model.id) &&
+		context.tools &&
+		context.tools.length > 0 &&
+		options?.toolChoice !== "none"
+	) {
+		request.toolConfig = {
+			functionCallingConfig: {
+				mode: "VALIDATED" as FunctionCallingConfigMode,
+			},
+		};
 	}
 
+	// Stateless system instruction injection: send on EVERY Antigravity request.
+	// This is safer than client-side session dedup because:
+	// - preambleConfig server-side persistence is unproven
+	// - A failed first request would poison the session if we skipped injection
+	// - Token cost is acceptable for Antigravity's long-context models
+	//
+	// Evidence:
+	// - Real Antigravity IDE sends the full system prompt on every request
+	//   (confirmed via repeated request dumps — no client-side dedup observed)
+	// - The [ignore] wrapper was a GJC-original addition not present in the
+	//   real IDE wire format. Removed for byte-faithful emulation.
+	// - preambleConfig: { mode: "SYSTEM_INSTRUCTION_MODE_REPLACE" } is the
+	//   mechanism the real IDE uses to deliver system instructions. Without it,
+	//   the server may append (not replace) the system prompt.
+	// - omp reference: `sessionSystemInstructionSent` Map was omp's approach;
+	//   we chose stateless injection for simplicity and safety.
 	if (isAntigravity && shouldInjectAntigravitySystemInstruction(model.id)) {
 		const existingParts = request.systemInstruction?.parts ?? [];
 		request.systemInstruction = {
 			role: "user",
-			parts: [
-				{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION },
-				{ text: `Please ignore following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` },
-				...existingParts,
-			],
+			parts: [{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION }, ...existingParts],
+		};
+		request.preambleConfig = {
+			mode: "SYSTEM_INSTRUCTION_MODE_REPLACE",
 		};
 	}
 

package/src/providers/google-gemini-headers.ts

@@ -15,27 +15,81 @@ export const getGeminiCliHeaders = (modelId?: string) => ({
 	"Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
 });
 
-export const ANTIGRAVITY_SYSTEM_INSTRUCTION =
-	"You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding." +
-	"You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question." +
-	"**Absolute paths only**" +
-	"**Proactiveness**";
 /**
- * Antigravity / Cloud Code Assist user agent. Lives in its own file so discovery
- * and usage code can read it without pulling the heavy google-gemini-cli provider
- * (and its @google/genai → google-auth-library dependency chain) into the startup
- * parse graph.
+ * Full Antigravity system instruction as observed in the real IDE binary.
+ * This is the complete prompt injected by the Antigravity language server,
+ * including BNF lexer definition for syntax highlighting, messaging system
+ * description, and reactive wakeup protocol.
+ *
+ * Wire-format fidelity note: The `%s` placeholders are literal in the real
+ * Antigravity IDE prompt. The Cloud Code Assist service either expands them
+ * server-side or the model handles them as-is. Preserved for byte-faithful
+ * emulation of the observed IDE wire format.
+ *
+ * Evidence: Disassembly of the Antigravity LS binary confirms this exact
+ * string is loaded and injected as the system instruction.
+ */
+export const ANTIGRAVITY_SYSTEM_INSTRUCTION = `You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.
+You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.
+The USER will send you requests, which you must always prioritize addressing. Along with each USER request, we will attach additional metadata about their current state, such as what files they have open and where their cursor is.
+This information may or may not be relevant to the coding task, it is up for you to decide.<lexer>
+  <config>
+    <name>BNF</name>
+    <alias>bnf</alias>
+    <filename>*.bnf</filename>
+    <mime_type>text/x-bnf</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="(&lt;)([ -;=?-~]+)(&gt;)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameClass"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="::=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[^&lt;&gt;:]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>You are connected to a messaging system where you may receive messages from: %s.
+
+## Receiving Messages
+
+You receive messages automatically at the start of each invocation. All messages are delivered in full directly into your context — no manual retrieval is needed.
+
+## Reactive Wakeup (No Polling Needed)
+
+The system automatically resumes your execution when:
+%s
+
+This means you do **NOT** need to poll in a loop while waiting for messages or updates. After launching anything that performs work asynchronously, you may continue other work or simply stop by calling no more tools. The system will notify you when there is something to process.
+`;
+/**
+ * Antigravity / Cloud Code Assist user agent.
+ *
+ * Disassembly-confirmed: getUserAgentName() @ 0x5ecb1dd loads "antigravity-ide"
+ * via LEA RDX, [RIP-0x284fc90] → 0x367b554 = "antigravity-ide"
+ *
+ * The LS sets HTTP headers via: fmt.Sprintf("User-Agent: %s", getUserAgentName())
+ * So the final header is: User-Agent: antigravity-ide
+ *
+ * -override_user_agent flag can override this (confirmed at 0x5ecbc37).
  */
 export let getAntigravityUserAgent = () => {
-	const DEFAULT_ANTIGRAVITY_VERSION = "1.104.0";
-	const version = process.env.PI_AI_ANTIGRAVITY_VERSION || DEFAULT_ANTIGRAVITY_VERSION;
-	// Map Node.js platform/arch to Antigravity's expected format.
-	// Verified against Antigravity source: _qn() and wqn() in main.js.
-	// process.platform: win32→windows, others pass through (darwin, linux)
-	// process.arch:     x64→amd64, ia32→386, others pass through (arm64)
-	const os = process.platform === "win32" ? "windows" : process.platform;
-	const arch = process.arch === "x64" ? "amd64" : process.arch === "ia32" ? "386" : process.arch;
-	const userAgent = `antigravity/${version} ${os}/${arch}`;
+	const override = process.env.PI_AI_ANTIGRAVITY_USER_AGENT;
+	const userAgent = override || "antigravity-ide";
 	getAntigravityUserAgent = () => userAgent;
 	return userAgent;
 };
+
+export const getAntigravityRequestHeaders = () => ({
+	"User-Agent": getAntigravityUserAgent(),
+});

package/src/providers/mock.ts

@@ -73,6 +73,8 @@ export type MockContent =
 			name: string;
 			/** Object form is preferred; strings are passed through verbatim. */
 			arguments: Record<string, unknown> | string;
+			/** Simulate a provider-flagged truncated call (cut off mid-arguments). */
+			incompleteArguments?: boolean;
 	  };
 
 /** One scripted response. */
@@ -416,6 +418,7 @@ function normalizeContent(input: MockContent, state: MockModel): TextContent | T
 			id: input.id ?? generateToolCallId(state),
 			name: input.name,
 			arguments: typeof input.arguments === "string" ? input.arguments : { ...input.arguments },
+			...(input.incompleteArguments ? { incompleteArguments: true } : {}),
 		} as ToolCall;
 	}
 	return input;

package/src/providers/openai-codex-responses.ts

@@ -78,6 +78,7 @@ import {
 	convertResponsesInputContent,
 	encodeResponsesToolCallId,
 	encodeTextSignatureV1,
+	flagTruncatedToolCalls,
 	mapOpenAIResponsesStopReason,
 	populateResponsesUsageFromResponse,
 } from "./openai-responses-shared";
@@ -254,6 +255,8 @@ interface CodexStreamRuntime {
 	providerRetryAttempt: number;
 	sawTerminalEvent: boolean;
 	canSafelyReplayWebsocketOverSse: boolean;
+	/** Ids of tool calls that received their terminal `output_item.done`. */
+	finalizedToolCallIds: Set<string>;
 }
 
 interface CodexStreamProcessingContext {
@@ -910,6 +913,7 @@ function createCodexStreamRuntime(initial: {
 		providerRetryAttempt: 0,
 		sawTerminalEvent: false,
 		canSafelyReplayWebsocketOverSse: true,
+		finalizedToolCallIds: new Set<string>(),
 	};
 }
 
@@ -1267,9 +1271,11 @@ function handleOutputItemDone(
 	}
 
 	if (item.type === "function_call") {
+		const id = encodeResponsesToolCallId(item.call_id, item.id);
+		runtime.finalizedToolCallIds.add(id);
 		const toolCall: ToolCall = {
 			type: "toolCall",
-			id: encodeResponsesToolCallId(item.call_id, item.id),
+			id,
 			name: item.name,
 			arguments: parseStreamingJson(item.arguments || "{}"),
 		};
@@ -1279,13 +1285,15 @@ function handleOutputItemDone(
 	}
 
 	if (item.type === "custom_tool_call") {
+		const id = encodeResponsesToolCallId(item.call_id, item.id);
+		runtime.finalizedToolCallIds.add(id);
 		const rawInput =
 			runtime.currentBlock?.type === "toolCall" && runtime.currentBlock.partialJson
 				? runtime.currentBlock.partialJson
 				: (item.input ?? "");
 		const toolCall: ToolCall = {
 			type: "toolCall",
-			id: encodeResponsesToolCallId(item.call_id, item.id),
+			id,
 			name: item.name,
 			arguments: { input: rawInput },
 			customWireName: item.name,
@@ -1349,6 +1357,10 @@ function handleResponseCompleted(
 	calculateCost(model, output.usage);
 	applyCodexServiceTierPricing(model, output.usage, response?.service_tier, runtime.requestBodyForState.service_tier);
 	output.stopReason = mapOpenAIResponsesStopReason(response?.status as OpenAI.Responses.ResponseStatus | undefined);
+	// A response cut short for length may have stopped mid-tool-call. Flag any
+	// call that never received its `output_item.done` so the agent loop rejects
+	// the truncated arguments instead of executing a best-effort partial parse.
+	flagTruncatedToolCalls(output, output.stopReason, block => runtime.finalizedToolCallIds.has(block.id));
 	if (output.content.some(block => block.type === "toolCall") && output.stopReason === "stop") {
 		output.stopReason = "toolUse";
 	}

package/src/providers/openai-completions.ts

@@ -51,7 +51,7 @@ import {
 	getStreamFirstEventTimeoutMs,
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
-import { parseStreamingJson } from "../utils/json-parse";
+import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { getKimiCommonHeaders } from "../utils/oauth/kimi";
 import { notifyProviderResponse } from "../utils/provider-response";
@@ -889,6 +889,17 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				}
 			}
 
+			// A turn cut short for length may have stopped mid-tool-call. The open
+			// block's `partialArgs` would otherwise be repaired into a plausible-
+			// but-wrong object by `finishCurrentBlock`; flag it first so the agent
+			// loop rejects the truncated call instead of executing it.
+			if (output.stopReason === "length" && currentBlock?.type === "toolCall") {
+				const partial = (currentBlock as { partialArgs?: string }).partialArgs;
+				if (partial !== undefined && !isCompleteJson(partial)) {
+					currentBlock.incompleteArguments = true;
+				}
+			}
+
 			finishCurrentBlock(currentBlock);
 
 			const firstEventTimeoutError = abortTracker.getLocalAbortReason();

package/src/providers/openai-responses-shared.ts

@@ -30,7 +30,7 @@ import {
 } from "../types";
 import { normalizeResponsesToolCallId } from "../utils";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
-import { parseStreamingJson } from "../utils/json-parse";
+import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER, partitionVisionContent } from "./vision-guard";
 
 export function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string {
@@ -710,6 +710,13 @@ export async function processResponsesStream<TApi extends Api>(
 							: "Unknown error (no error details in response)";
 				throw new Error(message);
 			}
+			// A response cut short for length (`incomplete`) may have stopped
+			// mid-tool-call. Any tool-call item still tracked in `items` never
+			// received its terminal `output_item.done`, so it was cut off; flag it
+			// (along with any finalized-but-unparseable JSON call) so the agent loop
+			// rejects it instead of executing repaired/partial arguments.
+			const openBlocks = new Set<unknown>(Array.from(items.values(), entry => entry.block));
+			flagTruncatedToolCalls(output, output.stopReason, block => !openBlocks.has(block));
 			if (output.content.some(block => block.type === "toolCall") && output.stopReason === "stop") {
 				output.stopReason = "toolUse";
 			}
@@ -728,6 +735,41 @@ export async function processResponsesStream<TApi extends Api>(
 	}
 }
 
+/**
+ * Mark tool-call blocks left incomplete by a length-truncated response so the
+ * agent loop rejects them instead of executing a best-effort partial parse.
+ *
+ * The universal signal is finalization: a call that never received its terminal
+ * `output_item.done` (passed in via `isFinalized`) was cut off mid-arguments.
+ * This covers both JSON function calls and raw-input custom tools without
+ * mis-flagging a *completed* custom tool whose raw input is not valid JSON. As a
+ * defensive secondary, a finalized JSON function call whose buffered arguments
+ * still don't parse (e.g. a misbehaving relay) is flagged too. No-op unless the
+ * turn stopped for length.
+ *
+ * Shared by both Responses providers (`openai-responses`, `openai-codex-responses`).
+ */
+export function flagTruncatedToolCalls(
+	output: AssistantMessage,
+	stopReason: StopReason,
+	isFinalized: (block: ToolCall) => boolean,
+): void {
+	if (stopReason !== "length") return;
+	for (const block of output.content) {
+		if (block.type !== "toolCall") continue;
+		if (!isFinalized(block)) {
+			block.incompleteArguments = true;
+			continue;
+		}
+		// Finalized: custom tools carry raw (non-JSON) input and are complete once
+		// finalized; only JSON function calls get the parse double-check.
+		if (!block.customWireName) {
+			const partial = (block as { partialJson?: string }).partialJson;
+			if (partial !== undefined && !isCompleteJson(partial)) block.incompleteArguments = true;
+		}
+	}
+}
+
 export function mapOpenAIResponsesStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason {
 	if (!status) return "stop";
 	switch (status) {

package/src/stream.ts

@@ -84,6 +84,7 @@ const serviceProviderMap: Record<string, KeyResolver> = {
 	xai: "XAI_API_KEY",
 	fireworks: "FIREWORKS_API_KEY",
 	firepass: "FIREPASS_API_KEY",
+	fugu: "FUGU_API_KEY",
 	openrouter: "OPENROUTER_API_KEY",
 	kilo: "KILO_API_KEY",
 	"vercel-ai-gateway": "AI_GATEWAY_API_KEY",

package/src/types.ts

@@ -112,6 +112,7 @@ export type KnownProvider =
 	| "github-copilot"
 	| "fireworks"
 	| "firepass"
+	| "fugu"
 	| "gitlab-duo"
 	| "cursor"
 	| "deepseek"
@@ -490,6 +491,14 @@ export interface ToolCall {
 	 * JSON function tools.
 	 */
 	customWireName?: string;
+	/**
+	 * Set when the provider detected the argument JSON was truncated — the model
+	 * hit its output-token limit (or the response was otherwise cut short) before
+	 * emitting a complete arguments object. The `arguments` field then holds a
+	 * best-effort partial parse and must not be executed as-is; the agent loop
+	 * rejects the call with a retryable error instead.
+	 */
+	incompleteArguments?: boolean;
 }
 
 export interface Usage {

package/src/utils/json-parse.ts

@@ -146,3 +146,21 @@ export function parseStreamingJson<T = Record<string, unknown>>(partialJson: str
 		}
 	}
 }
+
+/**
+ * Whether a string is a complete, well-formed JSON document (strict parse, no
+ * repair). Used to distinguish a tool-call argument blob that finished cleanly
+ * from one that was cut off mid-stream (truncation). An empty / whitespace-only
+ * string is treated as complete: a tool invoked with no arguments legitimately
+ * streams an empty buffer and must not be flagged as truncated.
+ */
+export function isCompleteJson(text: string | undefined): boolean {
+	const trimmed = text?.trim();
+	if (!trimmed) return true;
+	try {
+		JSON.parse(trimmed);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/utils/oauth/fugu.ts

@@ -0,0 +1,15 @@
+/** Sakana Fugu login flow (API key paste against https://api.sakana.ai/v1). */
+import { createApiKeyLogin } from "./api-key-login";
+
+export const loginFugu = createApiKeyLogin({
+	providerLabel: "Sakana Fugu",
+	authUrl: "https://fugu.sakana.ai/",
+	instructions: "Create or copy your Sakana Fugu API key",
+	promptMessage: "Paste your Sakana Fugu API key",
+	placeholder: "fugu_...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "Sakana Fugu",
+		modelsUrl: "https://api.sakana.ai/v1/models",
+	},
+});

package/src/utils/oauth/index.ts

@@ -75,6 +75,11 @@ const builtInOAuthProviders: OAuthProviderInfo[] = [
 		name: "Fire Pass (Fireworks Kimi K2.6 Turbo subscription)",
 		available: true,
 	},
+	{
+		id: "fugu",
+		name: "Sakana Fugu (API key)",
+		available: true,
+	},
 	{
 		id: "github-copilot",
 		name: "GitHub Copilot",
@@ -353,6 +358,7 @@ export async function refreshOAuthToken(
 		case "cerebras":
 		case "fireworks":
 		case "firepass":
+		case "fugu":
 		case "nvidia":
 		case "nanogpt":
 		case "synthetic":

package/src/utils/oauth/types.ts

@@ -17,6 +17,7 @@ export type OAuthProvider =
 	| "deepseek"
 	| "fireworks"
 	| "firepass"
+	| "fugu"
 	| "github-copilot"
 	| "google-gemini-cli"
 	| "google-antigravity"

package/src/utils/overflow.ts

@@ -52,14 +52,26 @@ const OVERFLOW_PATTERNS = [
 	/\b413\b.*\b(request|payload|entity)\b.*\btoo large\b/i, // "413 Request Entity Too Large" variants
 	/model_context_window_exceeded/i, // z.ai non-standard finish_reason surfaced as error text
 ];
+/**
+ * Threshold below which a "successful" (stopReason "stop") response with empty
+ * content is considered anomalous. Some proxies (notably LiteLLM) return an
+ * empty `choices[0].message.content` with a near-zero `usage` (e.g. input: 1,
+ * output: 1) when the upstream model context window is exceeded, instead of
+ * surfacing a proper error. The total token count for such a response is well
+ * below any realistic turn, so we treat it as a proxy-level overflow signal.
+ */
+const EMPTY_RESPONSE_USAGE_THRESHOLD = 5;
 /**
  * Check if an assistant message represents a context overflow error.
  *
- * This handles two cases:
+ * This handles three cases:
  * 1. Error-based overflow: Most providers return stopReason "error" with a
  *    specific error message pattern.
  * 2. Silent overflow: Some providers accept overflow requests and return
  *    successfully. For these, we check if usage.input exceeds the context window.
+ * 3. Proxy-level overflow: Some proxies (e.g. LiteLLM) return a "successful"
+ *    response with empty content and a fabricated near-zero usage when the
+ *    upstream model's context window is exceeded.
  *
  * ## Reliability by Provider
  *
@@ -83,6 +95,13 @@ const OVERFLOW_PATTERNS = [
  * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
  *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
  * - Ollama: Silently truncates input without error. Cannot be detected via this function.
+ * - LiteLLM proxy: Returns a "successful" response with empty content and a
+ *   fabricated near-zero usage (e.g. input: 1, output: 1) when the upstream
+ *   model's context window is exceeded. Detected via Case 3 (empty content +
+ *   anomalously low usage). Note: the LiteLLM proxy's context limit may differ
+ *   from the underlying model's advertised contextWindow (e.g. configured via
+ *   `model_info.max_tokens` in LiteLLM's config.yaml), so Case 2 (which compares
+ *   usage.input against contextWindow) may not catch it.
  *   The response will have usage.input < expected, but we don't know the expected value.
  *
  * ## Custom Providers
@@ -126,6 +145,21 @@ export function isContextOverflow(message: AssistantMessage, contextWindow?: num
 		}
 	}
 
+	// Case 3: Empty response with anomalously low usage (proxy-level overflow)
+	// Some proxies (e.g. LiteLLM) return a "successful" response (stopReason "stop")
+	// with empty content and a near-zero token count when the upstream model's
+	// context window is exceeded. This is distinct from silent overflow (Case 2),
+	// where the provider reports the real input token count. Here the proxy
+	// fabricates a bogus usage (input: 1, output: 1) that is far below any
+	// realistic turn, so we detect it heuristically.
+	if (
+		message.stopReason === "stop" &&
+		message.content.length === 0 &&
+		message.usage.input + message.usage.output <= EMPTY_RESPONSE_USAGE_THRESHOLD
+	) {
+		return true;
+	}
+
 	return false;
 }