antigravity-auth 1.6.0

package/dist/src/plugin/request-helpers.d.ts

@@ -0,0 +1,281 @@
+import type { GoogleSearchConfig } from "./transform/types";
+/**
+ * Cleans a JSON schema for Antigravity API compatibility.
+ * Transforms unsupported features into description hints while preserving semantic information.
+ *
+ * Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
+ */
+export declare function cleanJSONSchemaForAntigravity(schema: any): any;
+export interface AntigravityApiError {
+    code?: number;
+    message?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+/**
+ * Minimal representation of Antigravity API responses we touch.
+ */
+export interface AntigravityApiBody {
+    response?: unknown;
+    error?: AntigravityApiError;
+    [key: string]: unknown;
+}
+/**
+ * Usage metadata exposed by Antigravity responses. Fields are optional to reflect partial payloads.
+ */
+export interface AntigravityUsageMetadata {
+    totalTokenCount?: number;
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    cachedContentTokenCount?: number;
+    thoughtsTokenCount?: number;
+}
+/**
+ * Normalized thinking configuration accepted by Antigravity.
+ */
+export interface ThinkingConfig {
+    thinkingBudget?: number;
+    includeThoughts?: boolean;
+}
+/**
+ * Default token budget for thinking/reasoning. 16000 tokens provides sufficient
+ * space for complex reasoning while staying within typical model limits.
+ */
+export declare const DEFAULT_THINKING_BUDGET = 16000;
+/**
+ * Checks if a model name indicates thinking/reasoning capability.
+ * Models with "thinking", "gemini-3", or "opus" in their name support extended thinking.
+ */
+export declare function isThinkingCapableModel(modelName: string): boolean;
+/**
+ * Extracts thinking configuration from various possible request locations.
+ * Supports both Gemini-style thinkingConfig and Anthropic-style thinking options.
+ */
+export declare function extractThinkingConfig(requestPayload: Record<string, unknown>, rawGenerationConfig: Record<string, unknown> | undefined, extraBody: Record<string, unknown> | undefined): ThinkingConfig | undefined;
+/**
+ * Variant thinking config extracted from OpenCode's providerOptions.
+ */
+export interface VariantThinkingConfig {
+    /** Gemini 3 native thinking level (low/medium/high) */
+    thinkingLevel?: string;
+    /** Numeric thinking budget for Claude and Gemini 2.5 */
+    thinkingBudget?: number;
+    /** Whether to include thoughts in output */
+    includeThoughts?: boolean;
+    /** Google Search configuration */
+    googleSearch?: GoogleSearchConfig;
+}
+/**
+ * Extracts variant thinking config from OpenCode's providerOptions.
+ *
+ * All Antigravity models route through the Google provider, so we only check
+ * providerOptions.google. Supports two formats:
+ *
+ * 1. Gemini 3 native: { google: { thinkingLevel: "high", includeThoughts: true } }
+ * 2. Budget-based (Claude/Gemini 2.5): { google: { thinkingConfig: { thinkingBudget: 32000 } } }
+ *
+ * When providerOptions is missing or has no thinking config (common with OpenCode
+ * model variants), falls back to extracting from generationConfig directly:
+ * 3. generationConfig fallback: { thinkingConfig: { thinkingBudget: 8192 } }
+ */
+export declare function extractVariantThinkingConfig(providerOptions: Record<string, unknown> | undefined, generationConfig?: Record<string, unknown> | undefined): VariantThinkingConfig | undefined;
+/**
+ * Determines the final thinking configuration based on model capabilities and user settings.
+ * For Claude thinking models, we keep thinking enabled even in multi-turn conversations.
+ * The filterUnsignedThinkingBlocks function will handle signature validation/restoration.
+ */
+export declare function resolveThinkingConfig(userConfig: ThinkingConfig | undefined, isThinkingModel: boolean, _isClaudeModel: boolean, _hasAssistantHistory: boolean): ThinkingConfig | undefined;
+/**
+ * Filters thinking blocks from contents unless the signature matches our cache.
+ * Attempts to restore signatures from cache for thinking blocks that lack signatures.
+ *
+ * @param contents - The contents array from the request
+ * @param sessionId - Optional session ID for signature cache lookup
+ * @param getCachedSignatureFn - Optional function to retrieve cached signatures
+ */
+export declare function filterUnsignedThinkingBlocks(contents: any[], sessionId?: string, getCachedSignatureFn?: (sessionId: string, text: string) => string | undefined, isClaudeModel?: boolean): any[];
+/**
+ * Filters thinking blocks from Anthropic-style messages[] payloads using cached signatures.
+ */
+export declare function filterMessagesThinkingBlocks(messages: any[], sessionId?: string, getCachedSignatureFn?: (sessionId: string, text: string) => string | undefined, isClaudeModel?: boolean): any[];
+export declare function deepFilterThinkingBlocks(payload: unknown, sessionId?: string, getCachedSignatureFn?: (sessionId: string, text: string) => string | undefined, isClaudeModel?: boolean): unknown;
+/**
+ * Transforms thinking/reasoning content in response parts to OpenCode's expected format.
+ * Handles both Gemini-style (thought: true) and Anthropic-style (type: "thinking") formats.
+ * Also extracts reasoning_content for Anthropic-style responses.
+ */
+export declare function transformThinkingParts(response: unknown): unknown;
+/**
+ * Ensures thinkingConfig is valid: includeThoughts only allowed when budget > 0.
+ */
+export declare function normalizeThinkingConfig(config: unknown): ThinkingConfig | undefined;
+/**
+ * Parses an Antigravity API body; handles array-wrapped responses the API sometimes returns.
+ */
+export declare function parseAntigravityApiBody(rawText: string): AntigravityApiBody | null;
+/**
+ * Extracts usageMetadata from a response object, guarding types.
+ */
+export declare function extractUsageMetadata(body: AntigravityApiBody): AntigravityUsageMetadata | null;
+/**
+ * Walks SSE lines to find a usage-bearing response chunk.
+ */
+export declare function extractUsageFromSsePayload(payload: string): AntigravityUsageMetadata | null;
+/**
+ * Enhances 404 errors for Antigravity models with a direct preview-access message.
+ */
+export declare function rewriteAntigravityPreviewAccessError(body: AntigravityApiBody, status: number, requestedModel?: string): AntigravityApiBody | null;
+/**
+ * Checks if a JSON response body represents an empty response.
+ *
+ * Empty responses occur when:
+ * - No candidates in Gemini format
+ * - No choices in OpenAI format
+ * - Candidates/choices exist but have no content
+ *
+ * @param text - The response body text (should be valid JSON)
+ * @returns true if the response is empty
+ */
+export declare function isEmptyResponseBody(text: string): boolean;
+/**
+ * Checks if a streaming SSE response yielded zero meaningful chunks.
+ *
+ * This is used after consuming a streaming response to determine if retry is needed.
+ */
+export interface StreamingChunkCounter {
+    increment: () => void;
+    getCount: () => number;
+    hasContent: () => boolean;
+}
+export declare function createStreamingChunkCounter(): StreamingChunkCounter;
+/**
+ * Checks if an SSE line contains meaningful content.
+ *
+ * @param line - A single SSE line (e.g., "data: {...}")
+ * @returns true if the line contains content worth counting
+ */
+export declare function isMeaningfulSseLine(line: string): boolean;
+export declare function recursivelyParseJsonStrings(obj: unknown, skipParseKeys?: Set<string>, currentKey?: string): unknown;
+/**
+ * Groups function calls with their responses, handling ID mismatches.
+ *
+ * This is a port of LLM-API-Key-Proxy's _fix_tool_response_grouping() function.
+ *
+ * When context compaction or other processes strip tool responses, the tool call
+ * IDs become orphaned. This function attempts to recover by:
+ *
+ * 1. Pass 1: Match by exact ID (normal case)
+ * 2. Pass 2: Match by function name (for ID mismatches)
+ * 3. Pass 3: Match "unknown_function" orphans or take first available
+ * 4. Fallback: Create placeholder responses for missing tool results
+ *
+ * @param contents - Array of Gemini-style content messages
+ * @returns Fixed contents array with matched tool responses
+ */
+export declare function fixToolResponseGrouping(contents: any[]): any[];
+/**
+ * Checks if contents have any tool call/response ID mismatches.
+ *
+ * @param contents - Array of Gemini-style content messages
+ * @returns Object with mismatch details
+ */
+export declare function detectToolIdMismatches(contents: any[]): {
+    hasMismatches: boolean;
+    expectedIds: string[];
+    foundIds: string[];
+    missingIds: string[];
+    orphanIds: string[];
+};
+/**
+ * Find orphaned tool_use IDs (tool_use without matching tool_result).
+ * Works on Claude format messages.
+ */
+export declare function findOrphanedToolUseIds(messages: any[]): Set<string>;
+/**
+ * Fix orphaned tool_use blocks in Claude format messages.
+ * Mirrors fixToolResponseGrouping() but for Claude's messages[] format.
+ *
+ * Claude format:
+ * - assistant message with content[]: { type: 'tool_use', id, name, input }
+ * - user message with content[]: { type: 'tool_result', tool_use_id, content }
+ *
+ * @param messages - Claude format messages array
+ * @returns Fixed messages with placeholder tool_results for orphans
+ */
+export declare function fixClaudeToolPairing(messages: any[]): any[];
+/**
+ * Validate and fix tool pairing with fallback nuclear option.
+ * Defense in depth: tries gentle fix first, then nuclear removal.
+ */
+export declare function validateAndFixClaudeToolPairing(messages: any[]): any[];
+/**
+ * Injects parameter signatures into tool descriptions.
+ * Port of LLM-API-Key-Proxy's _inject_signature_into_descriptions()
+ *
+ * This helps prevent tool hallucination by explicitly listing parameters
+ * in the description, making it harder for the model to hallucinate
+ * parameters from its training data.
+ *
+ * @param tools - Array of tool definitions (Gemini format)
+ * @param promptTemplate - Template for the signature (default: "\\n\\nSTRICT PARAMETERS: {params}.")
+ * @returns Modified tools array with signatures injected
+ */
+export declare function injectParameterSignatures(tools: any[], promptTemplate?: string): any[];
+/**
+ * Injects a tool hardening system instruction into the request payload.
+ * Port of LLM-API-Key-Proxy's _inject_tool_hardening_instruction()
+ *
+ * @param payload - The Gemini request payload
+ * @param instructionText - The instruction text to inject
+ */
+export declare function injectToolHardeningInstruction(payload: Record<string, unknown>, instructionText: string): void;
+/**
+ * Assigns IDs to functionCall parts and returns the pending call IDs by name.
+ * This is the first pass of tool ID assignment.
+ *
+ * @param contents - Gemini-style contents array
+ * @returns Object with modified contents and pending call IDs map
+ */
+export declare function assignToolIdsToContents(contents: any[]): {
+    contents: any[];
+    pendingCallIdsByName: Map<string, string[]>;
+    toolCallCounter: number;
+};
+/**
+ * Matches functionResponse IDs to their corresponding functionCall IDs.
+ * This is the second pass of tool ID assignment.
+ *
+ * @param contents - Gemini-style contents array
+ * @param pendingCallIdsByName - Map of function names to pending call IDs
+ * @returns Modified contents with matched response IDs
+ */
+export declare function matchResponseIdsToContents(contents: any[], pendingCallIdsByName: Map<string, string[]>): any[];
+/**
+ * Applies all tool fixes to a request payload for Claude models.
+ * This includes:
+ * 1. Tool ID assignment for functionCalls
+ * 2. Response ID matching for functionResponses
+ * 3. Orphan recovery via fixToolResponseGrouping
+ * 4. Claude format pairing fix via validateAndFixClaudeToolPairing
+ *
+ * @param payload - Request payload object
+ * @param isClaude - Whether this is a Claude model request
+ * @returns Object with fix applied status
+ */
+export declare function applyToolPairingFixes(payload: Record<string, unknown>, isClaude: boolean): {
+    contentsFixed: boolean;
+    messagesFixed: boolean;
+};
+/**
+ * Creates a synthetic Claude SSE streaming response with error content.
+ *
+ * When returning HTTP 400/500 errors to OpenCode, the session becomes locked
+ * and the user cannot use /compact or other commands. This function creates
+ * a fake "successful" SSE response (200 OK) with the error message as text content,
+ * allowing the user to continue using the session.
+ *
+ * @param errorMessage - The error message to include in the response
+ * @param requestedModel - The model that was requested
+ * @returns A Response object with synthetic SSE stream
+ */
+export declare function createSyntheticErrorResponse(errorMessage: string, requestedModel?: string): Response;