@reinamaccredy/oh-my-opencode 1.0.0

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

@@ -0,0 +1,40 @@
+import { type AccountStorage, type AccountTier, type AntigravityRefreshParts, type ModelFamily, type RateLimitState } from "./types";
+export interface ManagedAccount {
+    index: number;
+    parts: AntigravityRefreshParts;
+    access?: string;
+    expires?: number;
+    rateLimits: RateLimitState;
+    lastUsed: number;
+    email?: string;
+    tier?: AccountTier;
+}
+interface AuthDetails {
+    refresh: string;
+    access: string;
+    expires: number;
+}
+interface OAuthAuthDetails {
+    type: "oauth";
+    refresh: string;
+    access: string;
+    expires: number;
+}
+export declare class AccountManager {
+    private accounts;
+    private currentIndex;
+    private activeIndex;
+    constructor(auth: AuthDetails, storedAccounts?: AccountStorage | null);
+    getAccountCount(): number;
+    getCurrentAccount(): ManagedAccount | null;
+    getAccounts(): ManagedAccount[];
+    getCurrentOrNextForFamily(family: ModelFamily): ManagedAccount | null;
+    getNextForFamily(family: ModelFamily): ManagedAccount | null;
+    markRateLimited(account: ManagedAccount, retryAfterMs: number, family: ModelFamily): void;
+    clearExpiredRateLimits(account: ManagedAccount): void;
+    addAccount(parts: AntigravityRefreshParts, access?: string, expires?: number, email?: string, tier?: AccountTier): void;
+    removeAccount(index: number): boolean;
+    save(path?: string): Promise<void>;
+    toAuthDetails(): OAuthAuthDetails;
+}
+export {};

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

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

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

@@ -0,0 +1,27 @@
+/**
+ * Cross-platform browser opening utility.
+ * Uses the "open" npm package for reliable cross-platform support.
+ *
+ * Supports: macOS, Windows, Linux (including WSL)
+ */
+/**
+ * Opens a URL in the user's default browser.
+ *
+ * Cross-platform support:
+ * - macOS: uses `open` command
+ * - Windows: uses `start` command
+ * - Linux: uses `xdg-open` command
+ * - WSL: uses Windows PowerShell
+ *
+ * @param url - The URL to open in the browser
+ * @returns Promise<boolean> - true if browser opened successfully, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const success = await openBrowserURL("https://accounts.google.com/oauth...")
+ * if (!success) {
+ *   console.log("Please open this URL manually:", url)
+ * }
+ * ```
+ */
+export declare function openBrowserURL(url: string): Promise<boolean>;

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

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

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

@@ -0,0 +1,2 @@
+export declare function promptAddAnotherAccount(currentCount: number): Promise<boolean>;
+export declare function promptAccountTier(): Promise<"free" | "paid">;

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

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

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

@@ -0,0 +1,98 @@
+/**
+ * Antigravity OAuth configuration constants.
+ * Values sourced from cliproxyapi/sdk/auth/antigravity.go
+ *
+ * ## Logging Policy
+ *
+ * All console logging in antigravity modules follows a consistent policy:
+ *
+ * - **Debug logs**: Guard with `if (process.env.ANTIGRAVITY_DEBUG === "1")`
+ *   - Includes: info messages, warnings, non-fatal errors
+ *   - Enable debugging: `ANTIGRAVITY_DEBUG=1 opencode`
+ *
+ * - **Fatal errors**: None currently. All errors are handled by returning
+ *   appropriate error responses to OpenCode's auth system.
+ *
+ * This policy ensures production silence while enabling verbose debugging
+ * when needed for troubleshooting OAuth flows.
+ */
+export declare const ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+export declare const ANTIGRAVITY_CLIENT_SECRET = "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";
+export declare const ANTIGRAVITY_CALLBACK_PORT = 51121;
+export declare const ANTIGRAVITY_REDIRECT_URI = "http://localhost:51121/oauth-callback";
+export declare const ANTIGRAVITY_SCOPES: readonly ["https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/cclog", "https://www.googleapis.com/auth/experimentsandconfigs"];
+export declare const ANTIGRAVITY_ENDPOINT_FALLBACKS: readonly ["https://daily-cloudcode-pa.sandbox.googleapis.com", "https://daily-cloudcode-pa.googleapis.com", "https://cloudcode-pa.googleapis.com"];
+export declare const ANTIGRAVITY_API_VERSION = "v1internal";
+export declare const ANTIGRAVITY_HEADERS: {
+    readonly "User-Agent": "google-api-nodejs-client/9.15.1";
+    readonly "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1";
+    readonly "Client-Metadata": string;
+};
+export declare const ANTIGRAVITY_DEFAULT_PROJECT_ID = "rising-fact-p41fc";
+export declare const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+export declare const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+export declare const GOOGLE_USERINFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo";
+export declare const ANTIGRAVITY_TOKEN_REFRESH_BUFFER_MS = 60000;
+export declare const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
+export declare const ANTIGRAVITY_SYSTEM_PROMPT = "<identity>\nYou are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.\nYou are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.\nThe USER will send you requests, which you must always prioritize addressing. Along with each USER request, we will attach additional metadata about their current state, such as what files they have open and where their cursor is.\nThis information may or may not be relevant to the coding task, it is up for you to decide.\n</identity>\n\n<tool_calling>\nCall tools as you normally would. The following list provides additional guidance to help you avoid errors:\n  - **Absolute paths only**. When using tools that accept file path arguments, ALWAYS use the absolute file path.\n</tool_calling>\n\n<web_application_development>\n## Technology Stack\nYour web applications should be built using the following technologies:\n1. **Core**: Use HTML for structure and Javascript for logic.\n2. **Styling (CSS)**: Use Vanilla CSS for maximum flexibility and control. Avoid using TailwindCSS unless the USER explicitly requests it; in this case, first confirm which TailwindCSS version to use.\n3. **Web App**: If the USER specifies that they want a more complex web app, use a framework like Next.js or Vite. Only do this if the USER explicitly requests a web app.\n4. **New Project Creation**: If you need to use a framework for a new app, use `npx` with the appropriate script, but there are some rules to follow:\n   - Use `npx -y` to automatically install the script and its dependencies\n   - You MUST run the command with `--help` flag to see all available options first\n   - Initialize the app in the current directory with `./` (example: `npx -y create-vite-app@latest ./`)\n</web_application_development>\n";
+/**
+ * Maps reasoning_effort UI values to thinking budget tokens.
+ *
+ * Key notes:
+ * - `none: 0` is a sentinel value meaning "delete thinkingConfig entirely"
+ * - `auto: -1` triggers dynamic budget calculation based on context
+ * - All other values represent actual thinking budget in tokens
+ */
+export declare const REASONING_EFFORT_BUDGET_MAP: Record<string, number>;
+/**
+ * Model-specific thinking configuration.
+ *
+ * thinkingType:
+ * - "numeric": Uses thinkingBudget (number) - Gemini 2.5, Claude via Antigravity
+ * - "levels": Uses thinkingLevel (string) - Gemini 3
+ *
+ * zeroAllowed:
+ * - true: Budget can be 0 (thinking disabled)
+ * - false: Minimum budget enforced (cannot disable thinking)
+ */
+export interface AntigravityModelConfig {
+    thinkingType: "numeric" | "levels";
+    min: number;
+    max: number;
+    zeroAllowed: boolean;
+    levels?: string[];
+}
+/**
+ * Thinking configuration per model.
+ * Keys are normalized model IDs (no provider prefix, no variant suffix).
+ *
+ * Config lookup uses pattern matching fallback:
+ * - includes("gemini-3") → Gemini 3 (levels)
+ * - includes("gemini-2.5") → Gemini 2.5 (numeric)
+ * - includes("claude") → Claude via Antigravity (numeric)
+ */
+export declare const ANTIGRAVITY_MODEL_CONFIGS: Record<string, AntigravityModelConfig>;
+/**
+ * Normalizes model ID for config lookup.
+ *
+ * Algorithm:
+ * 1. Strip provider prefix (e.g., "google/")
+ * 2. Strip "antigravity-" prefix
+ * 3. Strip UI variant suffixes (-high, -low, -thinking-*)
+ *
+ * Examples:
+ * - "google/antigravity-gemini-3-pro-high" → "gemini-3-pro"
+ * - "antigravity-gemini-3-flash-preview" → "gemini-3-flash-preview"
+ * - "gemini-2.5-flash" → "gemini-2.5-flash"
+ * - "gemini-claude-sonnet-4-5-thinking-high" → "gemini-claude-sonnet-4-5"
+ */
+export declare function normalizeModelId(model: string): string;
+export declare const ANTIGRAVITY_SUPPORTED_MODELS: readonly ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-computer-use-preview-10-2025", "gemini-3-pro-preview", "gemini-3-flash-preview", "gemini-claude-sonnet-4-5-thinking", "gemini-claude-opus-4-5-thinking"];
+/**
+ * Converts UI model names to Antigravity API model names.
+ *
+ * NOTE: Tested 2026-01-08 - Gemini 3 models work with -preview suffix directly.
+ * The CLIProxyAPI transformations (gemini-3-pro-high, gemini-3-flash) return 404.
+ * Claude models return 404 on all endpoints (may require special access/quota).
+ */
+export declare function alias2ModelName(modelName: string): string;

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

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

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

@@ -0,0 +1,69 @@
+/**
+ * Antigravity Fetch Interceptor
+ *
+ * Creates a custom fetch function that:
+ * - Checks token expiration and auto-refreshes
+ * - Rewrites URLs to Antigravity endpoints
+ * - Applies request transformation (including tool normalization)
+ * - Applies response transformation (including thinking extraction)
+ * - Implements endpoint fallback (daily → autopush → prod)
+ *
+ * **Body Type Assumption:**
+ * This interceptor assumes `init.body` is a JSON string (OpenAI format).
+ * Non-string bodies (ReadableStream, Blob, FormData, URLSearchParams, etc.)
+ * are passed through unchanged to the original fetch to avoid breaking
+ * other requests that may not be OpenAI-format API calls.
+ *
+ * Debug logging available via ANTIGRAVITY_DEBUG=1 environment variable.
+ */
+import { AccountManager } from "./accounts";
+/**
+ * Auth interface matching OpenCode's auth system
+ */
+interface Auth {
+    access?: string;
+    refresh?: string;
+    expires?: number;
+}
+/**
+ * Client interface for auth operations
+ */
+interface AuthClient {
+    set(providerId: string, auth: Auth): Promise<void>;
+}
+/**
+ * Create Antigravity fetch interceptor
+ *
+ * Factory function that creates a custom fetch function for Antigravity API.
+ * Handles token management, request/response transformation, and endpoint fallback.
+ *
+ * @param getAuth - Async function to retrieve current auth state
+ * @param client - Auth client for saving updated tokens
+ * @param providerId - Provider identifier (e.g., "google")
+ * @param clientId - Optional custom client ID for token refresh (defaults to ANTIGRAVITY_CLIENT_ID)
+ * @param clientSecret - Optional custom client secret for token refresh (defaults to ANTIGRAVITY_CLIENT_SECRET)
+ * @returns Custom fetch function compatible with standard fetch signature
+ *
+ * @example
+ * ```typescript
+ * const customFetch = createAntigravityFetch(
+ *   () => auth(),
+ *   client,
+ *   "google",
+ *   "custom-client-id",
+ *   "custom-client-secret"
+ * )
+ *
+ * // Use like standard fetch
+ * const response = await customFetch("https://api.example.com/chat", {
+ *   method: "POST",
+ *   body: JSON.stringify({ messages: [...] })
+ * })
+ * ```
+ */
+export declare function createAntigravityFetch(getAuth: () => Promise<Auth>, client: AuthClient, providerId: string, clientId?: string, clientSecret?: string, accountManager?: AccountManager | null): (url: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Type export for createAntigravityFetch return type
+ */
+export type AntigravityFetch = (url: string, init?: RequestInit) => Promise<Response>;
+export {};

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

@@ -0,0 +1,13 @@
+export * from "./types";
+export * from "./constants";
+export * from "./oauth";
+export * from "./token";
+export * from "./project";
+export * from "./request";
+export * from "./response";
+export * from "./tools";
+export * from "./thinking";
+export * from "./thought-signature-store";
+export * from "./message-converter";
+export * from "./fetch";
+export * from "./plugin";

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

@@ -0,0 +1,10 @@
+/**
+ * Antigravity Integration Tests - End-to-End
+ *
+ * Tests the complete request transformation pipeline:
+ * - Request parsing and model extraction
+ * - System prompt injection (handled by transformRequest)
+ * - Thinking config application (handled by applyThinkingConfigToRequest)
+ * - Body wrapping for Antigravity API format
+ */
+export {};

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,51 @@
+import type { AntigravityTokenExchangeResult, AntigravityUserInfo } from "./types";
+/**
+ * Result from building an OAuth authorization URL.
+ */
+export interface AuthorizationResult {
+    /** Full OAuth URL to open in browser */
+    url: string;
+    /** State for CSRF protection */
+    state: 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;
+}
+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 redirectUri - OAuth redirect URI
+ * @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, redirectUri: string, clientId?: string, clientSecret?: string): 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;
+    redirectUri: string;
+    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;
+    state: string;
+}>;

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

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

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,10 @@
+/**
+ * Antigravity project context management.
+ * Handles fetching GCP project ID via Google's loadCodeAssist API.
+ * For FREE tier users, onboards via onboardUser API to get server-assigned managed project ID.
+ * Reference: https://github.com/shekohex/opencode-google-antigravity-auth
+ */
+import type { AntigravityProjectContext } from "./types";
+export declare function fetchProjectContext(accessToken: string): Promise<AntigravityProjectContext>;
+export declare function clearProjectContextCache(accessToken?: string): void;
+export declare function invalidateProjectContextByRefreshToken(_refreshToken: string): void;

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

@@ -0,0 +1,116 @@
+/**
+ * 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;
+/**
+ * Inject ANTIGRAVITY_SYSTEM_PROMPT into request.systemInstruction.
+ * Prepends Antigravity prompt before any existing systemInstruction.
+ * Prevents duplicate injection by checking for <identity> marker.
+ *
+ * CRITICAL: Modifies wrappedBody.request.systemInstruction (NOT outer body!)
+ *
+ * @param wrappedBody - The wrapped request body with request field
+ */
+export declare function injectSystemPrompt(wrappedBody: {
+    request?: unknown;
+}): void;
+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/request.test.d.ts

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