@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/fingerprint.d.ts

@@ -0,0 +1,594 @@
+/**
+ * @file fingerprint.ts
+ * @module provider/fingerprint
+ * @description
+ * Anti-detection fingerprint generator mimicking Gemini CLI / Antigravity
+ * traffic against cloudcode-pa.googleapis.com (merged superset of the two
+ * prior variants).
+ *
+ * v2.1.15 Phase B: this module is THE single owner of identity masquerade —
+ * it absorbed getDynamicUserAgent (+Async), fetchRemoteAntigravityVersion,
+ * normalizePlatform/normalizeArch, getXGoogApiClient + X_GOOG_API_CLIENT (+
+ * the accurately split X_GOOG_API_CLIENT_GEMINI_CLI snapshot),
+ * buildClientMetadata, buildGeminiUserAgent, ua/apiClient (auth lineage),
+ * getRandomPlatformString, getGeminiCLIHeaders(WithOptions),
+ * getAntigravityHeaders(WithOptions), buildAntagravityHeaders (canonical of
+ * the five plugin/project/quota/search/models variants) and the hex/limit
+ * utility re-exports from core.js. Raw values stay in constants.ts; generic
+ * utilities live in core.js.
+ *
+ * Merged responsibilities:
+ * - OAuth constants, endpoints, 2026 model list
+ * - Weighted coherent platform pools (win32/x64, linux/x64, darwin/arm64)
+ *   plus a keyed PLATFORM_POOLS record with Go-style amd64 naming
+ * - Deterministic FNV-1a hashing for session_id / user_prompt_id
+ * - Jitter 0-80ms anti-rate-limit (sync value + async sleep + instance API)
+ * - Gemini CLI style User-Agent with google-api-nodejs-client pairing
+ * - Antigravity style User-Agent (`antigravity/{version} {os}/{arch}`)
+ * - X-Goog-Api-Client generation (simplified and full chains)
+ * - Client-Metadata (fixed IDE_UNSPECIFIED form and structured JSON form)
+ * - Unified FingerprintGenerator constructor accepting BOTH option shapes:
+ *     new FingerprintGenerator({ directory, allowExtendedPlatforms, ... })
+ *     new FingerprintGenerator("1.19.2" | "antigravity/1.19.2 darwin/arm64")
+ * - defaultFingerprintGenerator singleton + getFingerprintHeaders() wrapper
+ *
+ * Runtime constraint: only node:* builtins + global fetch/Headers.
+ *
+ * @license MIT
+ */
+import { ANTIGRAVITY_CLI_VERSION_POOL, ANTIGRAVITY_VERSION_FALLBACK, CLOUDCODE_BASE_URL, FINGERPRINT_IDE_TYPES, FINGERPRINT_PLATFORMS, FINGERPRINT_PLUGIN_TYPES, GEMINI_CLI_OAUTH_CLIENT_ID as OAUTH_CLIENT_ID, GEMINI_CLI_OAUTH_CLIENT_SECRET as OAUTH_CLIENT_SECRET, GEMINI_CLI_VERSION_POOL, GL_NODE_VERSION_POOL, PLATFORM_POOL, PROJECT_FALLBACK } from "./constants.js";
+import type { AntigravityVersion, SupportedArch, SupportedPlatform } from "./constants.js";
+export { ANTIGRAVITY_VERSION_FALLBACK, OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, PROJECT_FALLBACK };
+/** Scopes required by the Gemini CLI auth flow. */
+/** Base URL for the Cloud Code API (imported from constants.js — canonical owner since v2.1.15 Phase B). */
+export { CLOUDCODE_BASE_URL };
+export type { AntigravityVersion, SupportedArch, SupportedPlatform };
+/**
+ * v1internal endpoints used by Gemini CLI.
+ * All POST, requiring OAuth2 auth plus fingerprint headers.
+ */
+declare const FINGERPRINT_API_PATHS: {
+    readonly loadCodeAssist: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist";
+};
+import { MODELS_2026_LEGACY as MODELS_2026 } from "./models.js";
+import type { ModelId2026 } from "./models.js";
+export { MODELS_2026 };
+export type { ModelId2026 };
+export type PlatformOS = "win32" | "linux" | "darwin";
+export type PlatformArch = "x64" | "arm64";
+export type FingerprintType = "gemini-cli" | "antigravity";
+/**
+ * Supported header generation styles (observer naming for FingerprintType).
+ * - antigravity: emulates Antigravity Manager content requests
+ * - gemini-cli: emulates Gemini CLI quota pool (includes X-Goog-Api-Client)
+ */
+export type HeaderStyle = "antigravity" | "gemini-cli";
+/** OS name normalized for keyed fingerprint pools. */
+export type OsName = "windows" | "darwin" | "linux";
+/** Architecture name normalized for keyed fingerprint pools. */
+export type ArchName = "amd64" | "arm64" | "x64";
+/**
+ * Coherent platform profile for the weighted UA pools.
+ * Guarantees win32 never pairs with arm64 and that darwin prefers arm64.
+ */
+export interface PlatformProfile {
+    /** Node.js OS identifier, exact `process.platform` value */
+    os: PlatformOS;
+    /** Node.js architecture identifier */
+    arch: PlatformArch;
+    /** Formatted string inside the UA parenthesis: "win32; x64" */
+    uaSegment: string;
+    /** Distribution source - GitHub dominant for coherence */
+    source: string;
+    /** Randomization weight - darwin arm64 more common among developers */
+    weight: number;
+}
+/**
+ * Keyed coherent platform pool entry (Go-style amd64 naming on Windows,
+ * matching observed AM traffic).
+ */
+export interface PlatformPool {
+    /** Logical key e.g. "windows/amd64" */
+    readonly key: string;
+    /** Normalized OS name used in User-Agent */
+    readonly os: OsName;
+    /** Normalized arch name used in User-Agent */
+    readonly arch: ArchName;
+    /** Node.js platform identifier */
+    readonly nodePlatform: NodeJS.Platform;
+    /** Node.js arch identifier */
+    readonly nodeArch: string;
+    /** Electron/Chrome OS display fragment */
+    readonly displayOs: string;
+}
+/** Map of all known keyed pools. */
+export type PoolMap = Record<string, PlatformPool>;
+/**
+ * Keyed pool record. Windows uses Go-convention amd64 naming to match AM
+ * traffic; darwin uses arm64 (Apple Silicon primary for 2026); linux x64.
+ */
+export declare const PLATFORM_POOLS: PoolMap;
+/** Weighted pool of real-world valid combinations. */
+export declare const PLATFORM_PROFILE_POOL: readonly PlatformProfile[];
+export { PLATFORM_POOL };
+export declare const PLATFORM_POOL_EXTENDED: readonly PlatformProfile[];
+/** Preferred plugin version for new installs / Client-Metadata payloads. */
+export declare const PLUGIN_VERSION_FALLBACK = "2.1.16";
+export { ANTIGRAVITY_CLI_VERSION_POOL, GEMINI_CLI_VERSION_POOL, GL_NODE_VERSION_POOL };
+export declare const ANTIGRAVITY_VERSION_POOL: readonly ["1.12.8", "1.12.7", "1.12.5", "1.11.9", "1.11.4"];
+/** google-api-nodejs-client versions - lockstep with GeminiCLI releases. */
+export declare const GOOGLE_API_CLIENT_VERSION_POOL: readonly ["9.15.1", "9.15.0", "9.14.1", "9.14.0", "9.13.0"];
+/** Complementary gax version pool. */
+export declare const GAX_VERSION_POOL: readonly ["5.0.4", "5.0.3", "4.3.6"];
+import { fnv1a32, fnv1a32Hex, fnv1a64, getJitterMs, pickRandom } from "./core.js";
+export { fnv1a32, fnv1a32Hex, fnv1a64, getJitterMs, pickRandom };
+/**
+ * Generates a deterministic session_id based on the current directory.
+ * Same folder => same session_id => avoids device-hopping flags.
+ *
+ * @param directory - base path (defaults to process.cwd())
+ */
+export declare function generateSessionUuid(directory?: string): string;
+/**
+ * Secure random float in [0,1) using crypto.randomInt with Math.random fallback.
+ */
+export declare function secureRandom(): number;
+/** Picks a random element honoring optional weights. */
+export declare function pickRandomWeighted<T extends {
+    weight: number;
+}>(pool: readonly T[]): T;
+/**
+ * Async jitter SLEEP in [minMs, maxMs] for anti-rate-limit / anti-ban delays
+ * (renamed from `jitter` in v2.1.15 Phase B: core.js owns the sync `jitter`
+ * number draw, so this async sleep variant carries an accurate distinct name).
+ */
+export declare function jitterSleep(minMs?: number, maxMs?: number): Promise<void>;
+/**
+ * Normalizes a Node platform identifier for UA emission (identity-form
+ * canonical: darwin/win32/linux pass through; exotic values pass through
+ * unchanged as well — this is a stable lowercase identity map, not a filter).
+ */
+export declare function normalizePlatform(p: string): string;
+/**
+ * Normalizes a Node arch identifier for UA emission
+ * (arm64/x64/ia32 identity; exotic values pass through unchanged).
+ */
+export declare function normalizeArch(a: string): string;
+/**
+ * Dynamic Antigravity User-Agent: `antigravity/{version} {os}/{arch}`.
+ * Invalid/absent versions fall back to ANTIGRAVITY_VERSION_FALLBACK.
+ * Canonical of the getDynamicUserAgent family (v2.1.15 Phase B: the
+ * constants.ts, models.ts, plugin.ts and quota.ts locals deleted; the
+ * async version.ts GeminiCLI-template variant stays in version.ts under its
+ * own accurate name because it is a semantically distinct async builder).
+ */
+export declare function getDynamicUserAgent(version?: string, opts?: {
+    os?: string;
+    arch?: string;
+}): string;
+/**
+ * Async dynamic Antigravity User-Agent — resolves the remote Antigravity
+ * version when no cached version qualifies, then builds the UA via
+ * {@link getDynamicUserAgent}. (Absorbed from constants.ts in v2.1.15
+ * Phase B; version.ts's own remote chain remains the version-detection
+ * owner and may dedupe with {@link fetchRemoteAntigravityVersion} later.)
+ */
+export declare function getDynamicUserAgentAsync(cachedVersion?: string): Promise<string>;
+/**
+ * Fetches the latest Antigravity version across the known update sources
+ * (absorbed from constants.ts in v2.1.15 Phase B). Returns null when every
+ * source fails; never throws.
+ */
+export declare function fetchRemoteAntigravityVersion(): Promise<string | null>;
+/**
+ * Builds the antigravity-style X-Goog-Api-Client chain:
+ * `antigravity/{version} gl-node/{node} gax/4.9.0 grpc/1.14.0`.
+ * Canonical of the getXGoogApiClient family (constants.ts lineage — the same
+ * chain request.ts's buildApiClient and plugin.ts's buildCommonHeaders
+ * compose inline; the bare `gl-node/22.19.0` snapshot has its own accurate
+ * name below).
+ */
+export declare function getXGoogApiClient(version?: string): string;
+/**
+ * Canonical X_GOOG_API_CLIENT computed value — the dynamic
+ * {@link getXGoogApiClient} result (v2.1.15 Phase B: the constants.ts
+ * computed export moved here; the static "gl-node/22.19.0" copies in
+ * config/project/recovery/request/streaming were NOT the same value and
+ * keep their exact wire behavior through the accurately named
+ * {@link X_GOOG_API_CLIENT_GEMINI_CLI}).
+ */
+export declare const X_GOOG_API_CLIENT: string;
+/**
+ * Bare gl-node X-Goog-Api-Client snapshot observed on real Gemini CLI
+ * traffic (`gl-node/22.19.0`). Distinct value from {@link X_GOOG_API_CLIENT}
+ * — the former static "stale" copies in project.ts, quota.ts, request.ts,
+ * streaming.ts, recovery.ts, accounts.ts and config.ts resolve HERE so every
+ * live chain keeps sending exactly the bytes it sent before the merge.
+ */
+export declare const X_GOOG_API_CLIENT_GEMINI_CLI: "gl-node/22.19.0";
+/**
+ * Builds the Antigravity Client-Metadata header string — the quota.ts
+ * lineage (live-validated quota chain): uppercase platform/arch,
+ * pluginVersion taken from the constants template, osVersion before arch.
+ * Canonical of the buildClientMetadata family (v2.1.15 Phase B: the
+ * constants.ts, quota.ts, request.ts and search.ts locals deleted).
+ */
+export declare function buildClientMetadata(version?: string): string;
+/**
+ * Builds the GeminiCLI User-Agent dynamically, varying the platform:
+ * `GeminiCLI/<cliVersion>/<model> (<platform>; <arch>; GitHub)
+ * google-api-nodejs-client/<gclientVersion>`. Canonical of the
+ * buildGeminiUserAgent family (v2.1.15 Phase B: config.ts lineage body —
+ * overrides accepted; the auth.ts win32->"windows" mapping is expressed by
+ * auth.ts passing the pre-mapped platform, so one implementation serves
+ * both historical call shapes).
+ */
+export declare function buildGeminiUserAgent(overrides?: {
+    cliVersion?: string;
+    model?: string;
+    platform?: string;
+    arch?: string;
+    gclientVersion?: string;
+}): string;
+/**
+ * Antigravity User-Agent short form (auth.ts lineage):
+ * `antigravity/{version} {platform}/{arch}`. Thin alias of
+ * {@link getDynamicUserAgent} kept under its historical auth surface name;
+ * the auth call sites always invoke it without arguments, where the two
+ * implementations are byte-identical.
+ */
+export declare const ua: (v?: string) => string;
+/**
+ * Antigravity X-Goog-Api-Client short form (auth.ts lineage):
+ * `antigravity/{version} gl-node/{node} gccl/1.0.0 gax/1.0.0`. Distinct
+ * segment chain from {@link getXGoogApiClient} (gccl/gax-1.0.0 vs
+ * gax-4.9.0/grpc) — the live auth retrieveQuota path sends exactly this
+ * form, so it keeps its own accurate implementation here.
+ */
+export declare const apiClient: (v?: string) => string;
+/**
+ * Builds a platform string in the format expected by the Gemini CLI
+ * User-Agent, e.g. "linux; x64; GitHub" (absorbed from constants.ts in
+ * v2.1.15 Phase B).
+ */
+export declare function getRandomPlatformString(platformOverride?: SupportedPlatform, archOverride?: SupportedArch): string;
+export interface GeminiCliHeaderOptions {
+    /** model to include in the User-Agent (e.g. gemini-3-pro-preview) */
+    model?: string | undefined;
+    /** platform override (randomizes / uses process.platform when absent) */
+    platform?: SupportedPlatform | undefined;
+    /** arch override */
+    arch?: SupportedArch;
+    /** specific Gemini CLI version to spoof */
+    cliVersion?: string;
+    /** specific gapi client version */
+    gapiVersion?: string;
+    /** specific gl-node version */
+    glNodeVersion?: string;
+    /** access token for Authorization */
+    accessToken?: string;
+    /** custom ideType */
+    ideType?: (typeof FINGERPRINT_IDE_TYPES)[number];
+    /** custom platform metadata */
+    platformMeta?: (typeof FINGERPRINT_PLATFORMS)[number];
+    /** custom pluginType */
+    pluginType?: (typeof FINGERPRINT_PLUGIN_TYPES)[number];
+}
+/**
+ * Generates headers identical to the official Gemini CLI for detection
+ * bypass (canonical of the family: the richer constants.ts WithOptions
+ * lineage; plugin.ts's legacy terminal-platform variant had zero callers
+ * and was deleted in v2.1.15 Phase B).
+ *
+ * @param model - optional, defaults to gemini-3-pro-preview
+ * @param platform - optional, randomized with linux bias by default
+ */
+export declare function getGeminiCLIHeaders(model?: string, platform?: SupportedPlatform): Record<string, string>;
+/** Object-style variant, more robust for internal plugin usage. */
+export declare function getGeminiCLIHeadersWithOptions(opts?: GeminiCliHeaderOptions): Record<string, string>;
+/** Headers specialized for Antigravity versioning. */
+export interface AntigravityHeaderOptions {
+    version?: AntigravityVersion;
+    accessToken?: string;
+    cliVersion?: string;
+    model?: string;
+    platform?: SupportedPlatform;
+}
+export declare function getAntigravityHeaders(version?: AntigravityVersion | string): Record<string, string>;
+export declare function getAntigravityHeadersWithOptions(opts?: AntigravityHeaderOptions): Record<string, string>;
+/**
+ * Options for {@link buildAntagravityHeaders} — the canonical of the
+ * buildAntagravityHeaders family (v2.1.15 Phase B). The flags preserve each
+ * historical variant's exact effective header set:
+ * - plugin.ts / project.ts lineage (default): Authorization, Content-Type,
+ *   User-Agent + extras;
+ * - quota.ts lineage: `accept: true` adds Accept: application/json;
+ * - search.ts lineage: `identityHeaders: true` adds X-Goog-Api-Client
+ *   (dynamic getXGoogApiClient) and Client-Metadata (buildClientMetadata);
+ * - the models.ts strip-variant had zero consumers and was deleted.
+ */
+export interface AntigravityHeadersOptions {
+    userAgent?: string | undefined;
+    extra?: Record<string, string>;
+    /** Include Accept: application/json (quota/search lineage). Default false. */
+    accept?: boolean;
+    /** Include X-Goog-Api-Client + Client-Metadata (search lineage). Default false. */
+    identityHeaders?: boolean;
+}
+/**
+ * Builds the Antigravity content-request header map (Authorization bearer,
+ * JSON content type, dynamic Antigravity UA, optional Accept and bypass
+ * identity headers, extras merged last with x-goog-user-project always
+ * filtered per the observer requirement).
+ */
+export declare function buildAntagravityHeaders(accessToken: string, opts?: AntigravityHeadersOptions): Record<string, string>;
+export interface FingerprintOptions {
+    /** Directory for deterministic seed (defaults to cwd) */
+    directory?: string;
+    /** Allow rare extended platform combos (default false) */
+    allowExtendedPlatforms?: boolean;
+    /** Pin a specific platform (for tests) */
+    fixedPlatform?: PlatformProfile | undefined;
+    /** Pin the Gemini CLI version */
+    fixedCliVersion?: string | undefined;
+    /** Pin the google-api-client version */
+    fixedGoogleApiVersion?: string | undefined;
+    /** Pin the gl-node version */
+    fixedNodeVersion?: string | undefined;
+    /**
+     * Antigravity app version embedded in observer-style UAs.
+     * Accepts bare semver ("1.19.2") or full UA strings
+     * ("antigravity/1.19.2 darwin/arm64"); invalid values fall back to
+     * ANTIGRAVITY_VERSION_FALLBACK.
+     */
+    antigravityVersion?: string;
+}
+export interface FullHeadersResult {
+    /** Exact Gemini CLI User-Agent */
+    "User-Agent": string;
+    /** X-Goog-Api-Client fingerprint */
+    "X-Goog-Api-Client": string;
+    /** Hardened Client-Metadata */
+    "Client-Metadata": string;
+    /** Standard Content-Type */
+    "Content-Type": string;
+    /** Accept */
+    Accept: string;
+    /** Optional for some endpoints */
+    "X-Client-Details"?: string;
+    /** Extra metadata for internal debug/tracing */
+    __meta: {
+        platform: PlatformProfile;
+        cliVersion: string;
+        googleApiVersion: string;
+        glNodeVersion: string;
+        gaxVersion: string;
+        sessionId: string;
+        model: string;
+        type: FingerprintType;
+        jitterMs: number;
+    };
+}
+/**
+ * Anti-detection generator that mimics Gemini CLI exactly while also exposing
+ * the observer-style Antigravity header set.
+ *
+ * Coherence guarantees:
+ * - Chosen platform drives the UA segment consistently
+ * - Node / gax / google-api-client versions pair like a real release
+ * - session_id is deterministic per directory (avoids device hopping)
+ * - Observer mode never mutates global state
+ *
+ * Usage:
+ * ```ts
+ * const fp = new FingerprintGenerator({ directory: process.cwd() });
+ * const headers = fp.getFullHeaders('gemini-3-pro-preview', 'gemini-cli');
+ * // or observer style:
+ * const fp2 = new FingerprintGenerator('1.19.2');
+ * const h2 = fp2.getFingerprintHeaders('gemini-cli');
+ * ```
+ */
+export declare class FingerprintGenerator {
+    private readonly directory;
+    private readonly allowExtended;
+    private readonly fixedPlatform?;
+    private readonly fixedCliVersion?;
+    private readonly fixedGoogleApiVersion?;
+    private readonly fixedNodeVersion?;
+    private readonly sessionId;
+    private cachedPlatform;
+    /** Antigravity app version used in observer User-Agents. */
+    private readonly version;
+    private poolCache;
+    /**
+     * Unified constructor accepting BOTH historical option shapes:
+     *
+     * @param opts - either an options object ({@link FingerprintOptions}) or a
+     *               plain version string ("1.19.2", "antigravity/1.19.2 ...",
+     *               falls back to ANTIGRAVITY_VERSION_FALLBACK when invalid).
+     */
+    constructor(opts?: FingerprintOptions | string);
+    /** Validates / extracts the Antigravity version from raw input. */
+    private normalizeAntigravityVersion;
+    /** Numeric 32-bit FNV-1a (deterministic, fast, no crypto overhead). */
+    private fnv1a32m;
+    /** Numeric 64-bit FNV-1a for longer session identifiers. */
+    private fnv1a64b;
+    /** Hex representation (8 chars) of the 32-bit FNV-1a hash. */
+    fnv1aHex(input: string): string;
+    /**
+     * Deterministic session id from a seed (sess_ prefixed, FNV-based). When no
+     * seed is supplied, falls back to randomUUID + hostname + timestamp hashed
+     * into the same format. Never throws.
+     *
+     * v2.1.16 divergence note: {@link generateUserPromptId} below is the
+     * structural twin of this method, kept separate (not parametrized into one
+     * prefix+salt helper) because the outputs intentionally differ in four
+     * places: the prefix (sess_ vs up_), the secondary hash salt (`:sess` vs
+     * `:up`), the unseeded base (Date.now() vs process.pid) and the catch-path
+     * fallback shape (sess_ appends a base36 timestamp, up_ does not).
+     */
+    generateSessionId(seed?: string): string;
+    /**
+     * Deterministic user_prompt_id mirroring Antigravity Manager behavior where
+     * prompt IDs stay stable per request content. Never throws.
+     */
+    generateUserPromptId(seed?: string): string;
+    /**
+     * Returns a coherent platform with per-instance caching for stability.
+     * A fixedPlatform always wins (deterministic tests); an explicit override
+     * bypasses the cache entirely.
+     */
+    getPlatform(override?: PlatformProfile): PlatformProfile;
+    /** Forces a platform rotation (useful for anti-ban testing). */
+    rotatePlatform(): PlatformProfile;
+    /**
+     * Runtime-detected keyed pool (cached):
+     * win32 -> windows/amd64, darwin -> darwin/arm64 (even under Rosetta),
+     * everything else -> linux/x64.
+     */
+    getPlatformPool(): PlatformPool;
+    /** Static accessor for all keyed pools (testing / CLI listing). */
+    static getPlatformPools(): PoolMap;
+    /** Current keyed pool key, e.g. "darwin/arm64". */
+    getCurrentPoolKey(): string;
+    /** Cryptographically strong jitter in the inclusive 0..80ms range. */
+    getJitterMs(): number;
+    /** Applies jitter asynchronously - awaits 0..80ms. */
+    applyJitter(): Promise<void>;
+    /**
+     * Produces a coherent version set that actually shipped together.
+     * 70% recent-user slice, 30% long-tail for realistic distribution.
+     */
+    private getCoherentVersionPair;
+    /**
+     * User-Agent identical to the official Gemini CLI:
+     * `GeminiCLI/0.57.0/gemini-3-pro-preview (win32; x64; GitHub) google-api-nodejs-client/9.15.1`
+     */
+    getGeminiCLIUserAgent(model?: string, platform?: PlatformProfile): string;
+    /**
+     * Antigravity-flavored User-Agent observed in fetchAvailableModels traces:
+     * `Antigravity/1.12.8 (linux; x64) CodeAssist/0.9.2 google-api-nodejs-client/9.15.1 gl-node/22.19.0`
+     */
+    getAntigravityUserAgent(version?: string, platform?: PlatformProfile): string;
+    /**
+     * X-Goog-Api-Client identical to the Node.js Google client. 80% simplified
+     * (`gl-node/22.19.0`), 20% full chain with gccl/gax/grpc segments.
+     */
+    getXGoogApiClient(): string;
+    /**
+     * Hardened fixed Client-Metadata validated by onboarding/loadCodeAssist:
+     * `ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI`
+     */
+    getClientMetadata(): string;
+    /**
+     * Structured JSON Client-Metadata used by observer-style requests
+     * (ideType ANTIGRAVITY + plugin/arch/node details). Falls back to a compact
+     * key=value form and never throws.
+     */
+    private buildClientMetadata;
+    /**
+     * Observer-style X-Goog-Api-Client:
+     * `gl-node/<node> antigravity/<version> gccl/1.0.0`. Never throws.
+     */
+    private buildApiClient;
+    /**
+     * Complete Gemini CLI-compatible header set including coherent UA,
+     * X-Goog-Api-Client jitter, hardened Client-Metadata and Content-Type.
+     */
+    getFullHeaders(model?: string, type?: FingerprintType, platformOverride?: PlatformProfile): FullHeadersResult;
+    /** Native Fetch API Headers instance ready for direct fetch() usage. */
+    toFetchHeaders(model?: string, type?: FingerprintType): Headers;
+    /**
+     * Generates observer-style fingerprint headers.
+     *
+     * Enforced requirements:
+     * - User-Agent: `antigravity/{version} {os}/{arch}` (coherent keyed pool)
+     * - Client-Metadata: always included (structured JSON, AM observed)
+     * - X-Goog-Api-Client ONLY when headerStyle === 'gemini-cli'
+     * - Never includes X-Goog-QuotaUser nor X-Client-Device-Id
+     *
+     * @param headerStyle - 'antigravity' (default content path) or 'gemini-cli'
+     */
+    getFingerprintHeaders(headerStyle?: HeaderStyle): Record<string, string>;
+    /** Antigravity version currently embedded in observer fingerprints. */
+    getVersion(): string;
+    /** Deterministic session_id of this instance. */
+    getSessionId(): string;
+    /** Full OAuth config for the auth flow. */
+    getOAuthConfig(): {
+        clientId: string;
+        clientSecret: string;
+        scopes: readonly string[];
+        projectFallback: string;
+    };
+    /** Endpoint map (v2.1.15 Phase D: derives from the constants.js parts). */
+    getEndpoints(): typeof FINGERPRINT_API_PATHS;
+}
+/**
+ * Default shared generator using ANTIGRAVITY_VERSION_FALLBACK until
+ * version.ts resolves the remote version. Consumers may create their own
+ * instances with a dynamic version. The grand merge folded this module into
+ * the shared core graph the platform-portable bundles ship, so the singleton
+ * constructs on first use (the constructor resolves the cwd through the node
+ * path builtin): under node and bun the behavior is identical while a stubbed
+ * browser bundle never instantiates the generator at import time.
+ */
+export declare const defaultFingerprintGenerator: FingerprintGenerator;
+/**
+ * Convenience wrapper matching the original plugin export names. Uses the
+ * default singleton, or a temporary generator when a version is supplied.
+ *
+ * @param style - 'antigravity' (default) or 'gemini-cli'
+ * @param version - optional Antigravity version override
+ */
+export declare function getFingerprintHeaders(style?: HeaderStyle, version?: string): Record<string, string>;
+/**
+ * Short helper generating Gemini CLI compatible headers for project bypass.
+ *
+ * @param model - model id (default gemini-3-pro-preview)
+ * @param type - 'gemini-cli' or 'antigravity'
+ * @param platform - profile object, "win32 x64" string, or plain OS string
+ */
+export declare function generateHeaders(model?: string, type?: FingerprintType, platform?: PlatformProfile | `${PlatformOS} ${PlatformArch}` | PlatformOS): Record<string, string>;
+/** Variant returning a native Fetch API Headers instance (Node 20+). */
+export declare function generateFetchHeaders(model?: string, type?: FingerprintType, platform?: PlatformProfile | `${PlatformOS} ${PlatformArch}`): Headers;
+/**
+ * Full fingerprint with metadata for debugging/tracing; validates bypasses
+ * during development.
+ */
+export declare function generateFullFingerprint(model?: string, type?: FingerprintType, directory?: string): FullHeadersResult;
+/**
+ * Creates an instance bound to a specific directory (deterministic
+ * session_id). Essential for multi-workspace setups.
+ */
+export declare function createFingerprintForDirectory(directory: string): FingerprintGenerator;
+/**
+ * Bypass helper producing headers plus the base body for loadCodeAssist,
+ * including the blinded project fallback.
+ */
+export declare function buildLoadCodeAssistRequest(projectId?: string, model?: string): {
+    url: string;
+    method: "POST";
+    headers: Record<string, string>;
+    body: string;
+    sessionId: string;
+};
+export declare const FingerprintConstants: {
+    readonly OAUTH_CLIENT_ID: string;
+    readonly OAUTH_CLIENT_SECRET: string;
+    readonly GEMINI_CLI_SCOPES: readonly ["https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile"];
+    readonly PROJECT_FALLBACK: "rising-fact-p41fc";
+    readonly CLOUDCODE_BASE_URL: "https://cloudcode-pa.googleapis.com";
+    /** Lazy through the models.js import cycle: the aggregate reads the owner at access time, so every module evaluation order stays legal (the models → core → config → fingerprint cycle of the merged graph never evaluates this read during import). */
+    readonly MODELS_2026: readonly ["antigravity-gemini-3-pro", "antigravity-gemini-3.1-pro", "antigravity-gemini-3-flash", "antigravity-claude-sonnet-4-6", "antigravity-claude-opus-4-6-thinking", "gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-flash-preview", "gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3.1-pro-preview-customtools"];
+    readonly PLATFORM_PROFILE_POOL: readonly PlatformProfile[];
+    readonly PLATFORM_POOLS: PoolMap;
+    readonly GEMINI_CLI_VERSION_POOL: readonly ["0.57.0", "0.56.0", "0.55.1", "0.54.0", "0.53.0", "0.52.0", "0.51.2", "0.50.0"];
+    readonly GOOGLE_API_CLIENT_VERSION_POOL: readonly ["9.15.1", "9.15.0", "9.14.1", "9.14.0", "9.13.0"];
+    readonly GL_NODE_VERSION_POOL: readonly ["22.19.0", "22.16.0", "22.14.0", "20.19.3", "20.18.1", "20.17.0", "20.11.0", "18.20.4"];
+    readonly ANTIGRAVITY_VERSION_FALLBACK: "1.19.2";
+    readonly PLUGIN_VERSION_FALLBACK: "2.1.16";
+};
+export default FingerprintGenerator;
+//# sourceMappingURL=fingerprint.d.ts.map