oh-my-opencode 0.3.3 → 0.4.0

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

@@ -0,0 +1,52 @@
+/**
+ * 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

@@ -0,0 +1,41 @@
+/**
+ * Antigravity token management utilities.
+ * Handles token expiration checking, refresh, and storage format parsing.
+ */
+import type { AntigravityRefreshParts, AntigravityTokenExchangeResult, AntigravityTokens } from "./types";
+/**
+ * Check if the access token is expired.
+ * Includes a 60-second safety buffer to refresh before actual expiration.
+ *
+ * @param tokens - The Antigravity tokens to check
+ * @returns true if the token is expired or will expire within the buffer period
+ */
+export declare function isTokenExpired(tokens: AntigravityTokens): boolean;
+/**
+ * Refresh an access token using a refresh token.
+ * Exchanges the refresh token for a new access token via Google's OAuth endpoint.
+ *
+ * @param refreshToken - The refresh token to use
+ * @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 new access token, or throws on error
+ */
+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/tools.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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[];

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

@@ -0,0 +1,173 @@
+/**
+ * Antigravity Auth Type Definitions
+ * Matches cliproxyapi/sdk/auth/antigravity.go token format exactly
+ */
+/**
+ * Token storage format for Antigravity authentication
+ * Matches Go metadata structure: type, access_token, refresh_token, expires_in, timestamp, email, project_id
+ */
+export interface AntigravityTokens {
+    /** Always "antigravity" for this auth type */
+    type: "antigravity";
+    /** OAuth access token from Google */
+    access_token: string;
+    /** OAuth refresh token from Google */
+    refresh_token: string;
+    /** Token expiration time in seconds */
+    expires_in: number;
+    /** Unix timestamp in milliseconds when tokens were obtained */
+    timestamp: number;
+    /** ISO 8601 formatted expiration datetime (optional, for display) */
+    expired?: string;
+    /** User's email address from Google userinfo */
+    email?: string;
+    /** GCP project ID from loadCodeAssist API */
+    project_id?: string;
+}
+/**
+ * Project context returned from loadCodeAssist API
+ * Used to get cloudaicompanionProject for API calls
+ */
+export interface AntigravityProjectContext {
+    /** GCP project ID for Cloud AI Companion */
+    cloudaicompanionProject?: string;
+    /** Managed project ID for enterprise users (optional) */
+    managedProjectId?: string;
+}
+/**
+ * Metadata for loadCodeAssist API request
+ */
+export interface AntigravityClientMetadata {
+    /** IDE type identifier */
+    ideType: "IDE_UNSPECIFIED" | string;
+    /** Platform identifier */
+    platform: "PLATFORM_UNSPECIFIED" | string;
+    /** Plugin type - typically "GEMINI" */
+    pluginType: "GEMINI" | string;
+}
+/**
+ * Request body for loadCodeAssist API
+ */
+export interface AntigravityLoadCodeAssistRequest {
+    metadata: AntigravityClientMetadata;
+}
+/**
+ * Response from loadCodeAssist API
+ */
+export interface AntigravityLoadCodeAssistResponse {
+    /** Project ID - can be string or object with id field */
+    cloudaicompanionProject?: string | {
+        id: string;
+    };
+}
+/**
+ * Request body format for Antigravity API calls
+ * Wraps the actual request with project and model context
+ */
+export interface AntigravityRequestBody {
+    /** GCP project ID */
+    project: string;
+    /** Model identifier (e.g., "gemini-3-pro-preview") */
+    model: string;
+    /** User agent identifier */
+    userAgent: string;
+    /** Unique request ID */
+    requestId: string;
+    /** The actual request payload */
+    request: Record<string, unknown>;
+}
+/**
+ * Response format from Antigravity API
+ * Follows OpenAI-compatible structure with Gemini extensions
+ */
+export interface AntigravityResponse {
+    /** Response ID */
+    id?: string;
+    /** Object type (e.g., "chat.completion") */
+    object?: string;
+    /** Creation timestamp */
+    created?: number;
+    /** Model used for response */
+    model?: string;
+    /** Response choices */
+    choices?: AntigravityResponseChoice[];
+    /** Token usage statistics */
+    usage?: AntigravityUsage;
+    /** Error information if request failed */
+    error?: AntigravityError;
+}
+/**
+ * Single response choice in Antigravity response
+ */
+export interface AntigravityResponseChoice {
+    /** Choice index */
+    index: number;
+    /** Message content */
+    message?: {
+        role: "assistant";
+        content?: string;
+        tool_calls?: AntigravityToolCall[];
+    };
+    /** Delta for streaming responses */
+    delta?: {
+        role?: "assistant";
+        content?: string;
+        tool_calls?: AntigravityToolCall[];
+    };
+    /** Finish reason */
+    finish_reason?: "stop" | "tool_calls" | "length" | "content_filter" | null;
+}
+/**
+ * Tool call in Antigravity response
+ */
+export interface AntigravityToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Token usage statistics
+ */
+export interface AntigravityUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+/**
+ * Error response from Antigravity API
+ */
+export interface AntigravityError {
+    message: string;
+    type?: string;
+    code?: string | number;
+}
+/**
+ * Token exchange result from Google OAuth
+ * Matches antigravityTokenResponse in Go
+ */
+export interface AntigravityTokenExchangeResult {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    token_type: string;
+}
+/**
+ * User info from Google userinfo API
+ */
+export interface AntigravityUserInfo {
+    email: string;
+    name?: string;
+    picture?: string;
+}
+/**
+ * Parsed refresh token parts
+ * Format: refreshToken|projectId|managedProjectId
+ */
+export interface AntigravityRefreshParts {
+    refreshToken: string;
+    projectId?: string;
+    managedProjectId?: string;
+}