@reinamaccredy/oh-my-opencode 3.0.0-beta.14 → 3.0.0-beta.16

package/dist/auth/antigravity/response.d.ts

@@ -1,137 +0,0 @@
-/**
- * Antigravity Response Handler
- * Transforms Antigravity/Gemini API responses to OpenAI-compatible format
- *
- * Key responsibilities:
- * - Non-streaming response transformation
- * - SSE streaming response transformation (buffered - see transformStreamingResponse)
- * - Error response handling with retry-after extraction
- * - Usage metadata extraction from x-antigravity-* headers
- */
-import type { AntigravityError, AntigravityUsage } from "./types";
-/**
- * Usage metadata extracted from Antigravity response headers
- */
-export interface AntigravityUsageMetadata {
-    cachedContentTokenCount?: number;
-    totalTokenCount?: number;
-    promptTokenCount?: number;
-    candidatesTokenCount?: number;
-}
-/**
- * Transform result with response and metadata
- */
-export interface TransformResult {
-    response: Response;
-    usage?: AntigravityUsageMetadata;
-    retryAfterMs?: number;
-    error?: AntigravityError;
-}
-/**
- * Extract usage metadata from Antigravity response headers
- *
- * Antigravity sets these headers:
- * - x-antigravity-cached-content-token-count
- * - x-antigravity-total-token-count
- * - x-antigravity-prompt-token-count
- * - x-antigravity-candidates-token-count
- *
- * @param headers - Response headers
- * @returns Usage metadata if found
- */
-export declare function extractUsageFromHeaders(headers: Headers): AntigravityUsageMetadata | undefined;
-/**
- * Extract retry-after value from error response
- *
- * Antigravity returns retry info in error.details array:
- * {
- *   error: {
- *     details: [{
- *       "@type": "type.googleapis.com/google.rpc.RetryInfo",
- *       "retryDelay": "5.123s"
- *     }]
- *   }
- * }
- *
- * Also checks standard Retry-After header.
- *
- * @param response - Response object (for headers)
- * @param errorBody - Parsed error body (optional)
- * @returns Retry after value in milliseconds, or undefined
- */
-export declare function extractRetryAfterMs(response: Response, errorBody?: Record<string, unknown>): number | undefined;
-/**
- * Parse error response body and extract useful details
- *
- * @param text - Raw response text
- * @returns Parsed error or undefined
- */
-export declare function parseErrorBody(text: string): AntigravityError | undefined;
-/**
- * Transform a non-streaming Antigravity response to OpenAI-compatible format
- *
- * For non-streaming responses:
- * - Parses the response body
- * - Unwraps the `response` field if present (Antigravity wraps responses)
- * - Extracts usage metadata from headers
- * - Handles error responses
- *
- * Note: Does NOT handle thinking block extraction (Task 10)
- * Note: Does NOT handle tool normalization (Task 9)
- *
- * @param response - Fetch Response object
- * @returns TransformResult with transformed response and metadata
- */
-export declare function transformResponse(response: Response): Promise<TransformResult>;
-/**
- * Transform SSE streaming payload
- *
- * Processes each line in the SSE stream:
- * - Unwraps { response: { ... } } wrapper from data lines
- * - Preserves other SSE control lines (event:, id:, retry:, empty lines)
- *
- * Note: Does NOT extract thinking blocks (Task 10)
- *
- * @param payload - Raw SSE payload text
- * @returns Transformed SSE payload
- */
-export declare function transformStreamingPayload(payload: string): string;
-/**
- * Transforms a streaming SSE response from Antigravity to OpenAI format.
- *
- * Uses TransformStream to process SSE chunks incrementally as they arrive.
- * Each line is transformed immediately and yielded to the client.
- *
- * @param response - The SSE response from Antigravity API
- * @returns TransformResult with transformed streaming response
- */
-export declare function transformStreamingResponse(response: Response): Promise<TransformResult>;
-/**
- * Check if response is a streaming SSE response
- *
- * @param response - Fetch Response object
- * @returns True if response is SSE stream
- */
-export declare function isStreamingResponse(response: Response): boolean;
-/**
- * Extract thought signature from SSE payload text
- *
- * Looks for thoughtSignature in SSE events:
- * data: { "response": { "candidates": [{ "content": { "parts": [{ "thoughtSignature": "..." }] } }] } }
- *
- * Returns the last found signature (most recent in the stream).
- *
- * @param payload - SSE payload text
- * @returns Last thought signature if found
- */
-export declare function extractSignatureFromSsePayload(payload: string): string | undefined;
-/**
- * Extract usage from SSE payload text
- *
- * Looks for usageMetadata in SSE events:
- * data: { "usageMetadata": { ... } }
- *
- * @param payload - SSE payload text
- * @returns Usage if found
- */
-export declare function extractUsageFromSsePayload(payload: string): AntigravityUsage | undefined;

package/dist/auth/antigravity/storage.d.ts

@@ -1,5 +0,0 @@
-import type { AccountStorage } from "./types";
-export declare function getDataDir(): string;
-export declare function getStoragePath(): string;
-export declare function loadAccounts(path?: string): Promise<AccountStorage | null>;
-export declare function saveAccounts(storage: AccountStorage, path?: string): Promise<void>;

package/dist/auth/antigravity/storage.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/auth/antigravity/thinking.d.ts

@@ -1,278 +0,0 @@
-/**
- * Antigravity Thinking Block Handler (Gemini only)
- *
- * Handles extraction and transformation of thinking/reasoning blocks
- * from Gemini responses. Thinking blocks contain the model's internal
- * reasoning process, available in `-high` model variants.
- *
- * Key responsibilities:
- * - Extract thinking blocks from Gemini response format
- * - Detect thinking-capable model variants (`-high` suffix)
- * - Format thinking blocks for OpenAI-compatible output
- *
- * Note: This is Gemini-only. Claude models are NOT handled by Antigravity.
- */
-import { type AntigravityModelConfig } from "./constants";
-/**
- * Represents a single thinking/reasoning block extracted from Gemini response
- */
-export interface ThinkingBlock {
-    /** The thinking/reasoning text content */
-    text: string;
-    /** Optional signature for signed thinking blocks (required for multi-turn) */
-    signature?: string;
-    /** Index of the thinking block in sequence */
-    index?: number;
-}
-/**
- * Raw part structure from Gemini response candidates
- */
-export interface GeminiPart {
-    /** Text content of the part */
-    text?: string;
-    /** Whether this part is a thinking/reasoning block */
-    thought?: boolean;
-    /** Signature for signed thinking blocks */
-    thoughtSignature?: string;
-    /** Type field for Anthropic-style format */
-    type?: string;
-    /** Signature field for Anthropic-style format */
-    signature?: string;
-}
-/**
- * Gemini response candidate structure
- */
-export interface GeminiCandidate {
-    /** Content containing parts */
-    content?: {
-        /** Role of the content (e.g., "model", "assistant") */
-        role?: string;
-        /** Array of content parts */
-        parts?: GeminiPart[];
-    };
-    /** Index of the candidate */
-    index?: number;
-}
-/**
- * Gemini response structure for thinking block extraction
- */
-export interface GeminiResponse {
-    /** Response ID */
-    id?: string;
-    /** Array of response candidates */
-    candidates?: GeminiCandidate[];
-    /** Direct content (some responses use this instead of candidates) */
-    content?: Array<{
-        type?: string;
-        text?: string;
-        signature?: string;
-    }>;
-    /** Model used for response */
-    model?: string;
-}
-/**
- * Result of thinking block extraction
- */
-export interface ThinkingExtractionResult {
-    /** Extracted thinking blocks */
-    thinkingBlocks: ThinkingBlock[];
-    /** Combined thinking text for convenience */
-    combinedThinking: string;
-    /** Whether any thinking blocks were found */
-    hasThinking: boolean;
-}
-/**
- * Default thinking budget in tokens for thinking-enabled models
- */
-export declare const DEFAULT_THINKING_BUDGET = 16000;
-/**
- * Check if a model variant should include thinking blocks
- *
- * Returns true for model variants with `-high` suffix, which have
- * extended thinking capability enabled.
- *
- * Examples:
- * - `gemini-3-pro-high` → true
- * - `gemini-2.5-pro-high` → true
- * - `gemini-3-pro-preview` → false
- * - `gemini-2.5-pro` → false
- *
- * @param model - Model identifier string
- * @returns True if model should include thinking blocks
- */
-export declare function shouldIncludeThinking(model: string): boolean;
-/**
- * Check if a model is thinking-capable (broader check)
- *
- * This is a broader check than shouldIncludeThinking - it detects models
- * that have thinking capability, even if not explicitly requesting thinking output.
- *
- * @param model - Model identifier string
- * @returns True if model supports thinking/reasoning
- */
-export declare function isThinkingCapableModel(model: string): boolean;
-/**
- * Extract thinking blocks from a Gemini response
- *
- * Parses the response structure to identify and extract all thinking/reasoning
- * content. Supports both Gemini-style (thought: true) and Anthropic-style
- * (type: "thinking") formats.
- *
- * @param response - Gemini response object
- * @returns Extraction result with thinking blocks and metadata
- */
-export declare function extractThinkingBlocks(response: GeminiResponse): ThinkingExtractionResult;
-/**
- * Format thinking blocks for OpenAI-compatible output
- *
- * Converts Gemini thinking block format to OpenAI's expected structure.
- * OpenAI expects thinking content as special message blocks or annotations.
- *
- * Output format:
- * ```
- * [
- *   { type: "reasoning", text: "thinking content...", signature?: "..." },
- *   ...
- * ]
- * ```
- *
- * @param thinking - Array of thinking blocks to format
- * @returns OpenAI-compatible formatted array
- */
-export declare function formatThinkingForOpenAI(thinking: ThinkingBlock[]): Array<{
-    type: "reasoning";
-    text: string;
-    signature?: string;
-}>;
-/**
- * Transform thinking parts in a candidate to OpenAI format
- *
- * Modifies candidate content parts to use OpenAI-style reasoning format
- * while preserving the rest of the response structure.
- *
- * @param candidate - Gemini candidate to transform
- * @returns Transformed candidate with reasoning-formatted thinking
- */
-export declare function transformCandidateThinking(candidate: GeminiCandidate): GeminiCandidate;
-/**
- * Transform Anthropic-style thinking blocks to reasoning format
- *
- * Converts `type: "thinking"` blocks to `type: "reasoning"` for consistency.
- *
- * @param content - Array of content blocks
- * @returns Transformed content array
- */
-export declare function transformAnthropicThinking(content: Array<{
-    type?: string;
-    text?: string;
-    signature?: string;
-}>): Array<{
-    type?: string;
-    text?: string;
-    signature?: string;
-}>;
-/**
- * Filter out unsigned thinking blocks
- *
- * Claude API requires signed thinking blocks for multi-turn conversations.
- * This function removes thinking blocks without valid signatures.
- *
- * @param parts - Array of content parts
- * @returns Filtered array without unsigned thinking blocks
- */
-export declare function filterUnsignedThinkingBlocks(parts: GeminiPart[]): GeminiPart[];
-/**
- * Transform entire response thinking parts
- *
- * Main transformation function that handles both Gemini-style and
- * Anthropic-style thinking blocks in a response.
- *
- * @param response - Response object to transform
- * @returns Transformed response with standardized reasoning format
- */
-export declare function transformResponseThinking(response: GeminiResponse): GeminiResponse;
-/**
- * Thinking configuration for requests
- */
-export interface ThinkingConfig {
-    /** Token budget for thinking/reasoning */
-    thinkingBudget?: number;
-    /** Whether to include thoughts in response */
-    includeThoughts?: boolean;
-}
-/**
- * Normalize thinking configuration
- *
- * Ensures thinkingConfig is valid: includeThoughts only allowed when budget > 0.
- *
- * @param config - Raw thinking configuration
- * @returns Normalized configuration or undefined
- */
-export declare function normalizeThinkingConfig(config: unknown): ThinkingConfig | undefined;
-/**
- * Extract thinking configuration from request payload
- *
- * Supports both Gemini-style thinkingConfig and Anthropic-style thinking options.
- * Also supports reasoning_effort parameter which maps to thinking budget/level.
- *
- * @param requestPayload - Request body
- * @param generationConfig - Generation config from request
- * @param extraBody - Extra body options
- * @returns Extracted thinking configuration or undefined
- */
-export declare function extractThinkingConfig(requestPayload: Record<string, unknown>, generationConfig?: Record<string, unknown>, extraBody?: Record<string, unknown>): ThinkingConfig | DeleteThinkingConfig | undefined;
-/**
- * Resolve final thinking configuration based on model and context
- *
- * Handles special cases like Claude models requiring signed thinking blocks
- * for multi-turn conversations.
- *
- * @param userConfig - User-provided thinking configuration
- * @param isThinkingModel - Whether model supports thinking
- * @param isClaudeModel - Whether model is Claude (not used in Antigravity, but kept for compatibility)
- * @param hasAssistantHistory - Whether conversation has assistant history
- * @returns Final thinking configuration
- */
-export declare function resolveThinkingConfig(userConfig: ThinkingConfig | undefined, isThinkingModel: boolean, isClaudeModel: boolean, hasAssistantHistory: boolean): ThinkingConfig | undefined;
-/**
- * Get thinking config for a model by normalized ID.
- * Uses pattern matching fallback if exact match not found.
- *
- * @param model - Model identifier string (with or without provider prefix)
- * @returns Thinking configuration or undefined if not found
- */
-export declare function getModelThinkingConfig(model: string): AntigravityModelConfig | undefined;
-/**
- * Type for the delete thinking config marker.
- * Used when reasoning_effort is "none" to signal complete removal.
- */
-export interface DeleteThinkingConfig {
-    deleteThinkingConfig: true;
-}
-/**
- * Union type for thinking configuration input.
- */
-export type ThinkingConfigInput = ThinkingConfig | DeleteThinkingConfig;
-/**
- * Convert thinking budget to closest level string for Gemini 3 models.
- *
- * @param budget - Thinking budget in tokens
- * @param model - Model identifier
- * @returns Level string ("low", "high", etc.) or "medium" fallback
- */
-export declare function budgetToLevel(budget: number, model: string): string;
-/**
- * Apply thinking config to request body.
- *
- * CRITICAL: Sets request.generationConfig.thinkingConfig (NOT outer body!)
- *
- * Handles:
- * - Gemini 3: Sets thinkingLevel (string)
- * - Gemini 2.5: Sets thinkingBudget (number)
- * - Delete marker: Removes thinkingConfig entirely
- *
- * @param requestBody - Request body to modify (mutates in place)
- * @param model - Model identifier
- * @param config - Thinking configuration or delete marker
- */
-export declare function applyThinkingConfigToRequest(requestBody: Record<string, unknown>, model: string, config: ThinkingConfigInput): void;

package/dist/auth/antigravity/thinking.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Tests for reasoning_effort and Gemini 3 thinkingLevel support.
- *
- * Tests the following functions:
- * - getModelThinkingConfig()
- * - extractThinkingConfig() with reasoning_effort
- * - applyThinkingConfigToRequest()
- * - budgetToLevel()
- */
-export {};

package/dist/auth/antigravity/thought-signature-store.d.ts

@@ -1,52 +0,0 @@
-/**
- * Thought Signature Store
- *
- * Stores and retrieves thought signatures for multi-turn conversations.
- * Gemini 3 Pro requires thought_signature on function call content blocks
- * in subsequent requests to maintain reasoning continuity.
- *
- * Key responsibilities:
- * - Store the latest thought signature per session
- * - Provide signature for injection into function call requests
- * - Clear signatures when sessions end
- */
-/**
- * Store a thought signature for a session
- *
- * @param sessionKey - Unique session identifier (typically fetch instance ID)
- * @param signature - The thought signature from model response
- */
-export declare function setThoughtSignature(sessionKey: string, signature: string): void;
-/**
- * Retrieve the stored thought signature for a session
- *
- * @param sessionKey - Unique session identifier
- * @returns The stored signature or undefined if not found
- */
-export declare function getThoughtSignature(sessionKey: string): string | undefined;
-/**
- * Clear the thought signature for a session
- *
- * @param sessionKey - Unique session identifier
- */
-export declare function clearThoughtSignature(sessionKey: string): void;
-/**
- * Store or retrieve a persistent session ID for a fetch instance
- *
- * @param fetchInstanceId - Unique identifier for the fetch instance
- * @param sessionId - Optional session ID to store (if not provided, returns existing or generates new)
- * @returns The session ID for this fetch instance
- */
-export declare function getOrCreateSessionId(fetchInstanceId: string, sessionId?: string): string;
-/**
- * Clear the session ID for a fetch instance
- *
- * @param fetchInstanceId - Unique identifier for the fetch instance
- */
-export declare function clearSessionId(fetchInstanceId: string): void;
-/**
- * Clear all stored data for a fetch instance (signature + session ID)
- *
- * @param fetchInstanceId - Unique identifier for the fetch instance
- */
-export declare function clearFetchInstanceData(fetchInstanceId: string): void;

package/dist/auth/antigravity/token.d.ts

@@ -1,38 +0,0 @@
-import type { AntigravityRefreshParts, AntigravityTokenExchangeResult, AntigravityTokens } from "./types";
-export declare class AntigravityTokenRefreshError extends Error {
-    code?: string;
-    description?: string;
-    status: number;
-    statusText: string;
-    responseBody?: string;
-    constructor(options: {
-        message: string;
-        code?: string;
-        description?: string;
-        status: number;
-        statusText: string;
-        responseBody?: string;
-    });
-    get isInvalidGrant(): boolean;
-    get isNetworkError(): boolean;
-}
-export declare function isTokenExpired(tokens: AntigravityTokens): boolean;
-export declare function refreshAccessToken(refreshToken: string, clientId?: string, clientSecret?: string): Promise<AntigravityTokenExchangeResult>;
-/**
- * Parse a stored token string into its component parts.
- * Storage format: `refreshToken|projectId|managedProjectId`
- *
- * @param stored - The pipe-separated stored token string
- * @returns Parsed refresh parts with refreshToken, projectId, and optional managedProjectId
- */
-export declare function parseStoredToken(stored: string): AntigravityRefreshParts;
-/**
- * Format token components for storage.
- * Creates a pipe-separated string: `refreshToken|projectId|managedProjectId`
- *
- * @param refreshToken - The refresh token
- * @param projectId - The GCP project ID
- * @param managedProjectId - Optional managed project ID for enterprise users
- * @returns Formatted string for storage
- */
-export declare function formatTokenForStorage(refreshToken: string, projectId: string, managedProjectId?: string): string;

package/dist/auth/antigravity/token.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/auth/antigravity/tools.d.ts

@@ -1,119 +0,0 @@
-/**
- * Antigravity Tool Normalization
- * Converts tools between OpenAI and Gemini formats.
- *
- * OpenAI format:
- *   { "type": "function", "function": { "name": "x", "description": "...", "parameters": {...} } }
- *
- * Gemini format:
- *   { "functionDeclarations": [{ "name": "x", "description": "...", "parameters": {...} }] }
- *
- * Note: This is for Gemini models ONLY. Claude models are not supported via Antigravity.
- */
-/**
- * OpenAI function tool format
- */
-export interface OpenAITool {
-    type: string;
-    function?: {
-        name: string;
-        description?: string;
-        parameters?: Record<string, unknown>;
-    };
-}
-/**
- * Gemini function declaration format
- */
-export interface GeminiFunctionDeclaration {
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
-}
-/**
- * Gemini tools format (array of functionDeclarations)
- */
-export interface GeminiTools {
-    functionDeclarations: GeminiFunctionDeclaration[];
-}
-/**
- * OpenAI tool call in response
- */
-export interface OpenAIToolCall {
-    id: string;
-    type: "function";
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-/**
- * Gemini function call in response
- */
-export interface GeminiFunctionCall {
-    name: string;
-    args: Record<string, unknown>;
-}
-/**
- * Gemini function response format
- */
-export interface GeminiFunctionResponse {
-    name: string;
-    response: Record<string, unknown>;
-}
-/**
- * Gemini tool result containing function calls
- */
-export interface GeminiToolResult {
-    functionCall?: GeminiFunctionCall;
-    functionResponse?: GeminiFunctionResponse;
-}
-/**
- * Normalize OpenAI-format tools to Gemini format.
- * Converts an array of OpenAI tools to Gemini's functionDeclarations format.
- *
- * - Handles `function` type tools with name, description, parameters
- * - Logs warning for unsupported tool types (does NOT silently drop them)
- * - Creates a single object with functionDeclarations array
- *
- * @param tools - Array of OpenAI-format tools
- * @returns Gemini-format tools object with functionDeclarations, or undefined if no valid tools
- */
-export declare function normalizeToolsForGemini(tools: OpenAITool[]): GeminiTools | undefined;
-/**
- * Convert Gemini tool results (functionCall) back to OpenAI tool_call format.
- * Handles both functionCall (request) and functionResponse (result) formats.
- *
- * Gemini functionCall format:
- *   { "name": "tool_name", "args": { ... } }
- *
- * OpenAI tool_call format:
- *   { "id": "call_xxx", "type": "function", "function": { "name": "tool_name", "arguments": "..." } }
- *
- * @param results - Array of Gemini tool results containing functionCall or functionResponse
- * @returns Array of OpenAI-format tool calls
- */
-export declare function normalizeToolResultsFromGemini(results: GeminiToolResult[]): OpenAIToolCall[];
-/**
- * Convert a single Gemini functionCall to OpenAI tool_call format.
- * Useful for streaming responses where each chunk may contain a function call.
- *
- * @param functionCall - Gemini function call
- * @param id - Optional tool call ID (generates one if not provided)
- * @returns OpenAI-format tool call
- */
-export declare function convertFunctionCallToToolCall(functionCall: GeminiFunctionCall, id?: string): OpenAIToolCall;
-/**
- * Check if a tool array contains any function-type tools.
- *
- * @param tools - Array of OpenAI-format tools
- * @returns true if there are function tools to normalize
- */
-export declare function hasFunctionTools(tools: OpenAITool[]): boolean;
-/**
- * Extract function declarations from already-normalized Gemini tools.
- * Useful when tools may already be in Gemini format.
- *
- * @param tools - Tools that may be in Gemini or OpenAI format
- * @returns Array of function declarations
- */
-export declare function extractFunctionDeclarations(tools: unknown): GeminiFunctionDeclaration[];