antigravity-auth 1.6.0 → 1.7.0

package/dist/src/plugin/thinking-recovery.d.ts

@@ -1,89 +0,0 @@
-/**
- * Thinking Recovery Module
- *
- * Minimal implementation for recovering from corrupted thinking state.
- * When Claude's conversation history gets corrupted (thinking blocks stripped/malformed),
- * this module provides a "last resort" recovery by closing the current turn and starting fresh.
- *
- * Philosophy: "Let it crash and start again" - Instead of trying to fix corrupted state,
- * we abandon the corrupted turn and let Claude generate fresh thinking.
- */
-/**
- * Conversation state for thinking mode analysis
- */
-export interface ConversationState {
-    /** True if we're in an incomplete tool use loop (ends with functionResponse) */
-    inToolLoop: boolean;
-    /** Index of first model message in current turn */
-    turnStartIdx: number;
-    /** Whether the TURN started with thinking */
-    turnHasThinking: boolean;
-    /** Index of last model message */
-    lastModelIdx: number;
-    /** Whether last model msg has thinking */
-    lastModelHasThinking: boolean;
-    /** Whether last model msg has tool calls */
-    lastModelHasToolCalls: boolean;
-}
-/**
- * Analyzes conversation state to detect tool use loops and thinking mode issues.
- *
- * Key insight: A "turn" can span multiple assistant messages in a tool-use loop.
- * We need to find the TURN START (first assistant message after last real user message)
- * and check if THAT message had thinking, not just the last assistant message.
- */
-export declare function analyzeConversationState(contents: any[]): ConversationState;
-/**
- * Closes an incomplete tool loop by injecting synthetic messages to start a new turn.
- *
- * This is the "let it crash and start again" recovery mechanism.
- *
- * When we detect:
- * - We're in a tool loop (conversation ends with functionResponse)
- * - The tool call was made WITHOUT thinking (thinking was stripped/corrupted)
- * - We NOW want to enable thinking
- *
- * Instead of trying to fix the corrupted state, we:
- * 1. Strip ALL thinking blocks (removes any corrupted ones)
- * 2. Add synthetic MODEL message to complete the non-thinking turn
- * 3. Add synthetic USER message to start a NEW turn
- *
- * This allows Claude to generate fresh thinking for the new turn.
- */
-export declare function closeToolLoopForThinking(contents: any[]): any[];
-/**
- * Checks if conversation state requires tool loop closure for thinking recovery.
- *
- * Returns true if:
- * - We're in a tool loop (state.inToolLoop)
- * - The turn didn't start with thinking (state.turnHasThinking === false)
- *
- * This is the trigger for the "let it crash and start again" recovery.
- */
-export declare function needsThinkingRecovery(state: ConversationState): boolean;
-/**
- * Detects if a message looks like it was compacted from a thinking-enabled turn.
- *
- * This is a heuristic to distinguish between:
- * - "Never had thinking" (model didn't use thinking mode)
- * - "Thinking was stripped" (context compaction removed thinking blocks)
- *
- * Port of LLM-API-Key-Proxy's _looks_like_compacted_thinking_turn()
- *
- * Heuristics:
- * 1. Has functionCall parts (typical thinking flow produces tool calls)
- * 2. No thinking parts (thought: true)
- * 3. No text content before functionCall (thinking responses usually have text)
- *
- * @param msg - A single message from the conversation
- * @returns true if the message looks like thinking was stripped
- */
-export declare function looksLikeCompactedThinkingTurn(msg: any): boolean;
-/**
- * Checks if any message in the current turn looks like it was compacted.
- *
- * @param contents - Full conversation contents
- * @param turnStartIdx - Index of the first model message in current turn
- * @returns true if any model message in the turn looks compacted
- */
-export declare function hasPossibleCompactedThinking(contents: any[], turnStartIdx: number): boolean;

package/dist/src/plugin/thinking-recovery.js

@@ -1,289 +0,0 @@
-/**
- * Thinking Recovery Module
- *
- * Minimal implementation for recovering from corrupted thinking state.
- * When Claude's conversation history gets corrupted (thinking blocks stripped/malformed),
- * this module provides a "last resort" recovery by closing the current turn and starting fresh.
- *
- * Philosophy: "Let it crash and start again" - Instead of trying to fix corrupted state,
- * we abandon the corrupted turn and let Claude generate fresh thinking.
- */
-// ============================================================================
-// ============================================================================
-/**
- * Checks if a message part is a thinking/reasoning block.
- */
-function isThinkingPart(part) {
-    if (!part || typeof part !== "object")
-        return false;
-    return (part.thought === true ||
-        part.type === "thinking" ||
-        part.type === "redacted_thinking");
-}
-/**
- * Checks if a message part is a function response (tool result).
- */
-function isFunctionResponsePart(part) {
-    return part && typeof part === "object" && "functionResponse" in part;
-}
-/**
- * Checks if a message part is a function call.
- */
-function isFunctionCallPart(part) {
-    return part && typeof part === "object" && "functionCall" in part;
-}
-/**
- * Checks if a message is a tool result container (user role with functionResponse).
- */
-function isToolResultMessage(msg) {
-    if (!msg || msg.role !== "user")
-        return false;
-    const parts = msg.parts || [];
-    return parts.some(isFunctionResponsePart);
-}
-/**
- * Checks if a message contains thinking/reasoning content.
- */
-function messageHasThinking(msg) {
-    if (!msg || typeof msg !== "object")
-        return false;
-    if (Array.isArray(msg.parts)) {
-        return msg.parts.some(isThinkingPart);
-    }
-    if (Array.isArray(msg.content)) {
-        return msg.content.some((block) => block?.type === "thinking" || block?.type === "redacted_thinking");
-    }
-    return false;
-}
-/**
- * Checks if a message contains tool calls.
- */
-function messageHasToolCalls(msg) {
-    if (!msg || typeof msg !== "object")
-        return false;
-    if (Array.isArray(msg.parts)) {
-        return msg.parts.some(isFunctionCallPart);
-    }
-    // Anthropic format: content array with tool_use
-    if (Array.isArray(msg.content)) {
-        return msg.content.some((block) => block?.type === "tool_use");
-    }
-    return false;
-}
-// ============================================================================
-// ============================================================================
-/**
- * Analyzes conversation state to detect tool use loops and thinking mode issues.
- *
- * Key insight: A "turn" can span multiple assistant messages in a tool-use loop.
- * We need to find the TURN START (first assistant message after last real user message)
- * and check if THAT message had thinking, not just the last assistant message.
- */
-export function analyzeConversationState(contents) {
-    const state = {
-        inToolLoop: false,
-        turnStartIdx: -1,
-        turnHasThinking: false,
-        lastModelIdx: -1,
-        lastModelHasThinking: false,
-        lastModelHasToolCalls: false,
-    };
-    if (!Array.isArray(contents) || contents.length === 0) {
-        return state;
-    }
-    let lastRealUserIdx = -1;
-    for (let i = 0; i < contents.length; i++) {
-        const msg = contents[i];
-        if (msg?.role === "user" && !isToolResultMessage(msg)) {
-            lastRealUserIdx = i;
-        }
-    }
-    for (let i = 0; i < contents.length; i++) {
-        const msg = contents[i];
-        const role = msg?.role;
-        if (role === "model" || role === "assistant") {
-            const hasThinking = messageHasThinking(msg);
-            const hasToolCalls = messageHasToolCalls(msg);
-            if (i > lastRealUserIdx && state.turnStartIdx === -1) {
-                state.turnStartIdx = i;
-                state.turnHasThinking = hasThinking;
-            }
-            state.lastModelIdx = i;
-            state.lastModelHasToolCalls = hasToolCalls;
-            state.lastModelHasThinking = hasThinking;
-        }
-    }
-    if (contents.length > 0) {
-        const lastMsg = contents[contents.length - 1];
-        if (lastMsg?.role === "user" && isToolResultMessage(lastMsg)) {
-            state.inToolLoop = true;
-        }
-    }
-    return state;
-}
-// ============================================================================
-// ============================================================================
-/**
- * Strips all thinking blocks from messages.
- * Used before injecting synthetic messages to avoid invalid thinking patterns.
- */
-function stripAllThinkingBlocks(contents) {
-    return contents.map((content) => {
-        if (!content || typeof content !== "object")
-            return content;
-        if (Array.isArray(content.parts)) {
-            const filteredParts = content.parts.filter((part) => !isThinkingPart(part));
-            if (filteredParts.length === 0 && content.parts.length > 0) {
-                return content;
-            }
-            return { ...content, parts: filteredParts };
-        }
-        if (Array.isArray(content.content)) {
-            const filteredContent = content.content.filter((block) => block?.type !== "thinking" && block?.type !== "redacted_thinking");
-            if (filteredContent.length === 0 && content.content.length > 0) {
-                return content;
-            }
-            return { ...content, content: filteredContent };
-        }
-        return content;
-    });
-}
-/**
- * Counts tool results at the end of the conversation.
- */
-function countTrailingToolResults(contents) {
-    let count = 0;
-    for (let i = contents.length - 1; i >= 0; i--) {
-        const msg = contents[i];
-        if (msg?.role === "user") {
-            const parts = msg.parts || [];
-            const functionResponses = parts.filter(isFunctionResponsePart);
-            if (functionResponses.length > 0) {
-                count += functionResponses.length;
-            }
-            else {
-                break; // Real user message, stop counting
-            }
-        }
-        else if (msg?.role === "model" || msg?.role === "assistant") {
-            break; // Stop at the model that made the tool calls
-        }
-    }
-    return count;
-}
-/**
- * Closes an incomplete tool loop by injecting synthetic messages to start a new turn.
- *
- * This is the "let it crash and start again" recovery mechanism.
- *
- * When we detect:
- * - We're in a tool loop (conversation ends with functionResponse)
- * - The tool call was made WITHOUT thinking (thinking was stripped/corrupted)
- * - We NOW want to enable thinking
- *
- * Instead of trying to fix the corrupted state, we:
- * 1. Strip ALL thinking blocks (removes any corrupted ones)
- * 2. Add synthetic MODEL message to complete the non-thinking turn
- * 3. Add synthetic USER message to start a NEW turn
- *
- * This allows Claude to generate fresh thinking for the new turn.
- */
-export function closeToolLoopForThinking(contents) {
-    const strippedContents = stripAllThinkingBlocks(contents);
-    const toolResultCount = countTrailingToolResults(strippedContents);
-    let syntheticModelContent;
-    if (toolResultCount === 0) {
-        syntheticModelContent = "[Processing previous context.]";
-    }
-    else if (toolResultCount === 1) {
-        syntheticModelContent = "[Tool execution completed.]";
-    }
-    else {
-        syntheticModelContent = `[${toolResultCount} tool executions completed.]`;
-    }
-    const syntheticModel = {
-        role: "model",
-        parts: [{ text: syntheticModelContent }],
-    };
-    const syntheticUser = {
-        role: "user",
-        parts: [{ text: "[Continue]" }],
-    };
-    return [...strippedContents, syntheticModel, syntheticUser];
-}
-/**
- * Checks if conversation state requires tool loop closure for thinking recovery.
- *
- * Returns true if:
- * - We're in a tool loop (state.inToolLoop)
- * - The turn didn't start with thinking (state.turnHasThinking === false)
- *
- * This is the trigger for the "let it crash and start again" recovery.
- */
-export function needsThinkingRecovery(state) {
-    return state.inToolLoop && !state.turnHasThinking;
-}
-// ============================================================================
-// ============================================================================
-/**
- * Detects if a message looks like it was compacted from a thinking-enabled turn.
- *
- * This is a heuristic to distinguish between:
- * - "Never had thinking" (model didn't use thinking mode)
- * - "Thinking was stripped" (context compaction removed thinking blocks)
- *
- * Port of LLM-API-Key-Proxy's _looks_like_compacted_thinking_turn()
- *
- * Heuristics:
- * 1. Has functionCall parts (typical thinking flow produces tool calls)
- * 2. No thinking parts (thought: true)
- * 3. No text content before functionCall (thinking responses usually have text)
- *
- * @param msg - A single message from the conversation
- * @returns true if the message looks like thinking was stripped
- */
-export function looksLikeCompactedThinkingTurn(msg) {
-    if (!msg || typeof msg !== "object")
-        return false;
-    const parts = msg.parts || [];
-    if (parts.length === 0)
-        return false;
-    const hasFunctionCall = parts.some((p) => p && typeof p === "object" && p.functionCall);
-    if (!hasFunctionCall)
-        return false;
-    const hasThinking = parts.some((p) => p &&
-        typeof p === "object" &&
-        (p.thought === true || p.type === "thinking" || p.type === "redacted_thinking"));
-    if (hasThinking)
-        return false;
-    const hasTextBeforeFunctionCall = parts.some((p, idx) => {
-        if (!p || typeof p !== "object")
-            return false;
-        const firstFuncIdx = parts.findIndex((fp) => fp && typeof fp === "object" && fp.functionCall);
-        if (idx >= firstFuncIdx)
-            return false;
-        return ("text" in p &&
-            typeof p.text === "string" &&
-            p.text.trim().length > 0 &&
-            !p.thought);
-    });
-    return !hasTextBeforeFunctionCall;
-}
-/**
- * Checks if any message in the current turn looks like it was compacted.
- *
- * @param contents - Full conversation contents
- * @param turnStartIdx - Index of the first model message in current turn
- * @returns true if any model message in the turn looks compacted
- */
-export function hasPossibleCompactedThinking(contents, turnStartIdx) {
-    if (!Array.isArray(contents) || turnStartIdx < 0)
-        return false;
-    for (let i = turnStartIdx; i < contents.length; i++) {
-        const msg = contents[i];
-        if (msg?.role === "model" && looksLikeCompactedThinkingTurn(msg)) {
-            return true;
-        }
-    }
-    return false;
-}

package/dist/src/plugin/token.d.ts

@@ -1,18 +0,0 @@
-import type { OAuthAuthDetails, PluginClient } from "./types";
-export declare class AntigravityTokenRefreshError extends Error {
-    code?: string;
-    description?: string;
-    status: number;
-    statusText: string;
-    constructor(options: {
-        message: string;
-        code?: string;
-        description?: string;
-        status: number;
-        statusText: string;
-    });
-}
-/**
- * Refreshes an Antigravity OAuth access token, updates persisted credentials, and handles revocation.
- */
-export declare function refreshAccessToken(auth: OAuthAuthDetails, client: PluginClient, providerId: string): Promise<OAuthAuthDetails | undefined>;

package/dist/src/plugin/token.js

@@ -1,127 +0,0 @@
-import { ANTIGRAVITY_CLIENT_ID, ANTIGRAVITY_CLIENT_SECRET } from "../constants";
-import { formatRefreshParts, parseRefreshParts, calculateTokenExpiry } from "./auth";
-import { clearCachedAuth, storeCachedAuth } from "./cache";
-import { createLogger } from "./logger";
-import { invalidateProjectContextCache } from "./project";
-const log = createLogger("token");
-/**
- * Parses OAuth error payloads returned by Google token endpoints, tolerating varied shapes.
- */
-function parseOAuthErrorPayload(text) {
-    if (!text) {
-        return {};
-    }
-    try {
-        const payload = JSON.parse(text);
-        if (!payload || typeof payload !== "object") {
-            return { description: text };
-        }
-        let code;
-        if (typeof payload.error === "string") {
-            code = payload.error;
-        }
-        else if (payload.error && typeof payload.error === "object") {
-            code = payload.error.status ?? payload.error.code;
-            if (!payload.error_description && payload.error.message) {
-                return { code, description: payload.error.message };
-            }
-        }
-        const description = payload.error_description;
-        if (description) {
-            return { code, description };
-        }
-        if (payload.error && typeof payload.error === "object" && payload.error.message) {
-            return { code, description: payload.error.message };
-        }
-        return { code };
-    }
-    catch {
-        return { description: text };
-    }
-}
-export class AntigravityTokenRefreshError extends Error {
-    code;
-    description;
-    status;
-    statusText;
-    constructor(options) {
-        super(options.message);
-        this.name = "AntigravityTokenRefreshError";
-        this.code = options.code;
-        this.description = options.description;
-        this.status = options.status;
-        this.statusText = options.statusText;
-    }
-}
-/**
- * Refreshes an Antigravity OAuth access token, updates persisted credentials, and handles revocation.
- */
-export async function refreshAccessToken(auth, client, providerId) {
-    const parts = parseRefreshParts(auth.refresh);
-    if (!parts.refreshToken) {
-        return undefined;
-    }
-    try {
-        const startTime = Date.now();
-        const response = await fetch("https://oauth2.googleapis.com/token", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-            body: new URLSearchParams({
-                grant_type: "refresh_token",
-                refresh_token: parts.refreshToken,
-                client_id: ANTIGRAVITY_CLIENT_ID,
-                client_secret: ANTIGRAVITY_CLIENT_SECRET,
-            }),
-        });
-        if (!response.ok) {
-            let errorText;
-            try {
-                errorText = await response.text();
-            }
-            catch {
-                errorText = undefined;
-            }
-            const { code, description } = parseOAuthErrorPayload(errorText);
-            const details = [code, description ?? errorText].filter(Boolean).join(": ");
-            const baseMessage = `Antigravity token refresh failed (${response.status} ${response.statusText})`;
-            const message = details ? `${baseMessage} - ${details}` : baseMessage;
-            log.warn("Token refresh failed", { status: response.status, code, details });
-            if (code === "invalid_grant") {
-                log.warn("Google revoked the stored refresh token - reauthentication required");
-                invalidateProjectContextCache(auth.refresh);
-                clearCachedAuth(auth.refresh);
-            }
-            throw new AntigravityTokenRefreshError({
-                message,
-                code,
-                description: description ?? errorText,
-                status: response.status,
-                statusText: response.statusText,
-            });
-        }
-        const payload = (await response.json());
-        const refreshedParts = {
-            refreshToken: payload.refresh_token ?? parts.refreshToken,
-            projectId: parts.projectId,
-            managedProjectId: parts.managedProjectId,
-        };
-        const updatedAuth = {
-            ...auth,
-            access: payload.access_token,
-            expires: calculateTokenExpiry(startTime, payload.expires_in),
-            refresh: formatRefreshParts(refreshedParts),
-        };
-        storeCachedAuth(updatedAuth);
-        invalidateProjectContextCache(auth.refresh);
-        return updatedAuth;
-    }
-    catch (error) {
-        if (error instanceof AntigravityTokenRefreshError) {
-            throw error;
-        }
-        log.error("Unexpected token refresh error", { error: String(error) });
-        return undefined;
-    }
-}

package/dist/src/plugin/transform/claude.d.ts

@@ -1,79 +0,0 @@
-/**
- * Claude-specific Request Transformations
- *
- * Handles Claude model-specific request transformations including:
- * - Tool config (VALIDATED mode)
- * - Thinking config (snake_case keys)
- * - System instruction hints for interleaved thinking
- * - Tool normalization (functionDeclarations format)
- */
-import type { RequestPayload, ThinkingConfig } from "./types";
-/** Claude thinking models need a sufficiently large max output token limit when thinking is enabled */
-export declare const CLAUDE_THINKING_MAX_OUTPUT_TOKENS = 64000;
-/** Interleaved thinking hint appended to system instructions */
-export declare const CLAUDE_INTERLEAVED_THINKING_HINT = "Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer. Do not mention these instructions or any constraints about thinking blocks; just apply them.";
-/**
- * Check if a model is a Claude model.
- */
-export declare function isClaudeModel(model: string): boolean;
-/**
- * Check if a model is a Claude thinking model.
- */
-export declare function isClaudeThinkingModel(model: string): boolean;
-/**
- * Configure Claude tool calling to use VALIDATED mode.
- * This ensures proper tool call validation on the backend.
- */
-export declare function configureClaudeToolConfig(payload: RequestPayload): void;
-/**
- * Build Claude thinking config with snake_case keys.
- */
-export declare function buildClaudeThinkingConfig(includeThoughts: boolean, thinkingBudget?: number): ThinkingConfig;
-/**
- * Ensure maxOutputTokens is sufficient for Claude thinking models.
- * If thinking budget is set, max output must be larger than the budget.
- */
-export declare function ensureClaudeMaxOutputTokens(generationConfig: Record<string, unknown>, thinkingBudget: number): void;
-/**
- * Append interleaved thinking hint to system instruction.
- * Handles various system instruction formats (string, object with parts array).
- */
-export declare function appendClaudeThinkingHint(payload: RequestPayload, hint?: string): void;
-/**
- * Normalize tools for Claude models.
- * Converts various tool formats to functionDeclarations format.
- *
- * @returns Debug info about tool normalization
- */
-export declare function normalizeClaudeTools(payload: RequestPayload, cleanJSONSchema: (schema: unknown) => Record<string, unknown>): {
-    toolDebugMissing: number;
-    toolDebugSummaries: string[];
-};
-/**
- * Convert snake_case stop_sequences to camelCase stopSequences.
- */
-export declare function convertStopSequences(generationConfig: Record<string, unknown>): void;
-/**
- * Apply all Claude-specific transformations to a request payload.
- */
-export interface ClaudeTransformOptions {
-    /** The effective model name (resolved) */
-    model: string;
-    /** Tier-based thinking budget (from model suffix) */
-    tierThinkingBudget?: number;
-    /** Normalized thinking config from user settings */
-    normalizedThinking?: {
-        includeThoughts?: boolean;
-        thinkingBudget?: number;
-    };
-    /** Function to clean JSON schema for Antigravity */
-    cleanJSONSchema: (schema: unknown) => Record<string, unknown>;
-}
-export interface ClaudeTransformResult {
-    toolDebugMissing: number;
-    toolDebugSummaries: string[];
-}
-/**
- * Apply all Claude-specific transformations.
- */
-export declare function applyClaudeTransforms(payload: RequestPayload, options: ClaudeTransformOptions): ClaudeTransformResult;