@vib-rato/ai 0.16.0

package/dist/types/providers/cursor-pi-args.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Translate a Pi frame's args into the local tool kwargs that run it.
+ *
+ * Shared deliberately by three consumers: the provider synthesizes a display
+ * block from these, the coding-agent bridge executes with them, and the legacy
+ * pi shim performs the identical translation for the old wire. Separate
+ * hand-rolled copies drift, and the drift is invisible — the transcript shows
+ * one operation while a different one runs.
+ *
+ * Kept apart from `cursor/exec-modern.ts` on purpose: these are pure
+ * string/path functions with no protobuf coupling, while that module pulls in
+ * `@bufbuild/protobuf` and the generated `agent_pb` graph. The legacy shim is
+ * compiled into the bundled virtual module registry, so importing it from a
+ * nested path would drag the whole exec implementation in with it — and
+ * `./providers/*` is a single-segment wildcard export that cannot serve a
+ * nested specifier under bunfs (issue #3442).
+ *
+ * Every `optional int32` here is presence-sensitive: `0` is a supplied value,
+ * not "unset", so it must never be folded into a default.
+ */
+/**
+ * A `pi_read` range composed onto the path as `read`'s inline `:raw:N+K`
+ * selector.
+ *
+ * `read` exposes no range kwargs, so an uncomposed range reads the whole file.
+ * `offset` is a 1-indexed start clamped like the reference's
+ * `Math.max(0, offset - 1)` over 0-indexed lines; `limit` is a line count.
+ * `null` marks a present `limit: 0` — zero lines, which no selector expresses
+ * and which must not degrade into a whole-file read.
+ *
+ * The range is `raw` because a plain `:N+K` deliberately pads with one leading
+ * and three trailing context lines: helpful for a human reading a snippet,
+ * wrong for a caller that asked for exactly `limit` lines from `offset`. The
+ * wire result is an opaque `output` string, so the hashline and line-number
+ * gutter that `raw` also drops carry nothing the frame's contract needs.
+ * A range-free read keeps the ordinary form — whole-file reads want them.
+ */
+export declare function piReadPath(readPath: string, offset?: number, limit?: number): string | null;
+/**
+ * Whether a read path ends in an OMP line selector, including compound `raw`
+ * forms. Cursor uses this only to describe the operation already executed by
+ * the coding-agent read tool; the selector remains embedded in the path.
+ */
+export declare function piReadPathHasRange(readPath: string): boolean;
+/**
+ * The same range as {@link piReadPath}, rendered for a transcript block rather
+ * than for execution.
+ *
+ * Differs only at `limit: 0`, where `piReadPath` returns `null` because no
+ * selector reads zero lines and the frame is answered with empty output
+ * directly. The block still has to say so: falling back to the bare path there
+ * would record a whole-file read whose result is empty, which is the widest
+ * possible gap between what a rebuilt transcript shows and what happened.
+ * `+0` is never executed — it exists to be read.
+ */
+export declare function piReadDisplayPath(readPath: string, offset?: number, limit?: number): string;
+/**
+ * A legacy `grep` frame's pagination `offset` as the local tool's file `skip`.
+ *
+ * `grep` paginates by file and reports "use skip=N for the next page" in that
+ * same unit, so the offset maps across directly. A present `0` means "start at
+ * the beginning", which is the unskipped search rather than a skip of zero.
+ *
+ * Shared because both the executing bridge and the provider's transcript
+ * synthesis need it: a block showing an unskipped search beside a result from
+ * a later file window misreports what was searched.
+ */
+export declare function piGrepSkip(offset?: number): number | undefined;
+/**
+ * Join a Pi frame's optional `path` with the `glob`/`pattern` it scopes.
+ *
+ * The local `grep`/`glob` tools take one combined path spec. An absolute
+ * pattern ignores the path, and an absent or `.` path leaves the pattern
+ * standing alone rather than building a `./`- or `//`-prefixed spec.
+ *
+ * Uses `node:path` rather than string surgery so Windows absolutes (`C:\…`,
+ * UNC) are recognised and separators stay normalized.
+ */
+export declare function piJoinPath(basePath: string | undefined, pattern: string): string;
+/**
+ * The path a `pi_ls` frame lists.
+ *
+ * The frame's `limit` is deliberately NOT mapped. It caps directory *entries*
+ * (the reference does a flat `readdir` and slices the entry array), while the
+ * local `read` tool renders a depth-2 tree with per-directory caps and elision
+ * summaries and applies a selector as a *rendered line* slice. Nested rows,
+ * headers and "N more" lines all count toward that slice, so `:1+K` would cap
+ * a different unit while looking honored — worse than leaving it unset, which
+ * at least reports the local listing's own truncation faithfully.
+ */
+export declare function piLsPath(basePath: string | undefined): string;
+/** Escape a literal string so the regex-only local `grep` tool matches it verbatim. */
+export declare function piEscapeRegexLiteral(value: string): string;
+/** Clamp a present `optional int32` result cap the way the reference does; `undefined` stays unset. */
+export declare function piLimit(limit: number | undefined): number | undefined;
+/**
+ * A `pi_bash` frame's timeout as the local `bash` tool's kwarg.
+ *
+ * Presence-sensitive like every other `optional int32` here, and unusually
+ * load-bearing: `bash` documents `timeout: 0` as "disables the command
+ * deadline", so folding a supplied `0` into `undefined` applies the 300s
+ * default and kills exactly the long-running command that asked not to be.
+ * Negative values have no local meaning and fall back to the default.
+ */
+export declare function piTimeout(timeout: number | undefined): number | undefined;
+/**
+ * Drop keys whose value is `undefined` so optional local-tool kwargs stay
+ * absent rather than present-as-undefined.
+ *
+ * The Cursor exec bridge historically wrote forms like
+ * `cwd: workingDirectory || undefined` and
+ * `case: caseInsensitive === true ? false : undefined`. ArkType rejects a
+ * present `undefined` on an optional field (`was undefined`) even though
+ * omitting the key is valid — which flooded Cursor sessions with bash/grep
+ * validation errors for otherwise fine frames.
+ */
+export declare function omitUndefinedArgs<T extends Record<string, unknown>>(args: T): {
+    [K in keyof T]?: Exclude<T[K], undefined>;
+};

package/dist/types/providers/cursor.d.ts

@@ -0,0 +1,72 @@
+import { type JsonValue } from "@bufbuild/protobuf";
+import type { CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, Model, StreamFunction, StreamOptions, ToolCall, ToolResultMessage } from "../types";
+import { kCursorExecResolved } from "../utils/block-symbols";
+import { CURSOR_CLIENT_VERSION } from "./cursor/client-version";
+import type { CursorRule, RequestedModel_ModelParameterbytes } from "./cursor/gen/agent_pb";
+export declare const CURSOR_API_URL = "https://api2.cursor.sh";
+export { CURSOR_CLIENT_VERSION };
+/** Drop all cached state + blob bytes for a conversation (F15 bound + session-teardown hook). */
+export declare function disposeCursorConversation(conversationId: string): void;
+export interface CursorOptions extends StreamOptions {
+    customSystemPrompt?: string;
+    conversationId?: string;
+    execHandlers?: CursorExecHandlers;
+    onToolResult?: CursorToolResultHandler;
+}
+/** Build the ordered global USER rules Cursor expects for the current system prompt. */
+export declare function buildCursorRequestContextRules(systemPrompt: readonly string[] | undefined): CursorRule[];
+export interface CursorWireModelResolution {
+    modelId: string;
+    parameters: RequestedModel_ModelParameterbytes[];
+    translated: boolean;
+}
+/** Resolve a Cursor model's GPT effort suffix into its wire model and parameter. */
+export declare function resolveCursorWireModelForTest(model: Pick<Model<"cursor-agent">, "id" | "wireModelId">): CursorWireModelResolution;
+/** Turn Cursor's opaque HTTP/2 failure into a useful transport diagnosis. */
+export declare function mapH2TransportError(error: unknown, baseUrl: string): unknown;
+export declare const streamCursor: StreamFunction<"cursor-agent">;
+type ToolCallState = ToolCall & {
+    index: number;
+    partialJson?: string;
+    kind: "mcp" | "todo_write" | "native" | "cursor-exec";
+    [kCursorExecResolved]?: true;
+};
+/** Exported for tests: verifies handler is invoked with correct `this` when passed as bound. */
+export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult): Promise<{
+    execResult: TResult;
+    toolResult?: ToolResultMessage;
+}>;
+/** Exported for deterministic coverage of ordered server-message handling. */
+export declare function createCursorMessageQueueForTest(onError?: (error: unknown) => void): {
+    enqueue(handler: () => void | Promise<void>): Promise<void>;
+    drain(): Promise<void>;
+};
+/** Exported for direct regression coverage of the JSON-safety boundary. */
+export declare function cursorJsonSafeValueForTest(value: unknown): unknown;
+export declare function buildNativeToolCallBlock(toolCall: Record<string, unknown>, callId: string, index: number): ToolCallState | null;
+/**
+ * Build `ConversationStateStructure.rootPromptMessagesJson` blob IDs for the
+ * system prompt plus prior conversation history, as JSON blobs matching
+ * Cursor's internal Vercel-AI-SDK-shaped message format.
+ *
+ * Cursor's server uses `rootPromptMessagesJson` (not `turns[]`) to build the
+ * actual model prompt. `turns[]` is UI/display metadata. Without populating
+ * this field, multi-turn conversations lose prior context — the model sees
+ * only an empty placeholder where historical user turns should be.
+ * The last user message is excluded because it is sent in the action.
+ */
+/**
+ * Build one Cursor system-message JSON blob per ordered system prompt. Emitting separate blobs
+ * (rather than a single `\n\n`-joined string) lets Cursor's blob cache hit independently per
+ * entry: changing only the last prompt does not invalidate earlier blob ids, so the prefix
+ * up to the changed prompt remains cached on the server side.
+ *
+ * When no system prompts are provided, returns a single default greeting so we never emit
+ * an empty `rootPromptMessagesJson` head.
+ */
+export declare function buildCursorSystemPromptJsons(systemPrompt: readonly string[] | undefined, modelId?: string): string[];
+/** Exported for tests: decodes Cursor history blobs built from conversation messages. */
+export declare function buildCursorHistoryForTest(messages: Message[]): {
+    rootPromptMessagesJson: unknown[];
+    turnUserMessagesJson: JsonValue[];
+};

package/dist/types/providers/dashscope-token-plan-headers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DashScope Token Plan canonical request headers.
+ *
+ * Reproduces QwenLM/qwen-code's DashScopeOpenAICompatibleProvider.buildHeaders()
+ * defaultHeaders so the built-in `alibaba-token-plan` provider emits the same
+ * client identity / cache / auth-type fingerprint upstream sends. DashScope is
+ * compatibility-sensitive to this fingerprint; a non-identical set can cause
+ * request instability and affect first-event latency (vib-rato #3557).
+ *
+ * Upstream pin (reproduce EXACTLY here):
+ *   Repository:    QwenLM/qwen-code
+ *   Commit:        f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb
+ *   Version:       0.21.1
+ *   Source:        packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
+ *   buildHeaders():
+ *     const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+ *     const defaultHeaders = {
+ *       'User-Agent': userAgent,
+ *       'X-DashScope-CacheControl': 'enable',
+ *       'X-DashScope-UserAgent': userAgent,
+ *       'X-DashScope-AuthType': authType,
+ *     };
+ *     return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
+ *
+ * The Token Plan preset authenticates with AuthType.USE_OPENAI ('openai'), so
+ * X-DashScope-AuthType is the constant 'openai'. Pin the version so an upstream
+ * bump is an explicit parity update rather than silent drift.
+ */
+export declare const QWEN_CODE_UPSTREAM_REPO = "QwenLM/qwen-code";
+export declare const QWEN_CODE_UPSTREAM_COMMIT = "f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb";
+export declare const QWEN_CODE_UPSTREAM_VERSION = "0.21.1";
+/**
+ * The Qwen Code CLI version string used in identity headers. Pinned to the
+ * upstream version at {@link QWEN_CODE_UPSTREAM_COMMIT}; change both together
+ * as an explicit parity update.
+ */
+export declare function qwenCodeUserAgent(version?: string): string;
+/**
+ * Canonical DashScope Token Plan headers (upstream defaultHeaders, no caller
+ * overrides applied). Exposed for tests/fixtures so the pinned wire set lives
+ * in exactly one place.
+ */
+export declare function dashscopeTokenPlanDefaultHeaders(version?: string): Readonly<Record<string, string>>;
+/**
+ * Merge canonical DashScope Token Plan identity headers onto a caller's header
+ * map, reproducing upstream buildHeaders() precedence EXACTLY:
+ *   `{ ...defaultHeaders, ...customHeaders }` — caller wins per header.
+ *
+ * This mirrors Vibrato's existing kimi-code injection order
+ * (`headers = { ...getKimiCommonHeaders(), ...headers }`): canonical identity as
+ * the base, caller-supplied headers overriding individual keys. A caller that
+ * pins `User-Agent` takes that key; the other canonicals still apply.
+ *
+ * A null/undefined `callerHeaders` returns the canonical set alone (upstream
+ * `customHeaders ? {...} : defaultHeaders` shortcut).
+ */
+export declare function mergeDashScopeTokenPlanHeaders(callerHeaders: Record<string, string> | undefined, version?: string): Record<string, string>;

package/dist/types/providers/error-message.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Model } from "../types";
+export declare function createProviderErrorMessage(model: Model<Api>, err: unknown): {
+    role: "assistant";
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    api: Api;
+    provider: string;
+    model: string;
+    usage: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        totalTokens: number;
+        cost: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+            total: number;
+        };
+    };
+    stopReason: "error";
+    timestamp: number;
+};

package/dist/types/providers/github-copilot-headers.d.ts

@@ -0,0 +1,40 @@
+import type { Message } from "../types";
+/**
+ * Infer whether the current request to Copilot is user-initiated or agent-initiated.
+ * Accepts `unknown[]` because providers may pass pre-converted message shapes.
+ */
+export type CopilotInitiator = "user" | "agent";
+export type CopilotPremiumRequests = number;
+export type CopilotDynamicHeaders = {
+    headers: Record<string, string>;
+    initiator: CopilotInitiator;
+    premiumRequests: CopilotPremiumRequests;
+};
+export declare function resolveGitHubCopilotBaseUrl(baseUrl: string | undefined, apiKey: string | undefined): string | undefined;
+export declare function inferCopilotInitiator(messages: unknown[]): CopilotInitiator;
+/** Check whether any message in the conversation contains image content. */
+export declare function hasCopilotVisionInput(messages: Message[]): boolean;
+/**
+ * Resolve an explicitly configured Copilot initiator header, if present.
+ * Handles case-insensitive X-Initiator keys and returns the last valid value.
+ */
+export declare function getCopilotInitiatorOverride(headers: Record<string, string> | undefined): CopilotInitiator | undefined;
+export type CopilotPlanTier = "free" | "paid";
+export declare function getCopilotPremiumMultiplier(premiumMultiplier: number | undefined, planTier?: string): number;
+export declare function getCopilotPremiumRequests(params: {
+    initiator: CopilotInitiator;
+    premiumMultiplier?: number;
+    planTier?: string;
+}): CopilotPremiumRequests;
+/**
+ * Build dynamic Copilot headers that vary per-request.
+ * Static headers (User-Agent, Editor-Version, etc.) come from model.headers.
+ */
+export declare function buildCopilotDynamicHeaders(params: {
+    messages: unknown[];
+    hasImages: boolean;
+    premiumMultiplier?: number;
+    headers?: Record<string, string>;
+    initiatorOverride?: CopilotInitiator;
+    planTier?: string;
+}): CopilotDynamicHeaders;

package/dist/types/providers/gitlab-duo.d.ts

@@ -0,0 +1,27 @@
+import type { Api, Context, Model, SimpleStreamOptions } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+type GitLabProvider = "anthropic" | "openai";
+type GitLabOpenAIApiType = "chat" | "responses";
+export type GitLabModelMapping = {
+    provider: GitLabProvider;
+    model: string;
+    openaiApiType?: GitLabOpenAIApiType;
+    name: string;
+    reasoning: boolean;
+    input: ("text" | "image")[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+};
+export declare const MODEL_MAPPINGS: Record<string, GitLabModelMapping>;
+export declare function getModelMapping(modelId: string): GitLabModelMapping | undefined;
+export declare function getGitLabDuoModels(): Model<Api>[];
+export declare function clearGitLabDuoDirectAccessCache(): void;
+export declare function isGitLabDuoModel(model: Model<Api>): boolean;
+export declare function streamGitLabDuo(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+export {};

package/dist/types/providers/google-auth.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Application Default Credentials (ADC) resolution for Vertex AI.
+ *
+ * Replaces `google-auth-library` with a direct WebCrypto + REST implementation.
+ * Sources, in priority order:
+ *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
+ *     or `type: "authorized_user"` (refresh-token exchange).
+ *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
+ *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
+ *
+ * Tokens are cached per source key and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` before expiry
+ * (default 60s). Concurrent callers waiting on a refresh share the same in-flight promise.
+ */
+import type { FetchImpl } from "../types";
+/** Test seam: the ADC credentials file path as resolved from trusted env. */
+export declare function resolveAdcCredentialsPathForTest(): string | undefined;
+/**
+ * Returns a Bearer access token suitable for the `Authorization` header on Vertex AI calls.
+ * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.
+ */
+export declare function getVertexAccessToken(options?: {
+    signal?: AbortSignal;
+    fetch?: FetchImpl;
+}): Promise<string>;
+/** Test seam: clears every cached token. */
+export declare function __resetVertexTokenCache(): void;

package/dist/types/providers/google-gemini-cli.d.ts

@@ -0,0 +1,75 @@
+import type { Context, Model, StreamFunction, StreamOptions } from "../types";
+import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
+import { type GoogleThinkingLevel } from "./google-shared";
+/**
+ * Thinking level for Gemini 3 models. Re-exported from `google-shared` so existing
+ * `import { GoogleThinkingLevel } from "./google-gemini-cli"` callers keep working.
+ */
+export type { GoogleThinkingLevel };
+export interface GoogleGeminiCliOptions extends StreamOptions {
+    toolChoice?: "auto" | "none" | "any" | "required";
+    /**
+     * Thinking/reasoning configuration.
+     * - Gemini 2.x models: use `budgetTokens` to set the thinking budget
+     * - Gemini 3 models (gemini-3-pro-*, gemini-3-flash-*): use `level` instead
+     *
+     * When using `streamSimple`, this is handled automatically based on the model.
+     */
+    thinking?: {
+        enabled: boolean;
+        /** Thinking budget in tokens. Use for Gemini 2.x models. */
+        budgetTokens?: number;
+        /** Thinking level. Use for Gemini 3 models (LOW/HIGH for Pro, MINIMAL/LOW/MEDIUM/HIGH for Flash). */
+        level?: GoogleThinkingLevel;
+    };
+    projectId?: string;
+}
+export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityRequestHeaders, getGeminiCliHeaders, getGeminiCliUserAgent, } from "./google-gemini-headers";
+interface ParsedGeminiCliCredentials {
+    accessToken: string;
+    projectId: string;
+    refreshToken?: string;
+    expiresAt?: number;
+}
+export declare function parseGeminiCliCredentials(apiKeyRaw: string): ParsedGeminiCliCredentials;
+export declare function shouldRefreshGeminiCliCredentials(expiresAt: number | undefined, isAntigravity: boolean, nowMs?: number): boolean;
+interface CloudCodeAssistRequest {
+    project: string;
+    model: string;
+    request: {
+        contents: Content[];
+        sessionId?: string;
+        systemInstruction?: {
+            role?: string;
+            parts: {
+                text: string;
+            }[];
+        };
+        generationConfig?: {
+            maxOutputTokens?: number;
+            temperature?: number;
+            topP?: number;
+            topK?: number;
+            minP?: number;
+            presencePenalty?: number;
+            repetitionPenalty?: number;
+            thinkingConfig?: ThinkingConfig;
+        };
+        tools?: {
+            functionDeclarations: Record<string, unknown>[];
+        }[] | undefined;
+        toolConfig?: {
+            functionCallingConfig: {
+                mode: FunctionCallingConfigMode;
+            };
+        };
+        preambleConfig?: {
+            mode: "SYSTEM_INSTRUCTION_MODE_REPLACE";
+        };
+    };
+    requestType?: string;
+    userAgent?: string;
+    requestId?: string;
+}
+export declare const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli">;
+export declare function buildRequest(model: Model<"google-gemini-cli">, context: Context, projectId: string, options?: GoogleGeminiCliOptions, isAntigravity?: boolean): CloudCodeAssistRequest;

package/dist/types/providers/google-gemini-headers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Build a User-Agent string that identifies as Gemini CLI to unlock higher rate limits.
+ * Uses the same format as the official Gemini CLI (v0.35+):
+ * GeminiCLI/VERSION/MODEL (PLATFORM; ARCH; SURFACE)
+ */
+export declare const GEMINI_CLI_VERSION_ENV = "VIB_AI_GEMINI_CLI_VERSION";
+export declare const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
+export declare const DEFAULT_GEMINI_CLI_VERSION = "0.52.0";
+export declare function getGeminiCliUserAgent(modelId?: string): string;
+export declare const getGeminiCliHeaders: (modelId?: string) => {
+    "User-Agent": string;
+    "Client-Metadata": string;
+};
+/**
+ * Full Antigravity system instruction as observed in the real IDE binary.
+ * This is the complete prompt injected by the Antigravity language server,
+ * including BNF lexer definition for syntax highlighting, messaging system
+ * description, and reactive wakeup protocol.
+ *
+ * Wire-format fidelity note: The `%s` placeholders are literal in the real
+ * Antigravity IDE prompt. The Cloud Code Assist service either expands them
+ * server-side or the model handles them as-is. Preserved for byte-faithful
+ * emulation of the observed IDE wire format.
+ *
+ * Evidence: Disassembly of the Antigravity LS binary confirms this exact
+ * string is loaded and injected as the system instruction.
+ */
+export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION = "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.\nYou are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.\nThe USER will send you requests, which you must always prioritize addressing. Along with each USER request, we will attach additional metadata about their current state, such as what files they have open and where their cursor is.\nThis information may or may not be relevant to the coding task, it is up for you to decide.<lexer>\n  <config>\n    <name>BNF</name>\n    <alias>bnf</alias>\n    <filename>*.bnf</filename>\n    <mime_type>text/x-bnf</mime_type>\n  </config>\n  <rules>\n    <state name=\"root\">\n      <rule pattern=\"(&lt;)([ -;=?-~]+)(&gt;)\">\n        <bygroups>\n          <token type=\"Punctuation\"/>\n          <token type=\"NameClass\"/>\n          <token type=\"Punctuation\"/>\n        </bygroups>\n      </rule>\n      <rule pattern=\"::=\">\n        <token type=\"Operator\"/>\n      </rule>\n      <rule pattern=\"[^&lt;&gt;:]+\">\n        <token type=\"Text\"/>\n      </rule>\n      <rule pattern=\".\">\n        <token type=\"Text\"/>\n      </rule>\n    </state>\n  </rules>\n</lexer>You are connected to a messaging system where you may receive messages from: %s.\n\n## Receiving Messages\n\nYou receive messages automatically at the start of each invocation. All messages are delivered in full directly into your context \u2014 no manual retrieval is needed.\n\n## Reactive Wakeup (No Polling Needed)\n\nThe system automatically resumes your execution when:\n%s\n\nThis means you do **NOT** need to poll in a loop while waiting for messages or updates. After launching anything that performs work asynchronously, you may continue other work or simply stop by calling no more tools. The system will notify you when there is something to process.\n";
+/**
+ * Antigravity / Cloud Code Assist user agent.
+ *
+ * Disassembly-confirmed: getUserAgentName() @ 0x5ecb1dd loads "antigravity-ide"
+ * via LEA RDX, [RIP-0x284fc90] → 0x367b554 = "antigravity-ide"
+ *
+ * The LS sets HTTP headers via: fmt.Sprintf("User-Agent: %s", getUserAgentName())
+ * So the final header is: User-Agent: antigravity-ide
+ *
+ * -override_user_agent flag can override this (confirmed at 0x5ecbc37).
+ */
+export declare let getAntigravityUserAgent: () => string;
+export declare const getAntigravityRequestHeaders: () => {
+    "User-Agent": string;
+};