@wenathlan/devthink 2.0.14 → 2.0.19

package/dist/runtime.d.ts

@@ -1,212 +0,0 @@
-/**
- * The runtime module of the 1.1.90 consolidation: every correlated variation of the platform adapter contract, its implementations and the target matrix interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the platform runtime family: platformadapter holds the adapter contract every platform primitive flows through (the storage, clock, logger and fetch adapters with the node, browser and deno default compositions, the shared adapter registry on the global symbol registry so the esm and cjs modes of one process share one active adapter, and the bundle stamp of the running dist target); runtimeadapters holds the implementations the contract composes (the filesystem, chrome storage, deno kv and in-memory storage mappings, the capability probe table, the adapter declarations and the worker, dom and fetch shells with their feature downgrades); and platformtargets holds the target matrix that verifies every platform target against the adapter mappings with its minified output budget.
- * No binding is ever hardcoded: every node, deno and browser primitive arrives injected through the seam so the neutral and browser bundles never carry a platform import, and no adapter ever bypasses the human review.
- */
-import type { adaptercontract, bundlemode, capabilityprobe, clockadapter, fetchadapter, librarymode, loggeradapter, platformtarget, runtimeadapterdeclaration, featuredowngrade, platformmatrix } from "./types.js";
-import type { memoryadapter } from "./memory.js";
-/**
- * Platform adapter logic of the 1.1.81 family.
- * One contract carries every platform primitive the library touches: the storage adapter the memory module takes, the clock adapter the progress module takes, the logger adapter that keeps the core off a bound console and the fetch adapter that keeps the core off a bound network primitive — with the node, browser and deno default compositions that bind real platform apis behind the same seam, and the bundle stamp that reports the mode and target of the running bundle. The module stays pure: the node bindings arrive as injected filesystem primitives and the deno bindings as an injected kv store, so the neutral and browser bundles never carry a node import. The shared adapter registry lives on the global symbol registry instead of a module singleton, so the esm and cjs modes of one process share one active adapter instead of forking the dual package hazard.
- * Example: `const adapter = nodeplatformadapter({ profiledir, fs }); setsharedadapter(adapter); bundlestamp();` binds the filesystem storage, publishes it to every mode of the process and reports the running bundle.
- */
-/** Reads the consumption mode one runtime adapter serves: the browser shell rides the umd bundle, the node shell rides the cjs bundle and the bun and deno shells ride the esm core. */
-export declare function adaptermodeof(runtime: platformtarget["runtime"]): librarymode;
-/** Reads the clock adapter of the platform seam from the injected primitives; the adapter owns no timer of its own. */
-export declare function clockadapterof(primitives: {
-    now(): number;
-    schedule(callback: () => void, milliseconds: number): unknown;
-}): clockadapter;
-/** Reads the logger adapter of the platform seam from the injected sink; the adapter owns no console of its own. */
-export declare function loggeradapterof(sink: {
-    log(line: string): void;
-    warn(line: string): void;
-    error(line: string): void;
-}): loggeradapter;
-/** Reads the fetch adapter of the platform seam from the injected loader; the adapter owns no network primitive of its own. */
-export declare function fetchadapterof(primitives: {
-    fetch(input: string, init?: Record<string, unknown>): Promise<unknown>;
-}): fetchadapter;
-/** Reads the default clock adapter: now and the scheduler bind to the platform globals every supported runtime ships, so the default carries no node or browser specific import. Example: `defaultclock().now()` answers the platform timestamp. */
-export declare function defaultclock(): clockadapter;
-/** Reads the default logger adapter: the sink binds to the platform console every supported runtime ships. Example: `defaultlogger().log("line")` writes one line through the platform console. */
-export declare function defaultlogger(): loggeradapter;
-/** Reads the default fetch adapter: the loader binds to the platform fetch primitive and a runtime without one refuses instead of silently binding, so a host injects its own loader. Example: `defaultfetch().fetch("https://example.org")` rides the platform primitive. */
-export declare function defaultfetch(): fetchadapter;
-/** Composes the full adapter contract from the injected seams: the storage adapter is required because every runtime binds its own, while the clock, logger and fetch adapters default to the platform globals when the caller injects none. Example: `platformadapterof({ runtime: "node", storage: adapter })` fills the clock, logger and fetch defaults beside the injected storage. */
-export declare function platformadapterof(input: {
-    runtime: platformtarget["runtime"];
-    headless?: boolean;
-    storage: memoryadapter;
-    clock?: clockadapter;
-    logger?: loggeradapter;
-    fetch?: fetchadapter;
-}): adaptercontract;
-/** Reads the default node adapter: the caller injects the filesystem primitives of the node build, so this module never imports a node api and the browser bundles stay free of node shims. Example: `nodeplatformadapter({ profiledir, fs })` binds the filesystem storage under the profile directory. */
-export declare function nodeplatformadapter(input: {
-    profiledir: string;
-    fs: filesystemprimitives;
-    clock?: clockadapter;
-    logger?: loggeradapter;
-    fetch?: fetchadapter;
-}): adaptercontract;
-/** Reads the default browser adapter: the caller injects the chrome storage area of the browser build and an absent area falls back to the in-memory store, so the script tag bundle runs with no chrome api present. Example: `browserplatformadapter({ area })` binds the chrome storage area through the seam. */
-export declare function browserplatformadapter(input?: {
-    area?: chromestorageprimitives;
-    clock?: clockadapter;
-    logger?: loggeradapter;
-    fetch?: fetchadapter;
-}): adaptercontract;
-/** Reads the default deno adapter: the caller injects the kv store the deno host opened, so the deno runtime keeps its own storage mapping behind the same seam. Example: `denoplatformadapter({ kv })` binds the deno kv store. */
-export declare function denoplatformadapter(input: {
-    kv: denokvprimitives;
-    clock?: clockadapter;
-    logger?: loggeradapter;
-    fetch?: fetchadapter;
-}): adaptercontract;
-/** Publishes the active adapter contract onto the shared registry: every mode of the process reads the same adapter afterwards, so the library state stays consistent across the esm and cjs instances. Example: `setsharedadapter(adapter)` publishes one adapter for both modes. */
-export declare function setsharedadapter(adapter: adaptercontract): adaptercontract;
-/** Reads the active adapter contract from the shared registry; an unpublished registry answers undefined and a host publishes through setsharedadapter. Example: `sharedadapter()?.runtime` answers the runtime of the published adapter. */
-export declare function sharedadapter(): adaptercontract | undefined;
-/** Stamps the mode and target of the running bundle; each dist entry calls this once at load, so the library reports the bundle it runs from. Example: `stampbundle("umd", "devthink.umd.js")` stamps the script tag bundle. */
-export declare function stampbundle(mode: librarymode, target: string): void;
-/** Reads the stamp of the running bundle with the package version: one function answers the version, the consumption mode and the dist target of the bundle the caller loaded. Example: `bundlestamp().mode` answers `cjs` inside dist/index.cjs. */
-export declare function bundlestamp(): bundlemode;
-/** Detects the adapter runtime of the active platform through global probes: the node, bun and deno globals name their runtime and a page environment answers browser, so one probe decides which default adapter composition binds. Example: `detectadapterruntime()` answers `node` under the node build. */
-export declare function detectadapterruntime(): platformtarget["runtime"] | "unknown";
-/** Reads the adapter surface report of one contract: the runtime, mode, declaration mappings and probe flags in one plain record the doctor surfaces print. Example: `adaptersurfaceof(adapter).storage` answers the storage mapping name. */
-export declare function adaptersurfaceof(adapter: adaptercontract): {
-    runtime: string;
-    mode: librarymode;
-    storage: string;
-    worker: string;
-    dom: string;
-    probes: capabilityprobe;
-    declaration: runtimeadapterdeclaration;
-};
-/**
- * Runtimeadapters logic of the 1.1.67 family.
- * One core meets every runtime through its adapter: the capability probes detect the dom, storage, network and worker capabilities of the active runtime, a missing capability downgrades its feature instead of failing the runtime, and the runtime shells provide the timers, storage and fetch primitives with the storage adapter mapping to chrome storage in the browser, the filesystem in node and bun and deno kv in deno, the worker adapter mapping to web workers or worker threads and the dom adapter mapping to a live page in the browser and a remote browser session in headless mode.
- * The adapters stay injection seams: every primitive arrives as a parameter, so the pure core never imports a platform module and the extension bundle stays free of node shims.
- */
-/** The runtime names the adapters serve. */
-export type adapterruntime = platformtarget["runtime"];
-/** Reads one capability probe from the presence flags of the active runtime: the probe detects dom, storage, network and worker availability without failing anything. */
-export declare function capabilityprobeof(input: {
-    dom: boolean;
-    storage: boolean;
-    network: boolean;
-    worker: boolean;
-}): capabilityprobe;
-/** Reads the declared capability matrix: the browser probes every capability, node and bun probe storage, network and workers without a dom, and deno probes its kv storage, the platform fetch and its web workers without a dom. */
-export declare function runtimecapabilitiestable(): Record<adapterruntime, capabilityprobe>;
-/** Reads the adapter declaration of one runtime: the storage, fetch, timer, worker and dom mappings its platform provides. */
-export declare function runtimeadapterdeclarationof(runtime: adapterruntime, headless?: boolean): runtimeadapterdeclaration;
-/** Reads every adapter declaration of the matrix in one list, so the doctor report and the build matrix read the same mappings. */
-export declare function adapterdeclarationsof(): runtimeadapterdeclaration[];
-/** Reads the worker mapping of one runtime: the browser and deno run web workers while node and bun run worker threads. */
-export declare function workermapof(runtime: adapterruntime): "webworker" | "workerthreads";
-/** Reads the dom mapping of one mode: the browser maps to the live page and the headless mode maps to the remote browser session the attach protocol drives. */
-export declare function dommapof(mode: "browser" | "headless"): "livepage" | "remote";
-/** Computes the feature downgrades of one runtime: every feature whose capability the probes miss downgrades with its reason, and nothing fails the runtime. */
-export declare function downgradesof(input: {
-    features: Array<{
-        feature: string;
-        capability: keyof capabilityprobe;
-    }>;
-    probes: capabilityprobe;
-}): featuredowngrade[];
-/** Reads the storage primitives one filesystem runtime injects: the adapter maps every memory key to one json file under its base directory. */
-export interface filesystemprimitives {
-    readfile(path: string): Promise<string>;
-    writefile(path: string, data: string): Promise<void>;
-    mkdir(path: string): Promise<unknown>;
-    join(...parts: string[]): string;
-}
-/** Maps filesystem primitives onto the memory adapter seam: every key becomes one json file under the base directory, so node and bun store profiles the same way the browser stores them. */
-export declare function filesystemstorageadapter(fs: filesystemprimitives, base: string): memoryadapter;
-/** Reads the storage primitives one chrome runtime injects: the adapter maps every memory key onto one storage area entry. */
-export interface chromestorageprimitives {
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
-}
-/** Maps chrome storage primitives onto the memory adapter seam: the browser stores every memory key in the storage area the caller injected. */
-export declare function chromestorageadapter(area: chromestorageprimitives): memoryadapter;
-/** Reads the kv primitives one deno runtime injects: the adapter maps every memory key onto one kv entry. */
-export interface denokvprimitives {
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T): Promise<void>;
-}
-/** Maps deno kv primitives onto the memory adapter seam: deno stores every memory key in the kv store the caller opened. */
-export declare function denokvadapter(kv: denokvprimitives): memoryadapter;
-/** Maps an in-memory map onto the memory adapter seam: the test and browser fallback store keeps every key in one map. */
-export declare function memorystorageadapter(store?: Map<string, unknown>): memoryadapter;
-/** Reads the timer shell of one runtime: the platform scheduling primitive the caller injected decides when callbacks run, so no adapter reimplements a clock. */
-export declare function timershellof(primitives: {
-    settimeout(callback: () => void, milliseconds: number): unknown;
-    now(): number;
-}): {
-    schedule(callback: () => void, milliseconds: number): unknown;
-    now(): number;
-};
-/** Reads the fetch shell of one runtime: the platform fetch primitive the caller injected passes through untouched, because every supported runtime ships one. */
-export declare function fetchshellof(primitives: {
-    fetch(input: string, init?: unknown): Promise<unknown>;
-}): {
-    fetch(input: string, init?: unknown): Promise<unknown>;
-};
-/** Composes the runtime adapter of one target: the declaration, the probes and the injected primitives become one shell, with the storage adapter mapping through the seam the caller provided. */
-export declare function runtimeadapterof(input: {
-    runtime: adapterruntime;
-    headless?: boolean;
-    storage?: memoryadapter;
-    timer?: {
-        settimeout(callback: () => void, milliseconds: number): unknown;
-        now(): number;
-    };
-    fetch?: {
-        fetch(input: string, init?: unknown): Promise<unknown>;
-    };
-}): {
-    declaration: runtimeadapterdeclaration;
-    probes: capabilityprobe;
-    storage?: memoryadapter;
-    timer?: {
-        schedule(callback: () => void, milliseconds: number): unknown;
-        now(): number;
-    };
-    fetch?: {
-        fetch(input: string, init?: unknown): Promise<unknown>;
-    };
-};
-/** Reads the portable capability set of one runtime: a runtime that probes the dom (a live page or an attached remote session) executes every reviewed kind the vocabulary declares, and a runtime without one executes the kinds its domless filter admits. */
-export declare function portablecapabilityset(input: {
-    vocabulary: string[];
-    probes: capabilityprobe;
-    domlesskinds?: string[];
-}): string[];
-/**
- * Platformtargets logic of the 1.1.67 family.
- * The runtime matrix declares itself in one place: the browser, node, bun and deno targets each carry their entry file, bundle format, esbuild platform and declaration flag, the matrix verifies every runtime declares exactly one target, and one matrix run builds them all from the shared core.
- * Nothing about a target is inferred: the declaration is the contract the build matrix and the doctor report read, so a new runtime enters through one declaration and never through scattered build flags.
- */
-/** Declares the platform matrix: the browser target serves script tag consumers through the umd shell under the product name devthink.umd.js, the node target serves require consumers through its cjs shell, and the bun and deno targets ride the esm core entries of their runtime shells. */
-export declare function platformtargets(): platformtarget[];
-/** Builds the platform matrix of one declaration list with its completeness flag: the matrix completes when every runtime declares exactly one target. */
-export declare function platformmatrixof(targets: platformtarget[]): platformmatrix;
-/** Reads the platform target of one runtime from a declaration list; an absent or duplicated runtime refuses. */
-export declare function matrixtargetof(targets: platformtarget[], runtime: platformtarget["runtime"]): platformtarget;
-/** Verifies one matrix run: every declared target needs its built bundle present, so a missing entry names the runtime that failed its matrix run. */
-export declare function matrixverify(input: {
-    targets: platformtarget[];
-    present: string[];
-}): {
-    complete: boolean;
-    missing: string[];
-    reason: string;
-};
-/** Reads the output file name of one platform target bundle: an explicit output name wins, and an absent name keeps the entry stem with the format extension the target declares. */
-export declare function targetoutput(target: platformtarget): string;
-/** Reads the minified output file name of one platform target bundle: the unminified variant keeps its name and the minified variant inserts the min marker before the extension, so every target ships both variants under one rule. */
-export declare function minifiedoutput(target: platformtarget): string;
-//# sourceMappingURL=runtime.d.ts.map

package/dist/search.d.ts

@@ -1,375 +0,0 @@
-/**
- * @file search.ts
- * @module provider/search
- * @description
- *  Third-person observer: the library watches how Antigravity Manager and
- *  Gemini CLI perform grounding via googleSearch + urlContext and reproduces
- *  the contract without relying on localhost v1 proxy. The observer calls
- *  cloudcode-pa.googleapis.com directly, cascades endpoints on 403/404/5xx,
- *  injects native Gemini tools, and parses groundingMetadata rigorously.
- *
- *  Layout: library-first, root-first — file lives beside its siblings
- *  Runtime: only node:* builtins + global fetch (Node >=18). Zero external deps.
- *  Date governance: 25/08/2026 — Canto do Buriti, PI, BR — version awareness 2.0.0
- *
- *  Contract:
- *  - Endpoint: https://cloudcode-pa.googleapis.com/v1internal:generateContent (primary)
- *    cascade: daily-cloudcode-pa.googleapis.com, sandbox fallback
- *  - No localhost v1 base-url proxy, direct cloudcode-pa (security + user choice)
- *  - Native tools: googleSearch + urlContext — both injected when enabled
- *  - Model: SEARCH_MODEL gemini-3-flash with preview fallback chain
- *  - Thinking: thinkingLevel → thinkingBudget mapping (8192/16384/32768) clamped 32k
- *  - Grounding parse: groundingMetadata.webSearchQueries, groundingChunks[].web.uri/title,
- *    groundingSupports, searchEntryPoint.renderedContent
- *  - Proxy support: env HTTPS_PROXY/HTTP_PROXY/NO_PROXY + options.proxyUrl
- *    manual CONNECT tunneling via node:net + node:tls — no external deps
- *  - Bypass metadata: mimics antigravity/{ver} {os}/{arch} UA, strips x-goog-user-project,
- *    jitter 0-80ms, FNV-1a deterministic session_id note (not needed here but coherent)
- *
- *  EN: Antigravity bypass relies on mimicking antigravity/{ver} {os}/{arch} UA
- *      and bypassing x-goog-user-project stripping, endpoint cascade 403/404/5xx.
- *  PT-BR: Bypass Antigravity depende de imitar UA antigravity/{ver} {os}/{arch}
- *      e remover x-goog-user-project, cascata de endpoints em 403/404/5xx.
- *
- *  Production-ready: JSDoc, exhaustive error handling, timeout, abort, proxy,
- *  endpoint cascade, thinking budget, grounding parsing, no placeholder.
- *
- * @author devthink
- * @license MIT
- * @version 2.0.0
- */
-import { ANTIGRAVITY_USER_AGENT_FALLBACK, ANTIGRAVITY_VERSION_FALLBACK, DEFAULT_TIMEOUT_MS, GENERATE_CONTENT_ENDPOINT, JITTER_MAX_MS, JITTER_MIN_MS, STREAM_GENERATE_ENDPOINT } from "./constants.js";
-import { fnv1a32, getJitter, isRetryableStatus } from "./core.js";
-import { buildAntagravityHeaders, getDynamicUserAgent } from "./fingerprint.js";
-import { CODE_ASSIST_ENDPOINTS, SEARCH_MODEL, SEARCH_MODEL_FALLBACKS, SEARCH_MODEL_PREVIEW, THINKING_BUDGET_MAP, THINKING_BUDGET_MAX_CLAUDE, THINKING_BUDGET_MAX_GEMINI, THINKING_LEVELS, buildImageGenConfig, isImageGenModel } from "./models.js";
-import type { ThinkingLevel } from "./models.js";
-declare function parseGrounding(meta: any): {
-    uri: string;
-    title?: string;
-}[];
-export { ANTIGRAVITY_USER_AGENT_FALLBACK, ANTIGRAVITY_VERSION_FALLBACK, CODE_ASSIST_ENDPOINTS, DEFAULT_TIMEOUT_MS, GENERATE_CONTENT_ENDPOINT, JITTER_MAX_MS, JITTER_MIN_MS, SEARCH_MODEL, SEARCH_MODEL_FALLBACKS, SEARCH_MODEL_PREVIEW, STREAM_GENERATE_ENDPOINT, THINKING_BUDGET_MAP, THINKING_BUDGET_MAX_CLAUDE, THINKING_BUDGET_MAX_GEMINI, THINKING_LEVELS, buildImageGenConfig, getDynamicUserAgent, getJitter, isImageGenModel, };
-export type { ThinkingLevel };
-export { parseGrounding };
-/** Endpoint cascade — observer watches traffic: PROD first, then DAILY, SANDBOX */
-export declare const DEFAULT_ENDPOINT_ORDER: readonly string[];
-/** Timeouts — observer notes 10s per control call, 60s for content */
-export declare const SEARCH_TIMEOUT_MS: 60000;
-/**
- * Web chunk returned by groundingMetadata.
- * Observer documents: each chunk points to a source URL used for grounding.
- */
-export interface WebGroundingChunk {
-    /** source uri, e.g. https://developer.mozilla.org/... */
-    uri: string;
-    /** title returned by search */
-    title: string;
-    /** derived domain — convenience */
-    domain?: string | undefined;
-}
-/** Raw web object inside groundingChunks */
-export interface GroundingChunkWeb {
-    uri?: string;
-    title?: string;
-    domain?: string;
-}
-export interface GroundingChunk {
-    web?: GroundingChunkWeb;
-    /** alternative shapes: retrievedContext etc. — kept for resilience */
-    retrievedContext?: {
-        uri?: string;
-        title?: string;
-        text?: string;
-    };
-    [k: string]: unknown;
-}
-export interface GroundingSupportSegment {
-    startIndex?: number;
-    endIndex?: number;
-    text?: string;
-}
-export interface GroundingSupport {
-    segment?: GroundingSupportSegment;
-    groundingChunkIndices?: number[];
-    confidenceScores?: number[];
-}
-export interface SearchEntryPoint {
-    renderedContent?: string;
-    [k: string]: unknown;
-}
-export interface GroundingMetadata {
-    webSearchQueries?: string[];
-    groundingChunks?: GroundingChunk[];
-    groundingSupports?: GroundingSupport[];
-    searchEntryPoint?: SearchEntryPoint;
-    retrievalQueries?: string[];
-    [k: string]: unknown;
-}
-/** Request shape */
-export interface ExecuteSearchInput {
-    /** user query to ground with googleSearch/urlContext */
-    query: string;
-    /** optional system instruction — helps guide grounded answer */
-    systemPrompt?: string | undefined;
-    /** optional additional context appended to user query for better grounding */
-    additionalContext?: string | undefined;
-}
-export interface ExecuteSearchAuth {
-    /** OAuth access_token Bearer — required */
-    accessToken: string;
-    /** project id resolved via loadCodeAssist/onboardUser — optional but improves success */
-    projectId?: string;
-    /** optional custom user agent — fallback uses dynamic UA */
-    userAgent?: string;
-    /** optional antigravity version for UA — defaults to 1.19.2 */
-    version?: string;
-    /** optional client metadata override */
-    clientMetadata?: string;
-}
-export interface ExecuteSearchOptions {
-    /** model — defaults to SEARCH_MODEL gemini-3-flash */
-    model?: string;
-    /** thinking level mapping to budget */
-    thinkingLevel?: ThinkingLevel;
-    /** direct budget override — clamped 0-32768 */
-    thinkingBudget?: number;
-    /** include groundingMetadata in result — default true */
-    includeGrounding?: boolean;
-    /** inject url_context companion tool — default true per spec */
-    useUrlContext?: boolean;
-    /** inject google_search tool — default true */
-    useGoogleSearch?: boolean;
-    /** proxy url e.g. http://127.0.0.1:8080 — null disables env proxy */
-    proxyUrl?: string | null;
-    /** timeout per fetch — default 60s */
-    timeoutMs?: number;
-    /** custom endpoint list for cascade — default PROD/DAILY/SANDBOX */
-    endpoints?: string[];
-    /** include rendered search entry point? */
-    includeSearchEntryPoint?: boolean;
-    /** temperature for grounded answer — default 0.2 */
-    temperature?: number;
-    /** max output tokens — default 8192 */
-    maxOutputTokens?: number;
-    /** debug logging */
-    debug?: boolean;
-    /** jitter between endpoint retries — default true */
-    jitter?: boolean;
-    /** max retries across endpoints — internal */
-    maxRetries?: number;
-}
-/** Final grounded result */
-export interface SearchResult {
-    /** synthesized answer text */
-    text: string;
-    /** original query */
-    query: string;
-    /** model used */
-    model: string;
-    /** true if grounding sources returned */
-    grounded: boolean;
-    /** queries Gemini issued to Google Search */
-    webSearchQueries: string[];
-    /** parsed web sources — uri/title */
-    groundingChunks: WebGroundingChunk[];
-    /** raw supports — segment attribution */
-    groundingSupports?: GroundingSupport[] | undefined;
-    /** rendered search entry point HTML if present */
-    searchEntryPoint?: SearchEntryPoint | undefined;
-    /** raw groundingMetadata as returned */
-    groundingMetadata?: GroundingMetadata | undefined;
-    /** raw candidate response for debugging */
-    raw?: unknown | undefined;
-    /** endpoint that succeeded */
-    endpointUsed?: string | undefined;
-    /** thinking budget used */
-    thinkingBudgetUsed?: number | undefined;
-    /** was fallback project used? */
-    isFallbackProject?: boolean;
-}
-export declare class SearchError extends Error {
-    readonly status?: number | undefined;
-    readonly endpoint?: string | undefined;
-    readonly retryable: boolean;
-    readonly code?: string | undefined;
-    constructor(message: string, opts?: {
-        status?: number;
-        endpoint?: string;
-        retryable?: boolean;
-        code?: string;
-        cause?: unknown;
-    });
-}
-/**
- * Checks if HTTP status is retryable for endpoint cascade.
- * Observer: 403 project IAM mismatch, 404 rollout, 5xx instability → try next endpoint.
- */
-export interface ProxyResolution {
-    /** final proxy url to use, null if disabled */
-    proxyUrl: string | null;
-    /** reason / source for debugging */
-    source: "option" | "env_https_proxy" | "env_http_proxy" | "env_all_proxy" | "disabled" | "none" | "no_proxy_bypass";
-}
-/**
- * Parses NO_PROXY env — comma separated list of host suffixes, IPs, CIDRs (simplified).
- */
-export declare function isNoProxyMatch(targetHost: string, noProxyRaw: string | undefined): boolean;
-/**
- * Resolves proxy URL respecting options.proxyUrl, env vars, and NO_PROXY.
- * Observer scans env case-insensitively as per curl conventions.
- *
- * @param optionsProxy - explicit option, string or null (null disables)
- * @param targetUrl - target to check NO_PROXY against
- */
-export declare function resolveProxyUrl(optionsProxy: string | null | undefined, targetUrl?: string): ProxyResolution;
-/**
- * Fetch with timeout using AbortController.
- * Observer pattern: never leaks abort timer.
- *
- * @param url - url
- * @param init - init
- * @param timeoutMs - timeout
- * @param proxyUrl - optional proxy
- */
-export declare function fetchWithProxyTimeout(url: string, init: RequestInit, timeoutMs?: number, proxyUrl?: string | null): Promise<any>;
-/**
- * Resolves thinking budget from level or direct number.
- * Observer clamps to Gemini max 32768.
- *
- * @param level - thinkingLevel minimal/low/medium/high
- * @param directBudget - optional direct thinkingBudget
- * @returns clamped budget number
- */
-export declare function resolveThinkingBudget(level?: ThinkingLevel, directBudget?: number): number;
-/**
- * Normalizes model name — strips models/ prefix for body, keeps original for logging.
- * Observer notes cloudcode-pa accepts both gemini-3-flash and models/gemini-3-flash.
- *
- * @param raw - model id
- */
-export declare function normalizeModelName(raw: string): {
-    bare: string;
-    withPrefix: string;
-    original: string;
-};
-/**
- * Executes grounded search using Gemini native googleSearch + urlContext tools.
- * Third-person observer pattern: imitates Antigravity's google_search tool wrapper
- * but calls cloudcode-pa.googleapis.com directly, no localhost proxy.
- *
- * The observer:
- * 1. Validates query + accessToken.
- * 2. Resolves proxy (env + option) with NO_PROXY bypass.
- * 3. Resolves thinking budget from level or direct number, clamped 32k.
- * 4. Builds contents + tools [{googleSearch:{}},{urlContext:{}}] + generationConfig.
- * 5. Builds Antigravity headers (Bearer, UA dynamic, Client-Metadata, Api-Client)
- *    stripping x-goog-user-project per bypass spec.
- * 6. Cascades endpoints PROD → DAILY → SANDBOX on 403/404/5xx with jitter 0-80ms.
- * 7. Parses groundingMetadata.groundingChunks[].web.uri/title and webSearchQueries.
- *
- * @param input - query + optional systemPrompt
- * @param auth - OAuth access token + projectId + UA override
- * @param opts - model, thinking, proxy, timeout, endpoints, etc.
- * @returns grounded SearchResult with parsed chunks
- *
- * @throws SearchError on validation, timeout, 401, exhausted cascade, or invalid JSON.
- *
- * @example
- * ```ts
- * const result = await executeSearch(
- *   { query: "latest Gemini 3 flash grounding changes 2026" },
- *   { accessToken: "...", projectId: "rising-fact-p41fc" },
- *   { thinkingLevel: "medium", useUrlContext: true }
- * );
- * console.log(result.text);
- * console.log(result.groundingChunks.map(c=>c.uri));
- * ```
- */
-export declare function executeSearch(input: ExecuteSearchInput, auth: ExecuteSearchAuth, opts?: ExecuteSearchOptions): Promise<SearchResult>;
-/**
- * Convenience: execute search with project fallback rising-fact-p41fc.
- * Observer notes this fallback works for Antigravity but 403 for Gemini CLI models.
- *
- * @param query - search query
- * @param accessToken - bearer token
- * @param opts - optional search options + projectId override
- */
-export declare function searchWithFallback(query: string, accessToken: string, opts?: ExecuteSearchOptions & {
-    projectId?: string;
-    systemPrompt?: string;
-}): Promise<SearchResult>;
-/**
- * Extracts only grounding URIs from result — helper for TUI.
- *
- * @param result - SearchResult
- * @returns uri strings
- */
-export declare function extractGroundingUris(result: SearchResult): string[];
-/**
- * Extracts grounding titles for UI display.
- */
-export declare function extractGroundingTitles(result: SearchResult): Array<{
-    uri: string;
-    title: string;
-}>;
-/**
- * Decides whether native googleSearch grounding should be enabled for a model
- * given plugin config (`google_search_enabled`: true | "auto" | falsy).
- */
-export declare const shouldEnableSearch: (model: string, cfg: any) => boolean;
-/** Builds the native grounding tool list: googleSearch + urlContext. */
-export declare const buildSearchTools: () => any[];
-/** Normalizes groundingMetadata chunks into {uri,title} pairs.
- * Identical to core.parseGrounding — imported from the frozen owner and
- * re-exported above. */
-/** Formats grounding sources as markdown citation lines. */
-export declare const extractCitations: (grounding: any[]) => string;
-/**
- * Saves a base64-encoded PNG under ~/.config/opencode/generated-images (or a
- * custom dir) using an timestamped random filename; returns the written path.
- */
-export declare const saveGeneratedImage: (b64: string, dir?: string) => Promise<string>;
-/** Renders grounding sources as a markdown bullet list. */
-export declare const groundingToMarkdown: (grounding: any[]) => string;
-export declare const Search: {
-    SEARCH_MODEL: "gemini-3-flash";
-    SEARCH_MODEL_PREVIEW: "gemini-3-flash-preview";
-    SEARCH_MODEL_FALLBACKS: readonly ["gemini-3-flash-preview", "gemini-3-flash", "antigravity-gemini-3-flash", "gemini-3-flash-preview-2026"];
-    CODE_ASSIST_ENDPOINTS: {
-        readonly PROD: "https://cloudcode-pa.googleapis.com";
-        readonly DAILY: "https://daily-cloudcode-pa.googleapis.com";
-        readonly SANDBOX: "https://daily-cloudcode-pa.sandbox.googleapis.com";
-        readonly AUTOPUSH: "https://autopush-cloudcode-pa.sandbox.googleapis.com";
-    };
-    DEFAULT_ENDPOINT_ORDER: readonly string[];
-    GENERATE_CONTENT_ENDPOINT: "/v1internal:generateContent";
-    THINKING_BUDGET_MAP: Record<"high" | "low" | "max" | "medium" | "minimal" | "tiered", number>;
-    THINKING_LEVELS: readonly ["minimal", "low", "medium", "high", "tiered", "max"];
-    THINKING_BUDGET_MAX_GEMINI: 32768;
-    ANTIGRAVITY_VERSION_FALLBACK: "1.19.2";
-    ANTIGRAVITY_USER_AGENT_FALLBACK: string;
-    getDynamicUserAgent: typeof getDynamicUserAgent;
-    buildAntagravityHeaders: typeof buildAntagravityHeaders;
-    fetchWithProxyTimeout: typeof fetchWithProxyTimeout;
-    resolveProxyUrl: typeof resolveProxyUrl;
-    isNoProxyMatch: typeof isNoProxyMatch;
-    resolveThinkingBudget: typeof resolveThinkingBudget;
-    normalizeModelName: typeof normalizeModelName;
-    executeSearch: typeof executeSearch;
-    searchWithFallback: typeof searchWithFallback;
-    extractGroundingUris: typeof extractGroundingUris;
-    extractGroundingTitles: typeof extractGroundingTitles;
-    shouldEnableSearch: typeof shouldEnableSearch;
-    buildSearchTools: typeof buildSearchTools;
-    parseGrounding: typeof parseGrounding;
-    extractCitations: typeof extractCitations;
-    isImageGenModel: typeof isImageGenModel;
-    buildImageGenConfig: typeof buildImageGenConfig;
-    saveGeneratedImage: typeof saveGeneratedImage;
-    groundingToMarkdown: typeof groundingToMarkdown;
-    SearchError: typeof SearchError;
-    isRetryableStatus: typeof isRetryableStatus;
-    getJitter: typeof getJitter;
-    fnv1a32: typeof fnv1a32;
-};
-export default Search;
-//# sourceMappingURL=search.d.ts.map