oh-my-opencode 0.3.3 → 0.4.0

package/dist/auth/antigravity/message-converter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * OpenAI → Gemini message format converter
+ *
+ * Converts OpenAI-style messages to Gemini contents format,
+ * injecting thoughtSignature into functionCall parts.
+ */
+interface OpenAIMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content?: string | OpenAIContentPart[];
+    tool_calls?: OpenAIToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+interface OpenAIContentPart {
+    type: string;
+    text?: string;
+    image_url?: {
+        url: string;
+    };
+    [key: string]: unknown;
+}
+interface OpenAIToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface GeminiPart {
+    text?: string;
+    functionCall?: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    functionResponse?: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    thought_signature?: string;
+    [key: string]: unknown;
+}
+interface GeminiContent {
+    role: "user" | "model";
+    parts: GeminiPart[];
+}
+export declare function convertOpenAIToGemini(messages: OpenAIMessage[], thoughtSignature?: string): GeminiContent[];
+export declare function hasOpenAIMessages(body: Record<string, unknown>): boolean;
+export declare function convertRequestBody(body: Record<string, unknown>, thoughtSignature?: string): Record<string, unknown>;
+export {};

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

@@ -0,0 +1,85 @@
+import type { AntigravityTokenExchangeResult, AntigravityUserInfo } from "./types";
+/**
+ * PKCE pair containing verifier and challenge.
+ */
+export interface PKCEPair {
+    /** PKCE verifier - used during token exchange */
+    verifier: string;
+    /** PKCE challenge - sent in auth URL */
+    challenge: string;
+    /** Challenge method - always "S256" */
+    method: string;
+}
+/**
+ * OAuth state encoded in the auth URL.
+ * Contains the PKCE verifier for later retrieval.
+ */
+export interface OAuthState {
+    /** PKCE verifier */
+    verifier: string;
+    /** Optional project ID */
+    projectId?: string;
+}
+/**
+ * Result from building an OAuth authorization URL.
+ */
+export interface AuthorizationResult {
+    /** Full OAuth URL to open in browser */
+    url: string;
+    /** PKCE verifier to use during code exchange */
+    verifier: string;
+}
+/**
+ * Result from the OAuth callback server.
+ */
+export interface CallbackResult {
+    /** Authorization code from Google */
+    code: string;
+    /** State parameter from callback */
+    state: string;
+    /** Error message if any */
+    error?: string;
+}
+/**
+ * Generate PKCE verifier and challenge pair.
+ * Uses @openauthjs/openauth for cryptographically secure generation.
+ *
+ * @returns PKCE pair with verifier, challenge, and method
+ */
+export declare function generatePKCEPair(): Promise<PKCEPair>;
+/**
+ * Decode OAuth state from a base64 string.
+ *
+ * @param encoded - Base64URL or Base64 encoded state
+ * @returns Decoded OAuth state
+ */
+export declare function decodeState(encoded: string): OAuthState;
+export declare function buildAuthURL(projectId?: string, clientId?: string, port?: number): Promise<AuthorizationResult>;
+/**
+ * Exchange authorization code for tokens.
+ *
+ * @param code - Authorization code from OAuth callback
+ * @param verifier - PKCE verifier from initial auth request
+ * @param clientId - Optional custom client ID (defaults to ANTIGRAVITY_CLIENT_ID)
+ * @param clientSecret - Optional custom client secret (defaults to ANTIGRAVITY_CLIENT_SECRET)
+ * @returns Token exchange result with access and refresh tokens
+ */
+export declare function exchangeCode(code: string, verifier: string, clientId?: string, clientSecret?: string, port?: number): Promise<AntigravityTokenExchangeResult>;
+/**
+ * Fetch user info from Google's userinfo API.
+ *
+ * @param accessToken - Valid access token
+ * @returns User info containing email
+ */
+export declare function fetchUserInfo(accessToken: string): Promise<AntigravityUserInfo>;
+export interface CallbackServerHandle {
+    port: number;
+    waitForCallback: () => Promise<CallbackResult>;
+    close: () => void;
+}
+export declare function startCallbackServer(timeoutMs?: number): CallbackServerHandle;
+export declare function performOAuthFlow(projectId?: string, openBrowser?: (url: string) => Promise<void>, clientId?: string, clientSecret?: string): Promise<{
+    tokens: AntigravityTokenExchangeResult;
+    userInfo: AntigravityUserInfo;
+    verifier: string;
+}>;

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

@@ -0,0 +1,54 @@
+/**
+ * Google Antigravity Auth Plugin for OpenCode
+ *
+ * Provides OAuth authentication for Google models via Antigravity API.
+ * This plugin integrates with OpenCode's auth system to enable:
+ * - OAuth 2.0 with PKCE flow for Google authentication
+ * - Automatic token refresh
+ * - Request/response transformation for Antigravity API
+ *
+ * @example
+ * ```json
+ * // opencode.json
+ * {
+ *   "plugin": ["oh-my-opencode"],
+ *   "provider": {
+ *     "google": {
+ *       "options": {
+ *         "clientId": "custom-client-id",
+ *         "clientSecret": "custom-client-secret"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+import type { AuthHook, PluginInput } from "@opencode-ai/plugin";
+/**
+ * Creates the Google Antigravity OAuth plugin for OpenCode.
+ *
+ * This factory function creates an auth plugin that:
+ * 1. Provides OAuth flow for Google authentication
+ * 2. Creates a custom fetch interceptor for Antigravity API
+ * 3. Handles token management and refresh
+ *
+ * @param input - Plugin input containing the OpenCode client
+ * @returns Hooks object with auth configuration
+ *
+ * @example
+ * ```typescript
+ * // Used by OpenCode automatically when plugin is loaded
+ * const hooks = await createGoogleAntigravityAuthPlugin({ client, ... })
+ * ```
+ */
+export declare function createGoogleAntigravityAuthPlugin({ client, }: PluginInput): Promise<{
+    auth: AuthHook;
+}>;
+/**
+ * Default export for OpenCode plugin system
+ */
+export default createGoogleAntigravityAuthPlugin;
+/**
+ * Named export for explicit imports
+ */
+export declare const GoogleAntigravityAuthPlugin: typeof createGoogleAntigravityAuthPlugin;

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

@@ -0,0 +1,20 @@
+/**
+ * Antigravity project context management.
+ * Handles fetching GCP project ID via Google's loadCodeAssist API.
+ */
+import type { AntigravityProjectContext } from "./types";
+/**
+ * Fetch project context from Google's loadCodeAssist API.
+ * Extracts the cloudaicompanionProject from the response.
+ *
+ * @param accessToken - Valid OAuth access token
+ * @returns Project context with cloudaicompanionProject ID
+ */
+export declare function fetchProjectContext(accessToken: string): Promise<AntigravityProjectContext>;
+/**
+ * Clear the project context cache.
+ * Call this when tokens are refreshed or invalidated.
+ *
+ * @param accessToken - Optional specific token to clear, or clears all if not provided
+ */
+export declare function clearProjectContextCache(accessToken?: string): void;

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

@@ -0,0 +1,104 @@
+/**
+ * Antigravity request transformer.
+ * Transforms OpenAI-format requests to Antigravity format.
+ * Does NOT handle tool normalization (handled by tools.ts in Task 9).
+ */
+import type { AntigravityRequestBody } from "./types";
+/**
+ * Result of request transformation including URL, headers, and body.
+ */
+export interface TransformedRequest {
+    /** Transformed URL for Antigravity API */
+    url: string;
+    /** Request headers including Authorization and Antigravity-specific headers */
+    headers: Record<string, string>;
+    /** Transformed request body in Antigravity format */
+    body: AntigravityRequestBody;
+    /** Whether this is a streaming request */
+    streaming: boolean;
+}
+/**
+ * Build Antigravity-specific request headers.
+ * Includes Authorization, User-Agent, X-Goog-Api-Client, and Client-Metadata.
+ *
+ * @param accessToken - OAuth access token for Authorization header
+ * @returns Headers object with all required Antigravity headers
+ */
+export declare function buildRequestHeaders(accessToken: string): Record<string, string>;
+/**
+ * Extract model name from request body.
+ * OpenAI-format requests include model in the body.
+ *
+ * @param body - Request body that may contain a model field
+ * @returns Model name or undefined if not found
+ */
+export declare function extractModelFromBody(body: Record<string, unknown>): string | undefined;
+/**
+ * Extract model name from URL path.
+ * Handles Google Generative Language API format: /models/{model}:{action}
+ *
+ * @param url - Request URL to parse
+ * @returns Model name or undefined if not found
+ */
+export declare function extractModelFromUrl(url: string): string | undefined;
+/**
+ * Determine the action type from the URL path.
+ * E.g., generateContent, streamGenerateContent
+ *
+ * @param url - Request URL to parse
+ * @returns Action name or undefined if not found
+ */
+export declare function extractActionFromUrl(url: string): string | undefined;
+/**
+ * Check if a URL is targeting Google's Generative Language API.
+ *
+ * @param url - URL to check
+ * @returns true if this is a Google Generative Language API request
+ */
+export declare function isGenerativeLanguageRequest(url: string): boolean;
+/**
+ * Build Antigravity API URL for the given action.
+ *
+ * @param baseEndpoint - Base Antigravity endpoint URL (from fallbacks)
+ * @param action - API action (e.g., generateContent, streamGenerateContent)
+ * @param streaming - Whether to append SSE query parameter
+ * @returns Formatted Antigravity API URL
+ */
+export declare function buildAntigravityUrl(baseEndpoint: string, action: string, streaming: boolean): string;
+/**
+ * Get the first available Antigravity endpoint.
+ * Can be used with fallback logic in fetch.ts.
+ *
+ * @returns Default (first) Antigravity endpoint
+ */
+export declare function getDefaultEndpoint(): string;
+export declare function wrapRequestBody(body: Record<string, unknown>, projectId: string, modelName: string, sessionId: string): AntigravityRequestBody;
+export declare function injectThoughtSignatureIntoFunctionCalls(body: Record<string, unknown>, signature: string | undefined): Record<string, unknown>;
+/**
+ * Detect if request is for streaming.
+ * Checks both action name and request body for stream flag.
+ *
+ * @param url - Request URL
+ * @param body - Request body
+ * @returns true if streaming is requested
+ */
+export declare function isStreamingRequest(url: string, body: Record<string, unknown>): boolean;
+export interface TransformRequestOptions {
+    url: string;
+    body: Record<string, unknown>;
+    accessToken: string;
+    projectId: string;
+    sessionId: string;
+    modelName?: string;
+    endpointOverride?: string;
+    thoughtSignature?: string;
+}
+export declare function transformRequest(options: TransformRequestOptions): TransformedRequest;
+/**
+ * Prepare request headers for streaming responses.
+ * Adds Accept header for SSE format.
+ *
+ * @param headers - Existing headers object
+ * @returns Headers with streaming support
+ */
+export declare function addStreamingHeaders(headers: Record<string, string>): Record<string, string>;

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

@@ -0,0 +1,137 @@
+/**
+ * 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/thinking.d.ts

@@ -0,0 +1,234 @@
+/**
+ * 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.
+ */
+/**
+ * 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.
+ *
+ * @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 | 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;