@wenathlan/devthink 2.0.13 → 2.0.15

package/dist/request.d.ts

@@ -0,0 +1,1492 @@
+/**
+ * @file request.ts
+ * @module provider/request
+ * @description
+ *  THE single request-building module of the provider family of the merged library. v2.1.14
+ *  consolidation: request.ts absorbed request-helpers.ts in full, so the
+ *  entire request-building category — schema cleaning, tool validation,
+ *  thinking budgets, fingerprint headers, session/prompt id builders, model
+ *  classification, request transforms/builders and cascade fetch — lives in
+ *  this one file.
+ *
+ *  Third-person observer view: the library watches how OpenCode transforms
+ *  user messages (OpenAI and Anthropic shapes) into Gemini/Claude payloads
+ *  and how Antigravity Manager forwards them to cloudcode-pa.googleapis.com
+ *  without using localhost v1 proxy.
+ *
+ *  Responsibilities:
+ *  - transformRequest: OpenCode -> Gemini normalized request (contents, system, tools, genConfig)
+ *  - buildAntigravityRequest / buildGeminiCLIRequest: wraps normalized request into
+ *    cloudcode-pa envelope with deterministic session_id / user_prompt_id (FNV-1a),
+ *    endpoint cascade, fingerprint headers, and x-goog-user-project stripping
+ *  - schema cleaning: tolerant Gemini-shaping cleanJsonSchema plus the strict
+ *    allowlist cleanJsonSchemaStrict / cleanToolSchemaTolerant family
+ *  - tool name validation, sanitization and deduplication (two parallel
+ *    families: validateToolNames and validateToolNamesDetailed)
+ *  - message normalization: normalizeMessages and normalizeIncomingMessages
+ *  - thinking level parsing, budget maps, family-aware budgets and variant hints
+ *  - deterministic id builders over FNV-1a 32/64-bit digests
+ *  - model classification (isGeminiCLIOnlyModel, isLikelyAntigravityOnlyModel,
+ *    variant extraction) and the Gemini CLI bypass constants
+ *  - google_search injection when enabled; cascade fetch with retry
+ *
+ *  Architecture governance:
+ *  - Date: 25/08/2026 — Canto do Buriti, Piauí, Brasil
+ *  - Library-first, root-first: file lives beside its siblings (no src/ nesting)
+ *  - Only node:* builtins + global fetch (Node >=18) — zero external deps
+ *  - Direct cloudcode-pa usage: https://cloudcode-pa.googleapis.com,
+ *    https://daily-cloudcode-pa.googleapis.com,
+ *    https://daily-cloudcode-pa.sandbox.googleapis.com
+ *  - No localhost v1 base-url proxy (requisito explícito)
+ *  - Deterministic IDs via FNV-1a (32/64-bit) — reproducible per conversation
+ *  - Strip x-goog-user-project header to avoid 403 IAM (issue pi-mono #1830)
+ *  - Skip sandbox for gemini-cli models to avoid 404/403 cascade (#233)
+ *
+ *  v2.1.14 merge notes (request.ts + request-helpers.ts -> request.ts):
+ *  - Identical duplicated symbols collapsed to a single definition.
+ *  - Divergent duplicates resolved toward the more defensive variant; the
+ *    losing variant survives under a parallel export whenever its behavior
+ *    was not equivalent:
+ *      cleanJsonSchemaStrict            <- request-helpers cleanJsonSchema (strict allowlist)
+ *      cleanToolSchemaTolerant          <- request-helpers cleanToolSchema (tolerant normalizer)
+ *      validateToolNamesDetailed        <- request-helpers validateToolNames (rich validator)
+ *      buildGenerationConfigFromRequest <- request.ts buildGenerationConfig (request-shaped)
+ *  - Canonical fnv1a32 hashes UTF-16 code units (charCodeAt), matching the
+ *    repo-wide implementation in core.ts; the UTF-8 byte variant that lived
+ *    only in request-helpers.ts was dropped as the outlier.
+ *  - Canonical TOOL_NAME_REGEX is the letter-start + 64-cap pattern shared
+ *    with core.ts (TOOL_REGEX); the underscore-start variant was dropped.
+ *  - Canonical generateSessionId/generateUserPromptId are the validating
+ *    versions (throw RequestHelpersError on empty seed).
+ *  - The RequestHelpers barrel is re-exported from this module; the default
+ *    export remains RequestPipeline.
+ *
+ * @author devthink
+ * @license MIT
+ * @version 2.1.16
+ */
+import { fnv1a32, fnv1a32Hex, isRetryableStatus } from "./core.js";
+export declare const TOOL_NAME_MAX_LENGTH: 64;
+export declare const TOOL_NAME_MIN_LENGTH: 1;
+export declare const THINKING_LEVEL_TO_BUDGET_GEMINI: Record<string, number>;
+export declare const THINKING_LEVEL_TO_BUDGET_CLAUDE: Record<string, number>;
+/**
+ * Thinking budget ceiling shared by the clamp paths. v2.1.16: the value
+ * (64000) is byte-identical to models.ts THINKING_BUDGET_MAX_CLAUDE — the
+ * thinking-table owner — so this export now aliases that import instead of
+ * repeating the literal.
+ */
+export declare const THINKING_BUDGET_MAX: 64000;
+export declare const THINKING_BUDGET_MIN: 1024;
+export { GEMINI_CLI_OAUTH_CLIENT_ID as GEMINI_CLI_CLIENT_ID } from "./constants.js";
+export { GEMINI_CLI_OAUTH_CLIENT_SECRET as GEMINI_CLI_CLIENT_SECRET } from "./constants.js";
+import { getFingerprintHeaders } from "./fingerprint.js";
+import { getEndpointsForModel, isGeminiCLIOnlyModel } from "./models.js";
+import type { ThinkingLevel } from "./models.js";
+export { ENDPOINT_ORDER_ANTIGRAVITY, ENDPOINT_ORDER_GEMINI_CLI, GEMINI_CLI_ONLY_MODELS, SEARCH_MODEL, SEARCH_MODEL_PREVIEW, THINKING_BUDGET_MAP, THINKING_BUDGET_MAX_CLAUDE, THINKING_BUDGET_MAX_GEMINI, THINKING_LEVELS, getEndpointsForModel, isGeminiCLIOnlyModel, } from "./models.js";
+export type { ThinkingLevel } from "./models.js";
+/** Historical request-module alias of the models.ts owner list. */
+export { FETCH_AVAILABLE_MODELS_2026 as MODELS_2026 } from "./models.js";
+/**
+ * Official cloudcode-pa endpoints — prod is authoritative in 2026,
+ * daily and sandbox are rollout / canary fallbacks.
+ * Third-person: observer copies order from Antigravity Manager binary.
+ */
+/** Default cascade order for Antigravity pool (re-exported from models.ts above). */
+/** Stream endpoint suffix used by Antigravity */
+/** Antigravity version fallback — governance requires 1.19.2 (bypass ban <1.15.8) */
+/** Fallback project id */
+/** FNV-1a constants — 32-bit */
+/** Forbidden headers stripped case-insensitively — observer notes AM never sends them on content */
+/**
+ * OpenCode function tool — accepts OpenAI, Anthropic, or Gemini pre-shaped.
+ */
+export type OpenCodeTool = {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: any;
+    };
+} | {
+    name: string;
+    description?: string;
+    input_schema?: any;
+    inputSchema?: any;
+    parameters?: any;
+    [k: string]: any;
+} | {
+    functionDeclarations: Array<{
+        name: string;
+        description?: string;
+        parameters?: any;
+    }>;
+};
+export interface TransformRequestInput {
+    /** Model id, e.g. gemini-3-flash-preview or claude-opus-4-6-thinking-low */
+    model: string;
+    /** Message history in OpenCode format */
+    messages: OpenCodeMessage[];
+    /** Optional tools — OpenAI / Anthropic / Gemini shapes tolerated */
+    tools?: OpenCodeTool[] | any[];
+    /** Optional system instruction as string or array of texts */
+    system?: string | string[] | null;
+    /** Optional thinking level minimal|low|medium|high|max — maps to budget */
+    thinkingLevel?: ThinkingLevel | string;
+    /** Optional explicit thinking budget — overrides level map */
+    thinkingBudget?: number;
+    /** Whether to inject google_search grounding tool */
+    googleSearchEnabled?: boolean;
+    /** Optional generationConfig passthrough (temperature, maxTokens, etc) */
+    generationConfig?: Record<string, any>;
+    /** Optional seed for deterministic session_id — defaults to hash of messages+model */
+    sessionSeed?: string;
+    /** Optional seed for user_prompt_id — defaults to last user message */
+    userPromptSeed?: string;
+    /** Optional projectId — not used in transformRequest but kept for symmetry */
+    projectId?: string;
+}
+/**
+ * Gemini content part.
+ * v2.1.14 merge: unions the request.ts declaration (thought/thoughtSignature)
+ * with the request-helpers.ts declaration (fileData plus the explicit
+ * GeminiFunctionCall/GeminiFunctionResponse sub-shapes).
+ */
+export interface GeminiPart {
+    text?: string;
+    thought?: boolean;
+    thoughtSignature?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    fileData?: {
+        mimeType: string;
+        fileUri: string;
+    };
+    functionCall?: GeminiFunctionCall;
+    functionResponse?: GeminiFunctionResponse;
+    [k: string]: unknown;
+}
+/**
+ * Gemini content turn.
+ * v2.1.14 merge: keeps the "system" role from request.ts alongside the
+ * user/model pair used by both halves.
+ */
+export interface OpenCodeMessage {
+    role: "system" | "user" | "assistant" | "tool" | "model" | string;
+    content?: string | any[] | null;
+    tool_calls?: Array<{
+        id: string;
+        type?: string;
+        function: {
+            name: string;
+            arguments: string | object;
+        };
+    }>;
+    tool_call_id?: string;
+    name?: string;
+    thinking?: string;
+    signature?: string;
+    [k: string]: any;
+}
+export interface GeminiContent {
+    role: "user" | "model" | "system";
+    parts: GeminiPart[];
+}
+/** System instruction content shape (live pipeline lineage). */
+export type GeminiSystem = {
+    parts: GeminiPart[];
+} | undefined;
+export interface GeminiTool {
+    functionDeclarations?: Array<{
+        name: string;
+        description?: string;
+        parameters?: any;
+    }>;
+}
+export interface TransformedRequest {
+    /** Normalized model id stripped of antigravity- prefix for routing but original preserved */
+    model: string;
+    /** Original model string exactly as user provided */
+    originalModel: string;
+    /** Gemini contents array ready for cloudcode-pa */
+    contents: GeminiContent[];
+    /** System instruction aggregated */
+    systemInstruction?: {
+        role: "system";
+        parts: GeminiPart[];
+    } | null;
+    /** Tools normalized to Gemini functionDeclarations */
+    tools?: GeminiTool[] | null;
+    /** Generation config with thinking budget mapped if provided */
+    generationConfig?: Record<string, any> | null;
+    /** Deterministic session_id via FNV-1a */
+    sessionId: string;
+    /** Deterministic user_prompt_id via FNV-1a */
+    userPromptId: string;
+    /** Thinking budget resolved */
+    thinkingBudget?: number;
+    /** Thinking level resolved */
+    thinkingLevel?: ThinkingLevel;
+}
+export declare const ALLOWED_SCHEMA_KEYS: Set<string>;
+export declare const MAX_TOOLS_PER_REQUEST: 128;
+/** Allowed top-level keys of a tool definition after cleaning. */
+export declare const ALLOWED_TOOL_TOP_KEYS: readonly ["name", "description", "parameters"];
+/** Direct production cloudcode-pa endpoint — bypasses any localhost proxy. */
+export declare const DIRECT_ENDPOINT: "https://cloudcode-pa.googleapis.com";
+/** Daily (canary) cloudcode-pa endpoint. */
+export declare const DAILY_ENDPOINT: "https://daily-cloudcode-pa.googleapis.com";
+/** Autopush sandbox endpoint. */
+export declare const AUTOPUSH_ENDPOINT: "https://autopush-cloudcode-pa.sandbox.googleapis.com";
+/** Cascade order used by the observer when retrying endpoints. */
+export declare const ENDPOINT_CASCADE: readonly ["https://daily-cloudcode-pa.googleapis.com", "https://autopush-cloudcode-pa.sandbox.googleapis.com", "https://cloudcode-pa.googleapis.com"];
+/**
+ * Headers stripped before sending to avoid 403 IAM (pi-mono #1830); Antigravity
+ * Manager never sends these on content requests.
+ */
+/**
+ * Thrown when transformRequest cannot normalize input.
+ */
+export declare class RequestTransformationError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Domain error for the merged observer helpers. Thrown instead of generic Error
+ * so callers can distinguish cleaning/normalization failures from transport.
+ */
+export declare class RequestHelpersError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string, cause?: unknown);
+}
+/**
+ * Computes FNV-1a 32-bit hash.
+ * Third-person: observer notes this hash is fast, no crypto deps, deterministic.
+ *
+ * @param input - string to hash
+ * @returns unsigned 32-bit integer
+ */
+/**
+ * Generates hex string padded to 8 chars from FNV-1a.
+ *
+ * @param input - seed
+ * @returns 8-char hex
+ */
+/**
+ * Returns the FNV-1a 32-bit digest of input padded to 8 hex chars.
+ *
+ * @param input - seed string
+ */
+export declare function fnv1aHex(input: string): string;
+/**
+ * Returns a 16-char hex digest from two independent FNV-1a rounds, used when
+ * longer session ids are needed without reaching for crypto randomness.
+ *
+ * @param input - seed string
+ */
+export declare function fnv1aHex16(input: string): string;
+/**
+ * Alias kept for fingerprint.ts compatibility.
+ */
+export declare const fnv1aHash: typeof fnv1a32;
+/**
+ * Normalizes model id — trims, lowercases for detection, preserves original case for request.
+ * Also strips antigravity- prefix for internal detection but keeps original model field elsewhere.
+ *
+ * @param modelId - raw model string
+ * @returns object with base, original, normalized
+ */
+export declare function parseModelId(modelId: string): {
+    original: string;
+    normalized: string;
+    base: string;
+    variantSuffixes: string[];
+};
+/**
+ * Detecta se modelo só funciona via endpoint Antigravity (cloudcode-pa v1internal)
+ * e não via genai público. Heurística baseada em prefixos e sufixos.
+ *
+ * @param modelId - ID do modelo (ex: "antigravity-claude-opus-4-6-thinking")
+ * @returns true se provavelmente só funciona em Antigravity
+ *
+ * Regras:
+ * - qualquer modelo começando com antigravity- => true
+ * - contém "claude" => true (Claude só via bypass Antigravity)
+ * - contém "customtools" => true (customtools é feature Antigravity 2026)
+ * - está no set ANTIGRAVITY_ONLY_EXACT
+ * - contém "rising-fact" ou "unwritten-orb" etc? Não, esses são projects, não modelos
+ */
+export declare function isLikelyAntigravityOnlyModel(modelId: string): boolean;
+export interface ExtractVariantsResult {
+    input: string;
+    base: string;
+    isAntigravity: boolean;
+    isThinking: boolean;
+    isCustomTools: boolean;
+    isPreview: boolean;
+    family: string;
+    variants: string[];
+    candidatesInCatalog: string[];
+    relatedModels: Array<{
+        id: string;
+        inCatalog: boolean;
+    }>;
+}
+/**
+ * Extrai variantes de um modelId, removendo prefixos/sufixos e gerando candidatos.
+ *
+ * Ex: "antigravity-claude-opus-4-6-thinking" =>
+ *   base: "claude-opus-4-6"
+ *   variants: ["antigravity-claude-opus-4-6-thinking", "antigravity-claude-opus-4-6", "claude-opus-4-6-thinking", "claude-opus-4-6", ...]
+ */
+export declare function extractVariants(modelId: string): ExtractVariantsResult;
+/**
+ * Helper que extrai variantes de lista ou objeto
+ */
+export declare function extractVariantsFromAny(input: unknown): ExtractVariantsResult[];
+/**
+ * Detailed model variant extraction result used for routing and budgets.
+ */
+export interface ModelVariantInfo {
+    original: string;
+    normalized: string;
+    base: string;
+    family: "gemini" | "claude" | "unknown";
+    isPreview: boolean;
+    isThinking: boolean;
+    thinkingVariant: "low" | "max" | null;
+    isCustomTools: boolean;
+    isClaude: boolean;
+    isGemini: boolean;
+    isAntigravityWrapper: boolean;
+    budgetHint?: number | undefined;
+    group: "antigravity" | "gemini-cli";
+}
+/**
+ * Extracts routing/budget metadata from a model id: family detection, preview
+ * and customtools flags, thinking-low/max variant, antigravity wrapper and the
+ * suggested quota group.
+ *
+ * @param modelId - raw model id
+ * @throws {RequestHelpersError} when modelId is empty
+ */
+export declare function extractModelVariant(modelId: string): ModelVariantInfo;
+/**
+ * Checklist alias of {@link extractModelVariant}.
+ */
+export declare const parseModelVariant: typeof extractModelVariant;
+/**
+ * Builds dynamic User-Agent antigravity/{version} {os}/{arch}.
+ * Third-person observer copies AM behavior to bypass ban on 1.11.5.
+ *
+ * @param version - optional semver
+ */
+export declare function buildDynamicUserAgent(version?: string): string;
+/**
+ * Builds Client-Metadata header.
+ *
+ * @param version - optional version
+ */
+/**
+ * Builds X-Goog-Api-Client header — only for gemini-cli mode.
+ *
+ * @param version - optional
+ */
+export declare function buildApiClient(version?: string): string;
+/**
+ * Generates fingerprint headers for given style.
+ * Observer knows:
+ * - AM only sends User-Agent on content requests (not on onboard/load)
+ * - Never sends X-Goog-QuotaUser nor X-Client-Device-Id
+ * - Gemini CLI includes X-Goog-Api-Client
+ *
+ * @param style - 'antigravity' or 'gemini-cli'
+ * @param version - optional antigravity version
+ * @returns headers record
+ */
+/**
+ * Alias required by checklist naming: strip x-goog-user-project header explicit.
+ *
+ * @param headers - headers map
+ * @returns cleaned map
+ */
+export declare function stripXGoogUserProjectHeader(headers: Record<string, string>): Record<string, string>;
+/**
+ * Checks whether an HTTP status should trigger cascade retry:
+ * 429, 403, 404 and the whole 5xx range.
+ *
+ * @param status - HTTP status code
+ */
+/**
+ * Recursively cleans a JSON Schema node down to only the keys listed in
+ * {@link ALLOWED_SCHEMA_KEYS}. This removes $schema/$ref/title/
+ * additionalProperties/default/examples and similar unknown names that trigger
+ * "Invalid JSON payload Unknown name" errors upstream.
+ *
+ * v2.1.14 merge note: renamed from cleanJsonSchema (request-helpers.ts) to
+ * cleanJsonSchemaStrict; the tolerant Gemini-shaping normalizer from
+ * request.ts owns the cleanJsonSchema name. ALLOWED_SCHEMA_KEYS is now the
+ * full allowlist Set from request.ts; the switch below still only emits the
+ * six core keys, so the observable behavior of this strict cleaner is
+ * unchanged by the merge.
+ *
+ * @param schema - raw schema node
+ * @param depth - recursion guard, throws past depth 12
+ * @returns cleaned schema object or undefined when not salvageable
+ * @throws {RequestHelpersError} when depth exceeds 12 (possible circular schema)
+ */
+export declare function cleanJsonSchemaStrict(schema: unknown, depth?: number): Record<string, unknown> | undefined;
+/**
+ * Cleaned tool definition compatible with Gemini functionDeclarations.
+ */
+export interface CleanedTool {
+    name: string;
+    description?: string | undefined;
+    parameters: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[] | undefined;
+        description?: string | undefined;
+    };
+}
+/**
+ * Cleans a single raw tool definition (OpenAI wrapper, Anthropic input_schema
+ * or plain parameters) into a {@link CleanedTool} with a sanitized name and a
+ * root-object schema enforced.
+ *
+ * v2.1.14 merge note: keeps its name; it now builds on
+ * cleanJsonSchemaStrict (the strict cleaner formerly exported as the
+ * request-helpers cleanJsonSchema).
+ *
+ * @param raw - raw tool definition
+ * @throws {RequestHelpersError} on missing/invalid objects or names
+ */
+export declare function cleanRawToolSchema(raw: unknown): CleanedTool;
+/**
+ * Cleans an array of raw tools into deduplicated {@link CleanedTool} entries
+ * (last wins per sanitized name), capped at {@link MAX_TOOLS_PER_REQUEST}.
+ * Invalid tools are skipped rather than failing the request.
+ *
+ * @param tools - array of raw tool definitions
+ * @throws {RequestHelpersError} when input is not an array
+ */
+export declare function cleanToolsArray(tools: unknown): CleanedTool[];
+/**
+ * Maps a thinking block to Gemini thought part.
+ * For Gemini 3 and Claude via Antigravity, thought parts must have thought: true.
+ * Optionally includes thoughtSignature for multi-turn preservation.
+ *
+ * @param text - thinking text
+ * @param signature - optional signature for LRU cache in streaming.ts
+ * @returns GeminiPart
+ */
+export declare function mapThinkingBlock(text: string, signature?: string): GeminiPart;
+/**
+ * Sorts parts so that thought parts come first, then text, then function calls.
+ * Required because Gemini/Claude require thinking block order validation.
+ *
+ * @param parts - parts array
+ * @returns sorted parts
+ */
+export declare function sortThoughtFirst(parts: GeminiPart[]): GeminiPart[];
+/**
+ * Filters and normalizes thinking content — removes empty thinking and ensures
+ * signature preservation.
+ *
+ * @param parts - incoming parts
+ * @returns filtered parts
+ */
+export declare function filterAndMapThinkingParts(parts: any[]): GeminiPart[];
+/**
+ * Detects thinking blocks that must be filtered before dispatch: thought flags,
+ * type discriminators, reasoning_content/reasoning fields.
+ *
+ * @param block - any part-like object
+ */
+export declare function isThinkingBlock(block: unknown): boolean;
+/**
+ * Filters thinking blocks from a parts array.
+ *
+ * @param parts - array of parts in any shape
+ * @throws {RequestHelpersError} when input is not an array
+ */
+export declare function filterThinkingBlocksFromParts(parts: unknown): GeminiPart[];
+/**
+ * Filters thinking parts inside each Gemini message, dropping messages that
+ * become empty (including system).
+ *
+ * @param messages - Gemini-shaped messages
+ * @throws {RequestHelpersError} when input is not an array
+ */
+export declare function filterThinkingBlocksFromMessages(messages: unknown): GeminiMessage[];
+/**
+ * Auto-detecting filter: routes message arrays (role+parts items) to
+ * {@link filterThinkingBlocksFromMessages} and everything else to
+ * {@link filterThinkingBlocksFromParts}.
+ *
+ * Named `filterThinkingBlocksAuto` because the historical overloaded
+ * `filterThinkingBlocks` keeps its original tag-stripping/string semantics.
+ *
+ * @param input - parts array or messages array
+ * @throws {RequestHelpersError} when input is not an array
+ */
+export declare function filterThinkingBlocksAuto(input: unknown): unknown[];
+export interface ThoughtLikePart {
+    thought?: boolean;
+    thinking?: boolean;
+    type?: string;
+    text?: string;
+    content?: string;
+    reasoning?: string;
+    [k: string]: unknown;
+}
+export declare function filterThinkingBlocks(input: string): string;
+export declare function filterThinkingBlocks<T extends ThoughtLikePart>(input: T[]): T[];
+export declare function filterThinkingBlocks(input: unknown): unknown;
+/**
+ * Definition for google_search built-in grounding tool wrapped as function declaration
+ * for compatibility with OpenCode → Gemini flow.
+ * Observer notes: original plugin shekohex uses wrapper to call separate search API.
+ */
+export declare const GOOGLE_SEARCH_FUNCTION_DECLARATION: {
+    readonly name: "google_search";
+    readonly description: "Search the web for real-time information, factual grounding, current events, documentation, and recent knowledge. Use when user asks for latest information, news, or requires browsing to answer.";
+    readonly parameters: {
+        readonly type: "OBJECT";
+        readonly properties: {
+            readonly query: {
+                readonly type: "STRING";
+                readonly description: "Search query string, 3-10 words focused keywords";
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+};
+export declare const URL_CONTEXT_FUNCTION_DECLARATION: {
+    readonly name: "url_context";
+    readonly description: "Fetch and provide context from a URL for grounding.";
+    readonly parameters: {
+        readonly type: "OBJECT";
+        readonly properties: {
+            readonly url: {
+                readonly type: "STRING";
+                readonly description: "HTTP(S) URL to fetch";
+            };
+        };
+        readonly required: readonly ["url"];
+    };
+};
+/**
+ * Injects google_search tool into declarations if enabled and not already present.
+ *
+ * @param declarations - existing declarations array
+ * @param enabled - whether injection enabled
+ * @param includeUrlContext - whether to also inject url_context
+ * @returns new declarations array with injection
+ */
+export declare function injectGoogleSearchTool(declarations: Array<{
+    name: string;
+    description?: string;
+    parameters?: any;
+    originalName: string;
+}>, enabled?: boolean, includeUrlContext?: boolean): Array<{
+    name: string;
+    description?: string;
+    parameters?: any;
+    originalName: string;
+}>;
+/**
+ * Parses OpenAI tool arguments which may be stringified JSON.
+ *
+ * @param args - args string or object
+ * @returns parsed object
+ */
+export declare function parseFunctionArgs(args: string | object | any): Record<string, any>;
+/**
+ * Attempts to extract last user prompt text for deterministic user_prompt_id.
+ *
+ * @param messages - messages array
+ * @returns last user text or fallback
+ */
+export declare function extractLastUserPrompt(messages: OpenCodeMessage[]): string;
+export interface OpenCodeContentPart {
+    type?: string;
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: string;
+    };
+    id?: string;
+    tool_call_id?: string;
+    name?: string;
+    function?: {
+        name: string;
+        arguments: string | object;
+    };
+    [k: string]: unknown;
+}
+export interface OpenCodeToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string | object;
+    };
+}
+export interface GeminiFunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+export interface GeminiFunctionResponse {
+    name: string;
+    response: Record<string, unknown>;
+}
+export interface NormalizedMessagesResult {
+    systemInstruction?: GeminiSystemInstruction;
+    contents: GeminiContent[];
+    /** mensagens originais ignoradas por serem vazias */
+    droppedCount: number;
+}
+/**
+ * Normaliza lista de mensagens OpenCode (OpenAI-like) para formato Gemini
+ * Cloud Code Assist v1internal.
+ *
+ * - system => systemInstruction (combinado)
+ * - user => role user
+ * - assistant => role model, com functionCall se tiver tool_calls
+ * - tool => role user com functionResponse
+ * - filtra thinking blocks automaticamente
+ * - merge mensagens consecutivas de mesmo role
+ *
+ * @param messages - mensagens OpenCode
+ * @param opts - includeSystemAsUser? Se true, system vai como user prefixado
+ */
+export declare function normalizeMessages(messages: OpenCodeMessage[], opts?: {
+    mergeConsecutive?: boolean;
+    includeSystemAsUser?: boolean;
+    filterThinking?: boolean;
+}): NormalizedMessagesResult;
+/**
+ * Normalizes any role spelling onto the Gemini system/user/model triad.
+ * Tool-ish roles map to user because Cloud Code Assist expects
+ * functionResponse parts inside a user turn.
+ *
+ * @param rawRole - incoming role string
+ */
+export declare function normalizeRole(rawRole: string): "system" | "user" | "model";
+/**
+ * Normalizes one content element (string, block array or object) into Gemini
+ * parts. Skips thinking blocks, degrades images to markers and converts
+ * tool_use/tool_result blocks into functionCall/functionResponse parts.
+ *
+ * @param content - incoming content of any shape
+ */
+export declare function normalizeContentToParts(content: unknown): GeminiPart[];
+/**
+ * Gemini message with normalized role plus raw-role provenance.
+ */
+export interface GeminiMessage {
+    role: "system" | "user" | "model";
+    parts: GeminiPart[];
+    _rawRole?: string;
+}
+/**
+ * Generic incoming OpenCode / OpenAI / Anthropic message shape.
+ */
+export interface IncomingMessage {
+    role: string;
+    content?: string | unknown[] | Record<string, unknown> | null;
+    name?: string;
+    tool_calls?: Array<{
+        id?: string;
+        type?: string;
+        function?: {
+            name: string;
+            arguments?: string | Record<string, unknown>;
+        };
+    }>;
+    tool_call_id?: string;
+    tool_use_id?: string;
+    [k: string]: unknown;
+}
+/**
+ * Normalizes incoming OpenCode / OpenAI / Anthropic messages into Gemini
+ * messages: role mapping via normalizeRole, content via normalizeContentToParts,
+ * OpenAI tool_calls converted to functionCall parts, thinking blocks filtered,
+ * consecutive same-role messages merged (except system).
+ *
+ * Named `normalizeIncomingMessages` because the historical `normalizeMessages`
+ * keeps its original signature in this module.
+ *
+ * @param messages - array of incoming messages of any shape
+ * @throws {RequestHelpersError} when input is not an array
+ */
+export declare function normalizeIncomingMessages(messages: unknown): GeminiMessage[];
+export interface EnhancedAgyError {
+    message: string;
+    code?: string | undefined;
+    status?: number | undefined;
+    statusText?: string | undefined;
+    details?: unknown | undefined;
+    isRetryable: boolean;
+    isAuthError: boolean;
+    isQuotaError: boolean;
+    isModelError: boolean;
+    isThinkingBudgetError: boolean;
+    original: unknown;
+    suggestion?: string | undefined;
+    requestId?: string | undefined;
+    modelId?: string | undefined;
+}
+/**
+ * Enriquece erro vindo do Agentic SDK / Cloud Code Assist.
+ * Detecta auth, quota, model not found, thinking budget etc e sugere correção.
+ *
+ * @param error - erro bruto (Error, Response, objeto, string)
+ * @param context - contexto opcional com modelId, requestId etc
+ */
+export declare function enhanceAgySdkErrorResponse(error: unknown, context?: {
+    modelId?: string;
+    requestId?: string;
+}): EnhancedAgyError;
+/**
+ * Transforms OpenCode request (OpenAI/Anthropic mixed) into Gemini/Antigravity
+ * normalized request ready for cloudcode-pa envelope.
+ *
+ * Steps performed by third-person observer:
+ * - Validates model, messages
+ * - Parses model variant to extract thinkingLevel/budget
+ * - Aggregates system instructions
+ * - Normalizes contents: user ↔ model, maps thinking blocks first,
+ *   handles tool_use/tool_result pairing, handles OpenAI tool_calls
+ * - Cleans tool schemas, sanitizes tool names, ensures uniqueness
+ * - Injects google_search tool when enabled
+ * - Generates deterministic session_id and user_prompt_id via FNV-1a
+ * - Builds generationConfig with thinking budget if applicable
+ * - Supports 2026 models aliasing
+ *
+ * @param input - transform input
+ * @returns transformed request
+ * @throws RequestTransformationError on invalid input
+ */
+/** X-Goog-Api-Client value observed on real Gemini CLI traffic. */
+/** Client metadata object injected by Gemini CLI for bypass requests. */
+/** Fallback project id when no cloud project is resolved. */
+/** Production Cloud Code Assist base endpoint. */
+/** Daily (canary) Cloud Code Assist base endpoint — default for pure Gemini CLI bypass. */
+/** v1internal method suffixes observed on Cloud Code Assist traffic.
+ * v2.1.15 Phase A: renamed from the historical local name
+ * CODE_ASSIST_ENDPOINTS (a method-path map) so the host-map semantic of that
+ * name resolves to the models.ts owner; re-exported below for surface
+ * continuity. */
+export declare const CODE_ASSIST_METHOD_PATHS: {
+    readonly GENERATE: "/v1internal:generateContent";
+    readonly STREAM_GENERATE: "/v1internal:streamGenerateContent";
+    readonly LOAD: "/v1internal:loadCodeAssist";
+};
+/** Cloud Code Assist HOST map (canonical owner: models.ts).
+ * @deprecated legacy alias kept for the historical request-module surface. */
+export { CODE_ASSIST_ENDPOINTS } from "./models.js";
+/**
+ * Computes FNV-1a 64-bit hash over UTF-8 bytes.
+ * Complements the 32-bit variant when longer deterministic digests are needed.
+ *
+ * @param input - string to hash
+ * @returns unsigned 64-bit integer as bigint
+ */
+export declare function fnv1a64BigInt(input: string): bigint;
+/**
+ * Options controlling {@link buildUserPromptId} output shape.
+ */
+export interface BuildPromptIdOptions {
+    /** Custom prefix, defaults to "agyp_". */
+    prefix?: string;
+    /** Extra seed for disambiguation, e.g. projectId or sessionId. */
+    seed?: string;
+    /** Include timestamp? Breaks determinism, discouraged but supported. */
+    includeTimestamp?: boolean;
+    /** Hash length: "short" yields 8 hex chars, "long" adds a 12-char 64-bit suffix. */
+    length?: "short" | "long";
+}
+/**
+ * Generates a deterministic session_id via FNV-1a over the working directory.
+ * Same directory implies same session_id, which keeps fingerprints stable.
+ *
+ * @param directory - optional directory; falls back to cwd, then home dir
+ * @returns session id like `sess_1a2b3c4d5e6f7a8b9c0d`
+ */
+export declare function buildSessionIdFromDir(directory?: string | null): string;
+/**
+ * Generates a deterministic user_prompt_id via FNV-1a.
+ * Used by the Cloud Code backend for deduplication.
+ *
+ * @param input - prompt content; objects are JSON.stringify-ed; omitted input
+ *                falls back to hostname|cwd|pid for per-workspace stability
+ * @param opts - options object or bare seed string
+ * @returns id like `agyp_1a2b3c4d` or `agyp_1a2b3c4d-9f8e7d6c5b4a`
+ */
+export declare function buildUserPromptId(input?: string | object | null | undefined, opts?: BuildPromptIdOptions | string): string;
+/**
+ * Compatibility alias for fingerprint.ts: derives the session id from a directory.
+ * Kept alongside {@link generateSessionId}, which hashes an arbitrary seed instead.
+ *
+ * @param directory - optional directory path
+ * @returns deterministic session id
+ */
+export declare function buildSessionId(directory?: string): string;
+/**
+ * Normalizes free-form thinking input (string, options object, or message field)
+ * into a canonical level. Unknown values collapse to "medium"; explicit
+ * none/off inputs yield "none".
+ *
+ * @param input - raw thinking spec
+ * @returns canonical level including "none"
+ */
+export declare function normalizeThinkingLevel(input: unknown): ThinkingLevel | "none";
+/**
+ * Parses free-form input into a canonical thinking level. Also maps
+ * none/off onto minimal for compatibility.
+ *
+ * @param input - level-like value
+ * @returns canonical level or undefined when not parseable
+ */
+export declare function parseThinkingLevel(input: unknown): ThinkingLevel | undefined;
+/**
+ * Maps a thinking level (or numeric budget) onto its token budget, clamping
+ * numbers into [THINKING_BUDGET_MIN, THINKING_BUDGET_MAX]. Unknown named levels
+ * safely fall back to medium.
+ *
+ * @param level - level name, numeric budget or numeric string
+ * @throws {RequestHelpersError} on non-finite numbers or empty strings
+ */
+export declare function mapThinkingLevelToBudget(level: string | number): number;
+/**
+ * Spec-required alias of {@link mapThinkingLevelToBudget}.
+ */
+export declare const thinkingLevelToBudget: typeof mapThinkingLevelToBudget;
+/**
+ * Budget hint for a parsed variant suffix.
+ *
+ * @param variant - "low", "max" or null
+ */
+export declare function getThinkingBudgetForVariant(variant: "low" | "max" | null): number;
+/**
+ * Anthropic/OpenAI-style content block tolerated inside OpenCode messages.
+ */
+export interface OpenCodeContentBlock {
+    type?: string;
+    text?: string;
+    thinking?: string;
+    level?: ThinkingLevel | string;
+    thought?: string;
+    id?: string;
+    name?: string;
+    input?: unknown;
+    args?: unknown;
+    tool_use_id?: string;
+    tool_call_id?: string;
+    content?: unknown;
+    source?: {
+        type?: string;
+        media_type?: string;
+        data?: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Full OpenCode request envelope with thinking/search/session passthrough fields.
+ */
+export interface OpenCodeRequest {
+    model?: string;
+    messages?: OpenCodeMessage[];
+    tools?: OpenCodeTool[];
+    tool_choice?: unknown;
+    thinking?: ThinkingLevel | string | {
+        level?: ThinkingLevel | string;
+        budget?: number;
+        type?: string;
+        budget_tokens?: number;
+    };
+    thinkingLevel?: ThinkingLevel | string;
+    thinking_level?: ThinkingLevel | string;
+    directory?: string;
+    cwd?: string;
+    project?: string;
+    projectId?: string;
+    temperature?: number;
+    top_p?: number;
+    topP?: number;
+    top_k?: number;
+    topK?: number;
+    max_tokens?: number;
+    maxTokens?: number;
+    google_search?: boolean;
+    enable_google_search?: boolean;
+    enableGoogleSearch?: boolean;
+    session_id?: string;
+    user_prompt_id?: string;
+    [key: string]: unknown;
+}
+/**
+ * System instruction shape accepted by Cloud Code Assist.
+ */
+export interface GeminiSystemInstruction {
+    role?: "system";
+    parts: GeminiPart[];
+}
+/**
+ * Function declaration shape used in Gemini tools payloads.
+ */
+export interface GeminiFunctionDeclaration {
+    name: string;
+    description?: string;
+    parameters?: any;
+}
+/**
+ * Generation config including thinkingConfig with level/budget mapping.
+ * v2.1.14 merge: unions the request.ts declaration (top-level thinking
+ * compat fields) with the request-helpers.ts declaration (penalties,
+ * responseMimeType and the index signature).
+ */
+export interface GeminiGenerationConfig {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxOutputTokens?: number;
+    stopSequences?: string[];
+    candidateCount?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    thinkingConfig?: {
+        thinkingLevel?: string;
+        thinkingBudget?: number;
+        includeThoughts?: boolean;
+    };
+    responseMimeType?: string;
+    thinkingLevel?: string;
+    thinkingBudget?: number;
+    [k: string]: unknown;
+}
+/**
+ * Inner `request` field of the Cloud Code Assist v1internal envelope.
+ */
+export interface CloudCodeAssistInnerRequest {
+    contents: GeminiContent[];
+    systemInstruction?: GeminiSystemInstruction;
+    tools?: any[];
+    toolConfig?: {
+        functionCallingConfig?: {
+            mode: string;
+            allowedFunctionNames?: string[];
+        };
+    };
+    generationConfig?: GeminiGenerationConfig;
+}
+/**
+ * Options bag accepted by the merged transform helpers.
+ */
+export interface TransformOptions {
+    projectId?: string;
+    directory?: string;
+    enableGoogleSearch?: boolean;
+    thinkingLevel?: ThinkingLevel | string;
+    model?: string;
+    sessionId?: string;
+    userPromptId?: string;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxTokens?: number;
+}
+/**
+ * Result of {@link transformTools}: ready-made tools payload plus tool config.
+ */
+export interface TransformToolsResult {
+    tools: any[] | undefined;
+    toolConfig?: {
+        functionCallingConfig: {
+            mode: string;
+            allowedFunctionNames?: string[];
+        };
+    } | undefined;
+    sanitizedMap: Record<string, string>;
+}
+/**
+ * Complete fetch payload for Antigravity / Cloud Code Assist endpoints.
+ */
+export interface AntigravityFetchPayload {
+    url: string;
+    method: "POST";
+    headers: Record<string, string>;
+    body: {
+        model: string;
+        project: string;
+        request: CloudCodeAssistInnerRequest;
+        user_prompt_id: string;
+        session_id: string;
+        requestId?: string;
+    };
+    rawBody: string;
+    model: string;
+    project: string;
+    user_prompt_id: string;
+    session_id: string;
+    isGeminiCLIOnly: boolean;
+}
+/**
+ * Builds a GeminiGenerationConfig from an OpenCode request plus overrides.
+ *
+ * v2.1.14 merge note: renamed from buildGenerationConfig so the richer
+ * options-object builder merged from request-helpers.ts can own that name.
+ * Resolves the thinking level (override > opts > request > default) and maps
+ * it onto the canonical budget map.
+ *
+ * @param req - OpenCode request with optional sampling/thinking fields
+ * @param opts - transform-level overrides
+ * @param thinkingLevelOverride - explicit level that wins over everything else
+ * @returns generation config ready for CloudCodeAssistInnerRequest
+ */
+export declare function buildGenerationConfigFromRequest(req: OpenCodeRequest, opts?: TransformOptions, thinkingLevelOverride?: ThinkingLevel): GeminiGenerationConfig;
+export interface BuildGenerationConfigOptions {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxTokens?: number;
+    maxOutputTokens?: number;
+    thinkingLevel?: ThinkingLevel;
+    thinkingBudget?: number;
+    includeThoughts?: boolean;
+    modelId?: string;
+    stopSequences?: string[];
+    candidateCount?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    responseMimeType?: string;
+}
+/**
+ * Constrói GenerationConfig para cloudcode-pa v1internal.
+ * Mapeia thinkingLevel (minimal/low/medium/high) para thinkingBudget.
+ *
+ * - Para modelos Gemini: minimal=0 (desativa), low=1024, medium=4096, high=8192
+ * - Para modelos Claude (via Antigravity): budgets maiores
+ * - Se thinkingBudget direto fornecido, usa direto
+ * - Se thinkingLevel=none/minimal com includeThoughts=false, omite includeThoughts para economia
+ *
+ * @param opts - opções de geração
+ * @returns config compatível com v1internal:generateContent
+ */
+export declare function buildGenerationConfig(opts?: BuildGenerationConfigOptions): GeminiGenerationConfig;
+/**
+ * Builds the exact header set used by Gemini CLI bypass traffic:
+ * User-Agent, X-Goog-Api-Client, Client-Metadata (header and mirrored
+ * X-Goog-Client-Metadata), JSON content type, gzip accept-encoding, and an
+ * optional Bearer authorization merged last so extras can override.
+ *
+ * @param token - optional OAuth token; "Bearer " prefix added when missing
+ * @param extra - additional headers merged after the defaults
+ * @returns headers record ready for fetch
+ */
+export declare function buildBypassHeaders(token?: string, extra?: Record<string, string>): Record<string, string>;
+/**
+ * Cleans one JSON Schema for Gemini function declarations: drops every key not
+ * present in {@link ALLOWED_SCHEMA_KEYS} (recursively), normalizes oneOf to
+ * anyOf, filters required/enum arrays, and defaults type to object when
+ * properties exist.
+ *
+ * @param schema - raw schema node of any shape
+ * @returns cleaned schema (same reference type semantics as input primitives)
+ */
+export declare function cleanToolSchema(schema: unknown): any;
+export interface CleanToolSchemaOptions {
+    maxDepth?: number;
+    keepFormat?: boolean;
+    keepDescription?: boolean;
+}
+/**
+ * Limpa e normaliza JSON Schema de tool para formato aceito por Gemini / Cloud Code Assist.
+ *
+ * O que faz:
+ * - remove $schema, $id, examples, etc
+ * - remove chaves undefined / null vazias
+ * - normaliza type para lowercase e singular
+ * - converte `const: X` para `enum: [X]`
+ * - limpa recursivamente properties, items, anyOf/oneOf/allOf
+ * - garante que object com properties tenha type=object
+ * - remove propriedades vazias
+ * - impede profundidade infinita (>20)
+ *
+ * v2.1.14 merge note: renamed from cleanToolSchema (request-helpers.ts) to
+ * cleanToolSchemaTolerant; the strict allowlist cleaner from request.ts owns
+ * the cleanToolSchema name.
+ *
+ * @param schema - schema bruto (any)
+ * @param opts - opções
+ * @returns schema limpo
+ */
+export declare function cleanToolSchemaTolerant(schema: unknown, opts?: CleanToolSchemaOptions, _depth?: number): unknown;
+/**
+ * Versão plural que limpa mapa de tools ou array de function declarations
+ *
+ * v2.1.14 merge note: canonical plural (superset of request.ts's array-only
+ * variant; strict-array cleaning stays available via schemas.map(cleanToolSchema)).
+ */
+export declare function cleanToolSchemas(tools: unknown, opts?: CleanToolSchemaOptions): unknown;
+/**
+ * Checks whether a tool name already satisfies the Gemini naming rules.
+ *
+ * @param name - candidate name
+ * @returns true when valid without sanitization
+ */
+export declare function isValidToolName(name: string): boolean;
+/**
+ * Detailed result of {@link validateToolNames}.
+ */
+export interface ValidateToolNamesResult {
+    valid: string[];
+    invalid: string[];
+    sanitized: Record<string, string>;
+    duplicates: string[];
+}
+/**
+ * Validates a list of tool names, reporting duplicates and computing sanitized
+ * replacements for invalid entries.
+ *
+ * @param names - raw tool names
+ * @returns valid/invalid partitions plus sanitized mapping
+ */
+export declare function validateToolNames(names: string[]): ValidateToolNamesResult;
+/**
+ * Validates one tool name against the Gemini naming rules.
+ *
+ * @param name - candidate name of any type
+ */
+export declare function validateToolName(name: unknown): boolean;
+export interface InvalidToolName {
+    name: string;
+    reason: string;
+}
+export interface SanitizedToolName {
+    original: string;
+    sanitized: string;
+}
+export interface ValidateToolNamesDetailedResult {
+    valid: boolean;
+    validNames: string[];
+    invalid: InvalidToolName[];
+    sanitized: SanitizedToolName[];
+    allSanitizedValid: boolean;
+}
+/**
+ * Valida lista de nomes de tools. Gemini exige ^[A-Za-z_][A-Za-z0-9_]*$ e max 64.
+ *
+ * v2.1.14 merge note: renamed from validateToolNames (request-helpers.ts);
+ * the canonical TOOL_NAME_REGEX (letter start + 64 cap, from request.ts)
+ * now backs this validator.
+ *
+ * @param tools - array de string, array de {name}, ou Record<string,any>
+ * @returns resultado com valid/invalid/sanitized
+ */
+export declare function validateToolNamesDetailed(tools: Array<string | {
+    name: string;
+    [k: string]: unknown;
+}> | Record<string, unknown>): ValidateToolNamesDetailedResult;
+/**
+ * Converts OpenCode tool definitions into the Cloud Code Assist tools payload:
+ * validates names, sanitizes invalid ones, cleans each schema, deduplicates by
+ * final name, optionally injects `{ google_search: {} }`, and emits the
+ * matching AUTO function-calling toolConfig.
+ *
+ * Kept alongside {@link validateAndSanitizeTools}, which returns flat
+ * declarations instead of a wrapped payload.
+ *
+ * @param openTools - raw tools in OpenAI/Anthropic/Gemini shapes
+ * @param enableGoogleSearch - inject the google_search built-in tool
+ * @returns tools payload, tool config and sanitized-name map
+ */
+export declare function transformTools(openTools: OpenCodeTool[] | undefined, enableGoogleSearch?: boolean): TransformToolsResult;
+/**
+ * Named bundle mirroring the legacy ONDA 4 module surface. The default export
+ * remains {@link RequestPipeline}; both barrels stay available.
+ */
+export declare const RequestTransformer: {
+    readonly GEMINI_CLI_OAUTH_CLIENT_ID: string;
+    readonly GEMINI_CLI_OAUTH_CLIENT_SECRET: string;
+    readonly GEMINI_CLI_USER_AGENT: "GeminiCLI/0.57.0/gemini-3-pro-preview (linux; x64; GitHub) google-api-nodejs-client/9.15.1";
+    readonly X_GOOG_API_CLIENT: "gl-node/22.19.0";
+    readonly CLIENT_METADATA: {
+        readonly ideType: "IDE_UNSPECIFIED";
+        readonly platform: "PLATFORM_UNSPECIFIED";
+        readonly pluginType: "GEMINI";
+    };
+    readonly CLIENT_METADATA_STRING: "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI";
+    readonly FALLBACK_PROJECT_ID: "rising-fact-p41fc";
+    readonly CLOUDCODE_PA_BASE: "https://cloudcode-pa.googleapis.com";
+    readonly CLOUDCODE_DAILY_BASE: "https://daily-cloudcode-pa.googleapis.com";
+    readonly CODE_ASSIST_ENDPOINTS: {
+        readonly GENERATE: "/v1internal:generateContent";
+        readonly STREAM_GENERATE: "/v1internal:streamGenerateContent";
+        readonly LOAD: "/v1internal:loadCodeAssist";
+    };
+    readonly CODE_ASSIST_METHOD_PATHS: {
+        readonly GENERATE: "/v1internal:generateContent";
+        readonly STREAM_GENERATE: "/v1internal:streamGenerateContent";
+        readonly LOAD: "/v1internal:loadCodeAssist";
+    };
+    readonly MODELS_2026: readonly ["gemini-3-pro-preview", "gemini-3-flash-preview", "gemini-3.1-pro-preview", "gemini-3.1-pro-preview-customtools", "gemini-3-flash", "gemini-3-pro", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5", "claude-opus-4-6-thinking", "claude-opus-4-6-thinking-low", "claude-opus-4-6-thinking-max", "claude-sonnet-4-6", "claude-sonnet-4-6-thinking", "claude-opus-4-5-thinking", "antigravity-gemini-3-pro", "antigravity-gemini-3-flash", "antigravity-gemini-3.1-pro", "antigravity-gemini-3-pro-preview", "antigravity-gemini-3-flash-preview", "antigravity-claude-opus-4-6-thinking", "antigravity-claude-sonnet-4-6"];
+    readonly THINKING_BUDGET_MAP: Record<"high" | "low" | "max" | "medium" | "minimal" | "tiered", number>;
+    readonly fnv1a32: typeof fnv1a32;
+    readonly fnv1a64BigInt: typeof fnv1a64BigInt;
+    readonly buildSessionIdFromDir: typeof buildSessionIdFromDir;
+    readonly buildSessionId: typeof buildSessionId;
+    readonly buildUserPromptId: typeof buildUserPromptId;
+    readonly sanitizeToolName: typeof sanitizeToolName;
+    readonly isValidToolName: typeof isValidToolName;
+    readonly validateToolNames: typeof validateToolNames;
+    readonly cleanToolSchema: typeof cleanToolSchema;
+    readonly cleanToolSchemas: typeof cleanToolSchemas;
+    readonly transformTools: typeof transformTools;
+    readonly normalizeThinkingLevel: typeof normalizeThinkingLevel;
+    readonly mapThinkingLevelToBudget: typeof mapThinkingLevelToBudget;
+    readonly isGeminiCLIOnlyModel: typeof isGeminiCLIOnlyModel;
+    readonly isLikelyAntigravityOnlyModel: typeof isLikelyAntigravityOnlyModel;
+    readonly buildGenerationConfigFromRequest: typeof buildGenerationConfigFromRequest;
+    readonly buildBypassHeaders: typeof buildBypassHeaders;
+    readonly transformRequest: typeof transformRequest;
+    readonly buildAntigravityRequest: typeof buildAntigravityRequest;
+    readonly buildGeminiCLIRequest: typeof buildGeminiCLIRequest;
+};
+export declare const RequestPipeline: {
+    transformRequest: typeof transformRequest;
+    buildAntigravityRequest: typeof buildAntigravityRequest;
+    buildGeminiCLIRequest: typeof buildGeminiCLIRequest;
+    isGeminiCLIOnlyModel: typeof isGeminiCLIOnlyModel;
+    getEndpointsForModel: typeof getEndpointsForModel;
+    fnv1a32: typeof fnv1a32;
+    fnv1a32Hex: typeof fnv1a32Hex;
+    generateDeterministicId: typeof generateDeterministicId;
+    generateSessionId: typeof generateSessionId;
+    generateUserPromptId: typeof generateUserPromptId;
+    sanitizeToolName: typeof sanitizeToolName;
+    ensureUniqueToolNames: typeof ensureUniqueToolNames;
+    validateAndSanitizeTools: typeof validateAndSanitizeTools;
+    cleanJsonSchema: typeof cleanJsonSchema;
+    mapThinkingBlock: typeof mapThinkingBlock;
+    sortThoughtFirst: typeof sortThoughtFirst;
+    filterAndMapThinkingParts: typeof filterAndMapThinkingParts;
+    injectGoogleSearchTool: typeof injectGoogleSearchTool;
+    stripForbiddenHeaders: typeof stripForbiddenHeaders;
+    stripXGoogUserProjectHeader: typeof stripXGoogUserProjectHeader;
+    getFingerprintHeaders: typeof getFingerprintHeaders;
+    buildDynamicUserAgent: typeof buildDynamicUserAgent;
+    fetchWithCascade: typeof fetchWithCascade;
+    parseModelId: typeof parseModelId;
+    extractThinkingLevel: typeof extractThinkingLevel;
+};
+export declare function stripForbiddenHeaders(headers: Record<string, string>): Record<string, string>;
+/** Cloud Code streaming method path (family owner — former plugin.ts local). */
+export declare const STREAM_METHOD: "/v1internal:streamGenerateContent?alt=sse";
+/** Cloud Code non-streaming method path. */
+export declare const GENERATE_METHOD: "/v1internal:generateContent";
+/** Cloud Code loadCodeAssist method path (project discovery). */
+export declare const LOAD_METHOD: "/v1internal:loadCodeAssist";
+/** Cloud Code onboardUser method path (project discovery). */
+export declare const ONBOARD_METHOD: "/v1internal:onboardUser";
+export declare const TOOL_NAME_REGEX: RegExp;
+declare function sanitizeToolName(name: string): string;
+declare function ensureUniqueToolNames(names: string[]): string[];
+declare function cleanJsonSchema(input: any, seen?: WeakSet<object>): any;
+declare function validateAndSanitizeTools(rawTools?: any[]): {
+    declarations: any[];
+};
+export declare function generateDeterministicId(seed: string): string;
+export declare function generateSessionId(seed?: string, offsetEnabled?: boolean): string;
+export declare function generateUserPromptId(seed?: string, offsetEnabled?: boolean): string;
+interface TransformRequestOptions {
+    model: string;
+    messages?: any[] | undefined;
+    tools?: any[] | undefined;
+    system?: string | any | undefined;
+    thinkingLevel?: string | undefined;
+    thinkingBudget?: number | undefined;
+    googleSearchEnabled?: boolean | undefined;
+    generationConfig?: any | undefined;
+    sessionSeed?: string | undefined;
+    userPromptSeed?: string | undefined;
+    projectId?: string | undefined;
+    pidOffsetEnabled?: boolean | undefined;
+    claudeToolHardening?: boolean | undefined;
+    keepThinking?: boolean | undefined;
+}
+interface TransformResult {
+    contents: GeminiContent[];
+    systemInstruction?: GeminiSystem | undefined;
+    tools?: any[] | undefined;
+    toolConfig?: any | undefined;
+    generationConfig?: any | undefined;
+    sessionId: string;
+    userPromptId: string;
+    thinkingBudget?: number | undefined;
+    thinkingLevel?: ThinkingLevel | undefined;
+}
+declare function extractThinkingLevel(modelId: string, explicit?: string): {
+    level?: ThinkingLevel;
+    budget?: number;
+};
+export declare function transformRequest(opts: TransformRequestOptions): TransformResult;
+export declare function buildCloudCodeBody(projectId: string, inner: TransformResult): Record<string, any>;
+export interface BuildOptions {
+    model: string;
+    messages?: any[] | undefined;
+    tools?: any[] | undefined;
+    system?: any | undefined;
+    thinkingLevel?: string | undefined;
+    thinkingBudget?: number | undefined;
+    googleSearchEnabled?: boolean | undefined;
+    generationConfig?: any | undefined;
+    accessToken: string;
+    projectId: string;
+    endpointOverrides?: string[] | undefined;
+    userAgent?: string | undefined;
+    antigravityVersion?: string | undefined;
+    methodSuffix?: string | undefined;
+    sessionSeed?: string | undefined;
+    userPromptSeed?: string | undefined;
+    pidOffsetEnabled?: boolean | undefined;
+    claudeToolHardening?: boolean | undefined;
+    keepThinking?: boolean | undefined;
+}
+export interface BuildResult {
+    url: string;
+    endpoints: string[];
+    baseEndpoints: string[];
+    headers: Record<string, string>;
+    body: Record<string, any>;
+    sessionId: string;
+    userPromptId: string;
+    isGeminiCLIOnly: boolean;
+    method: string;
+    innerRequest: TransformResult;
+}
+export declare function buildAntigravityRequest(options: BuildOptions): BuildResult;
+export declare function buildGeminiCLIRequest(options: BuildOptions): BuildResult;
+export declare function fetchWithCascade(buildResult: BuildResult, fetchOptions?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<Response>;
+export declare const BYPASS_CONSTANTS: {
+    readonly directEndpoint: "https://cloudcode-pa.googleapis.com";
+    readonly dailyEndpoint: "https://daily-cloudcode-pa.googleapis.com";
+    readonly sandboxEndpoint: "https://autopush-cloudcode-pa.sandbox.googleapis.com";
+    readonly endpointCascade: readonly ["https://daily-cloudcode-pa.googleapis.com", "https://autopush-cloudcode-pa.sandbox.googleapis.com", "https://cloudcode-pa.googleapis.com"];
+    readonly headersToStrip: readonly ["x-goog-user-project", "X-Goog-QuotaUser", "X-Client-Device-Id"];
+    readonly toolNamePattern: string;
+    readonly maxToolNameLength: 64;
+    readonly maxToolsPerRequest: 128;
+    readonly thinkingBudgetMap: Record<"high" | "low" | "max" | "medium" | "minimal" | "tiered", number>;
+    readonly fnvOffsetBasis: 2166136261;
+    readonly fnvPrime: 16777619;
+};
+/** Full Cloud Code v1internal method URLs on the production base. */
+export declare const API_PATHS: {
+    readonly loadCodeAssist: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist";
+    readonly onboardUser: "https://cloudcode-pa.googleapis.com/v1internal:onboardUser";
+    readonly fetchAvailableModels: "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
+    readonly generateContent: "https://cloudcode-pa.googleapis.com/v1internal:generateContent";
+    readonly streamGenerateContent: "https://cloudcode-pa.googleapis.com/v1internal:streamGenerateContent";
+    readonly retrieveUserQuotaSummary: "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary";
+};
+/** Daily-build method URLs (quota lineage: antigravity quota reads the daily base). */
+export declare const API_PATHS_DAILY: {
+    readonly loadCodeAssist: "https://daily-cloudcode-pa.googleapis.com/v1internal:loadCodeAssist";
+    readonly retrieveUserQuotaSummary: "https://daily-cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary";
+};
+export declare const RequestHelpers: {
+    readonly GEMINI_CLI_OAUTH_CLIENT_ID: string;
+    readonly GEMINI_CLI_OAUTH_CLIENT_SECRET: string;
+    readonly GEMINI_CLI_USER_AGENT: "GeminiCLI/0.57.0/gemini-3-pro-preview (linux; x64; GitHub) google-api-nodejs-client/9.15.1";
+    readonly X_GOOG_API_CLIENT: "gl-node/22.19.0";
+    readonly CLIENT_METADATA_RAW: "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI";
+    readonly CLOUDCODE_PA_BASE: "https://cloudcode-pa.googleapis.com";
+    readonly PROJECT_FALLBACK: "rising-fact-p41fc";
+    readonly MODELS_2026: readonly ["gemini-3-pro-preview", "gemini-3-flash-preview", "gemini-3.1-pro-preview", "gemini-3.1-pro-preview-customtools", "gemini-3-flash", "gemini-3-pro", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5", "claude-opus-4-6-thinking", "claude-opus-4-6-thinking-low", "claude-opus-4-6-thinking-max", "claude-sonnet-4-6", "claude-sonnet-4-6-thinking", "claude-opus-4-5-thinking", "antigravity-gemini-3-pro", "antigravity-gemini-3-flash", "antigravity-gemini-3.1-pro", "antigravity-gemini-3-pro-preview", "antigravity-gemini-3-flash-preview", "antigravity-claude-opus-4-6-thinking", "antigravity-claude-sonnet-4-6"];
+    readonly fnv1a32: typeof fnv1a32;
+    readonly fnv1a64BigInt: typeof fnv1a64BigInt;
+    readonly buildUserPromptId: typeof buildUserPromptId;
+    readonly buildSessionIdFromDir: typeof buildSessionIdFromDir;
+    readonly isLikelyAntigravityOnlyModel: typeof isLikelyAntigravityOnlyModel;
+    readonly cleanToolSchemaTolerant: typeof cleanToolSchemaTolerant;
+    readonly cleanToolSchemas: typeof cleanToolSchemas;
+    readonly validateToolNamesDetailed: typeof validateToolNamesDetailed;
+    readonly sanitizeToolName: typeof sanitizeToolName;
+    readonly filterThinkingBlocks: typeof filterThinkingBlocks;
+    readonly normalizeMessages: typeof normalizeMessages;
+    readonly buildGenerationConfig: typeof buildGenerationConfig;
+    readonly enhanceAgySdkErrorResponse: typeof enhanceAgySdkErrorResponse;
+    readonly extractVariants: typeof extractVariants;
+    readonly extractVariantsFromAny: typeof extractVariantsFromAny;
+    readonly THINKING_LEVEL_TO_BUDGET_GEMINI: Record<string, number>;
+    readonly THINKING_LEVEL_TO_BUDGET_CLAUDE: Record<string, number>;
+    readonly FNV_OFFSET_BASIS: 2166136261;
+    readonly FNV_PRIME: 16777619;
+    readonly fnv1aHex: typeof fnv1aHex;
+    readonly fnv1aHex16: typeof fnv1aHex16;
+    readonly fnv1aHash: typeof fnv1a32;
+    readonly generateDeterministicId: typeof generateDeterministicId;
+    readonly generateSessionId: typeof generateSessionId;
+    readonly generateUserPromptId: typeof generateUserPromptId;
+    readonly THINKING_BUDGET_MAP: Record<"high" | "low" | "max" | "medium" | "minimal" | "tiered", number>;
+    readonly THINKING_LEVELS: readonly ["minimal", "low", "medium", "high", "tiered", "max"];
+    readonly THINKING_BUDGET_MIN: 1024;
+    readonly THINKING_BUDGET_MAX: 64000;
+    readonly THINKING_BUDGET_MAX_GEMINI: 32768;
+    readonly THINKING_BUDGET_MAX_CLAUDE: 64000;
+    readonly parseThinkingLevel: typeof parseThinkingLevel;
+    readonly mapThinkingLevelToBudget: typeof mapThinkingLevelToBudget;
+    readonly thinkingLevelToBudget: typeof mapThinkingLevelToBudget;
+    readonly getThinkingBudgetForVariant: typeof getThinkingBudgetForVariant;
+    readonly isGeminiCLIOnlyModel: typeof isGeminiCLIOnlyModel;
+    readonly extractModelVariant: typeof extractModelVariant;
+    readonly parseModelVariant: typeof extractModelVariant;
+    readonly TOOL_NAME_REGEX: RegExp;
+    readonly TOOL_NAME_MIN_LENGTH: 1;
+    readonly TOOL_NAME_MAX_LENGTH: 64;
+    readonly MAX_TOOLS_PER_REQUEST: 128;
+    readonly ALLOWED_SCHEMA_KEYS: Set<string>;
+    readonly ALLOWED_TOOL_TOP_KEYS: readonly ["name", "description", "parameters"];
+    readonly validateToolName: typeof validateToolName;
+    readonly cleanJsonSchemaStrict: typeof cleanJsonSchemaStrict;
+    readonly cleanRawToolSchema: typeof cleanRawToolSchema;
+    readonly cleanToolsArray: typeof cleanToolsArray;
+    readonly normalizeRole: typeof normalizeRole;
+    readonly normalizeContentToParts: typeof normalizeContentToParts;
+    readonly normalizeIncomingMessages: typeof normalizeIncomingMessages;
+    readonly isThinkingBlock: typeof isThinkingBlock;
+    readonly filterThinkingBlocksAuto: typeof filterThinkingBlocksAuto;
+    readonly filterThinkingBlocksFromParts: typeof filterThinkingBlocksFromParts;
+    readonly filterThinkingBlocksFromMessages: typeof filterThinkingBlocksFromMessages;
+    readonly DIRECT_ENDPOINT: "https://cloudcode-pa.googleapis.com";
+    readonly DAILY_ENDPOINT: "https://daily-cloudcode-pa.googleapis.com";
+    readonly AUTOPUSH_ENDPOINT: "https://autopush-cloudcode-pa.sandbox.googleapis.com";
+    readonly ENDPOINT_CASCADE: readonly ["https://daily-cloudcode-pa.googleapis.com", "https://autopush-cloudcode-pa.sandbox.googleapis.com", "https://cloudcode-pa.googleapis.com"];
+    readonly HEADERS_TO_STRIP: readonly ["x-goog-user-project", "X-Goog-QuotaUser", "X-Client-Device-Id"];
+    readonly BYPASS_CONSTANTS: {
+        readonly directEndpoint: "https://cloudcode-pa.googleapis.com";
+        readonly dailyEndpoint: "https://daily-cloudcode-pa.googleapis.com";
+        readonly sandboxEndpoint: "https://autopush-cloudcode-pa.sandbox.googleapis.com";
+        readonly endpointCascade: readonly ["https://daily-cloudcode-pa.googleapis.com", "https://autopush-cloudcode-pa.sandbox.googleapis.com", "https://cloudcode-pa.googleapis.com"];
+        readonly headersToStrip: readonly ["x-goog-user-project", "X-Goog-QuotaUser", "X-Client-Device-Id"];
+        readonly toolNamePattern: string;
+        readonly maxToolNameLength: 64;
+        readonly maxToolsPerRequest: 128;
+        readonly thinkingBudgetMap: Record<"high" | "low" | "max" | "medium" | "minimal" | "tiered", number>;
+        readonly fnvOffsetBasis: 2166136261;
+        readonly fnvPrime: 16777619;
+    };
+    readonly isRetryableStatus: typeof isRetryableStatus;
+    readonly stripForbiddenHeaders: typeof stripForbiddenHeaders;
+    readonly RequestHelpersError: typeof RequestHelpersError;
+};
+export default RequestPipeline;
+//# sourceMappingURL=request.d.ts.map