@sayknow-cli/ai 0.3.0 → 0.3.2

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 SKC 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 SKC-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/request-transformer.ts

@@ -23,6 +23,7 @@ export interface InputItem {
 	name?: string;
 	output?: unknown;
 	arguments?: unknown;
+	encrypted_content?: unknown;
 }
 
 export interface RequestBody {
@@ -62,6 +63,57 @@ function getReasoningConfig(model: Model<Api>, options: CodexRequestOptions): Re
 	return config;
 }
 
+function describeTextPartValue(value: unknown): string {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+
+function normalizeTextPartValue(value: unknown, path: string): string {
+	if (typeof value === "string") return value.toWellFormed();
+	try {
+		const encoded = JSON.stringify(value);
+		if (typeof encoded === "string") return encoded.toWellFormed();
+	} catch {
+		// Fall through to the actionable local error below.
+	}
+	throw new Error(
+		`Invalid Codex request text part at ${path}: expected a string or JSON-serializable value, received ${describeTextPartValue(value)}. Normalize compacted continuation content before sending to Codex.`,
+	);
+}
+
+function normalizeTextPartFields(content: unknown, path: string): unknown {
+	if (typeof content === "string") return content.toWellFormed();
+	if (!Array.isArray(content)) return content;
+	return content.map((part, index) => {
+		if (!part || typeof part !== "object") return part;
+		const normalizedPart = { ...(part as Record<string, unknown>) };
+		if ("text" in normalizedPart) {
+			normalizedPart.text = normalizeTextPartValue(normalizedPart.text, `${path}[${index}].text`);
+		}
+		return normalizedPart;
+	});
+}
+
+function normalizeInputTextPartFields(input: InputItem[] | undefined): InputItem[] | undefined {
+	if (!Array.isArray(input)) return input;
+	return input.map((item, itemIndex) => {
+		const normalizedItem = { ...item };
+		const itemRecord = normalizedItem as Record<string, unknown>;
+		if ("encrypted_content" in itemRecord) {
+			if (typeof itemRecord.encrypted_content === "string") {
+				itemRecord.encrypted_content = itemRecord.encrypted_content.toWellFormed();
+			} else {
+				delete itemRecord.encrypted_content;
+			}
+		}
+		if (normalizedItem.type === "message") {
+			normalizedItem.content = normalizeTextPartFields(normalizedItem.content, `input[${itemIndex}].content`);
+		}
+		return normalizedItem;
+	});
+}
+
 function filterInput(input: InputItem[] | undefined): InputItem[] | undefined {
 	if (!Array.isArray(input)) return input;
 
@@ -121,6 +173,7 @@ export async function transformRequestBody(
 				return item;
 			});
 		}
+		body.input = normalizeInputTextPartFields(body.input);
 	}
 
 	if (prompt?.developerMessages && prompt.developerMessages.length > 0 && Array.isArray(body.input)) {

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

@@ -44,6 +44,7 @@ import {
 	getOpenAIResponsesHistoryItems,
 	getOpenAIResponsesHistoryPayload,
 	normalizeSystemPrompts,
+	sanitizeOpenAIResponsesHistoryItemsForReplay,
 } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
@@ -78,6 +79,7 @@ import {
 	convertResponsesInputContent,
 	encodeResponsesToolCallId,
 	encodeTextSignatureV1,
+	flagTruncatedToolCalls,
 	mapOpenAIResponsesStopReason,
 	populateResponsesUsageFromResponse,
 } from "./openai-responses-shared";
@@ -254,6 +256,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 +914,7 @@ function createCodexStreamRuntime(initial: {
 		providerRetryAttempt: 0,
 		sawTerminalEvent: false,
 		canSafelyReplayWebsocketOverSse: true,
+		finalizedToolCallIds: new Set<string>(),
 	};
 }
 
@@ -1267,9 +1272,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 +1286,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 +1358,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";
 	}
@@ -2538,17 +2551,16 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 	for (const msg of transformedMessages) {
 		if (msg.role === "user" || msg.role === "developer") {
 			const providerPayload = (msg as { providerPayload?: AssistantMessage["providerPayload"] }).providerPayload;
-			const historyItems = getOpenAIResponsesHistoryItems(providerPayload, model.provider) as
-				| Array<ResponseInput[number]>
-				| undefined;
+			const historyItems = getOpenAIResponsesHistoryItems(providerPayload, model.provider);
 			if (historyItems) {
-				for (const item of historyItems) {
+				const sanitizedHistoryItems = sanitizeOpenAIResponsesHistoryItemsForReplay(historyItems);
+				for (const item of sanitizedHistoryItems) {
 					const maybe = item as { type?: string; call_id?: string };
 					if (maybe.type === "custom_tool_call" && typeof maybe.call_id === "string") {
 						customCallIds.add(maybe.call_id);
 					}
 				}
-				messages.push(...historyItems);
+				messages.push(...sanitizedHistoryItems);
 				msgIndex += 1;
 				continue;
 			}
@@ -2567,18 +2579,19 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 				model.provider,
 				assistantMsg.provider,
 			);
-			const historyItems = providerPayload?.items as Array<ResponseInput[number]> | undefined;
+			const historyItems = providerPayload?.items;
 			if (historyItems) {
-				for (const item of historyItems) {
+				const sanitizedHistoryItems = sanitizeOpenAIResponsesHistoryItemsForReplay(historyItems);
+				for (const item of sanitizedHistoryItems) {
 					const maybe = item as { type?: string; call_id?: string };
 					if (maybe.type === "custom_tool_call" && typeof maybe.call_id === "string") {
 						customCallIds.add(maybe.call_id);
 					}
 				}
 				if (providerPayload?.dt) {
-					messages.push(...historyItems);
+					messages.push(...sanitizedHistoryItems);
 				} else {
-					messages.splice(0, messages.length, ...historyItems);
+					messages.splice(0, messages.length, ...sanitizedHistoryItems);
 					// Keep customCallIds from the pre-splice state since historyItems may re-introduce them.
 				}
 				msgIndex += 1;

package/src/providers/openai-completions-compat.ts

@@ -103,6 +103,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		provider === "opencode-go" ||
 		baseUrl.includes("opencode.ai");
 	const isOpenCodeProvider = provider === "opencode-go" || provider === "opencode-zen";
+	const isOpenCodeGoReasoning = provider === "opencode-go" && Boolean(model.reasoning);
 
 	const useMaxTokens =
 		provider === "mistral" ||
@@ -194,7 +195,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		supportsReasoningEffort: !isGrok && !isZai,
 		reasoningEffortMap,
 		supportsUsageInStreaming: !isCerebras,
-		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel,
+		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel || isOpenCodeGoReasoning,
 		disableReasoningOnToolChoice: isDeepseekFamily && Boolean(model.reasoning) && !isOpenRouter,
 		supportsToolChoice: !isDirectDeepseekReasoning,
 		supportsForcedToolChoice: true,

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":
@@ -466,6 +472,9 @@ export async function getOAuthApiKey(
 	return { newCredentials: creds, apiKey };
 }
 
+export function resolveOAuthStorageProvider(provider: OAuthProviderId): OAuthProviderId {
+	return provider === "openai-codex-device" ? "openai-codex" : provider;
+}
 /**
  * Get list of OAuth providers.
  */

package/src/utils/oauth/types.ts

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