@vib-rato/ai 0.16.0

package/src/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;
+};

package/src/providers/google-gemini-headers.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 const GEMINI_CLI_VERSION_ENV = "VIB_AI_GEMINI_CLI_VERSION";
+export const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
+export const DEFAULT_GEMINI_CLI_VERSION = "0.52.0";
+
+export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
+	const version =
+		process.env[GEMINI_CLI_VERSION_ENV] || process.env[LEGACY_GEMINI_CLI_VERSION_ENV] || DEFAULT_GEMINI_CLI_VERSION;
+	const platform = process.platform === "win32" ? "win32" : process.platform;
+	const arch = process.arch === "x64" ? "x64" : process.arch;
+	return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;
+}
+
+export const getGeminiCliHeaders = (modelId?: string) => ({
+	"User-Agent": getGeminiCliUserAgent(modelId),
+	"Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
+});
+
+/**
+ * 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 const ANTIGRAVITY_SYSTEM_INSTRUCTION = `You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.
+You 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.
+The 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.
+This information may or may not be relevant to the coding task, it is up for you to decide.<lexer>
+  <config>
+    <name>BNF</name>
+    <alias>bnf</alias>
+    <filename>*.bnf</filename>
+    <mime_type>text/x-bnf</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="(&lt;)([ -;=?-~]+)(&gt;)">
+        <bygroups>
+          <token type="Punctuation"/>
+          <token type="NameClass"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
+      <rule pattern="::=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[^&lt;&gt;:]+">
+        <token type="Text"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>You are connected to a messaging system where you may receive messages from: %s.
+
+## Receiving Messages
+
+You receive messages automatically at the start of each invocation. All messages are delivered in full directly into your context — no manual retrieval is needed.
+
+## Reactive Wakeup (No Polling Needed)
+
+The system automatically resumes your execution when:
+%s
+
+This 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.
+`;
+/**
+ * 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 let getAntigravityUserAgent = () => {
+	const override = process.env.PI_AI_ANTIGRAVITY_USER_AGENT;
+	const userAgent = override || "antigravity-ide";
+	getAntigravityUserAgent = () => userAgent;
+	return userAgent;
+};
+
+export const getAntigravityRequestHeaders = () => ({
+	"User-Agent": getAntigravityUserAgent(),
+});

package/src/providers/google-shared.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
+ */
+import type { ProviderSafetyStopAdapterInvocation } from "../adapter-internals/provider-safety-stop";
+import type { AssistantMessage, Context, FetchImpl, Model, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { normalizeSchemaForGoogle } from "../utils/schema";
+import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, Part } from "./google-types";
+export type { Content, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, ThinkingConfig, } from "./google-types";
+export { normalizeSchemaForGoogle };
+type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
+export declare const PROVIDER_SAFETY_STOP = "provider_safety_stop";
+export declare function isGoogleCandidateSafetyStopReason(reason: string): boolean;
+export declare function isGooglePromptSafetyStopReason(reason: string): boolean;
+export declare function getGooglePromptBlockReason(promptFeedback: {
+    blockReason?: unknown;
+} | undefined): string | undefined;
+/**
+ * Thinking level for Gemini 3 models. Mirrors Google's `ThinkingLevel` enum values.
+ * Defined here (not in any specific provider) so all Google providers can reference it
+ * without inducing a circular dependency.
+ */
+export type GoogleThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/**
+ * Sampling/thinking options shared by `streamGoogle` and `streamGoogleVertex`.
+ * `google-gemini-cli` uses a different transport and request shape — do not extend this for it.
+ */
+export interface GoogleSharedStreamOptions extends StreamOptions {
+    toolChoice?: "auto" | "none" | "any" | "required";
+    thinking?: {
+        enabled: boolean;
+        budgetTokens?: number;
+        level?: GoogleThinkingLevel;
+    };
+}
+/**
+ * Determines whether a streamed Gemini `Part` should be treated as "thinking".
+ *
+ * Protocol note (Gemini / Vertex AI thought signatures):
+ * - `thought: true` is the definitive marker for thinking content (thought summaries).
+ * - `thoughtSignature` is an encrypted representation of the model's internal thought process
+ *   used to preserve reasoning context across multi-turn interactions.
+ * - `thoughtSignature` can appear on ANY part type (text, functionCall, etc.) - it does NOT
+ *   indicate the part itself is thinking content.
+ * - For non-functionCall responses, the signature appears on the last part for context replay.
+ * - When persisting/replaying model outputs, signature-bearing parts must be preserved as-is;
+ *   do not merge/move signatures across parts.
+ *
+ * See: https://ai.google.dev/gemini-api/docs/thought-signatures
+ */
+export declare function isThinkingPart(part: Pick<Part, "thought" | "thoughtSignature">): boolean;
+/**
+ * Retain thought signatures during streaming.
+ *
+ * Some backends only send `thoughtSignature` on the first delta for a given part/block; later deltas may omit it.
+ * This helper preserves the last non-empty signature for the current block.
+ *
+ * Note: this does NOT merge or move signatures across distinct response parts. It only prevents
+ * a signature from being overwritten with `undefined` within the same streamed block.
+ */
+export declare function retainThoughtSignature(existing: string | undefined, incoming: string | undefined): string | undefined;
+/**
+ * Anthropic model models via Google APIs require explicit tool call IDs in function calls/responses.
+ */
+export declare function requiresToolCallId(modelId: string): boolean;
+/**
+ * Convert internal messages to Gemini Content[] format.
+ */
+export declare function convertMessages<T extends GoogleApiType>(model: Model<T>, context: Context): Content[];
+/**
+ * Convert tools to Gemini function declarations format.
+ *
+ * We prefer `parametersJsonSchema` (full JSON Schema: anyOf/oneOf/const/etc.).
+ *
+ * Anthropic model models via Cloud Code Assist require the legacy `parameters` field; the API
+ * translates it into Anthropic's `input_schema`. When using that path, we sanitize the
+ * schema to remove Google-unsupported JSON Schema keywords.
+ */
+export declare function convertTools(tools: Tool[], model: Model<"google-generative-ai" | "google-gemini-cli" | "google-vertex">): {
+    functionDeclarations: Record<string, unknown>[];
+}[] | undefined;
+/**
+ * Map tool choice string to Gemini FunctionCallingConfigMode.
+ */
+export declare function mapToolChoice(choice: string): FunctionCallingConfigMode;
+/**
+ * Map Gemini FinishReason to our StopReason.
+ */
+export declare function mapStopReason(reason: FinishReason): StopReason;
+/**
+ * Map string finish reason to our StopReason (for raw API responses).
+ */
+export declare function mapStopReasonString(reason: string): StopReason;
+export declare function nextToolCallId(name: string): string;
+/**
+ * Push the appropriate `text_end` / `thinking_end` event for the given block.
+ * Shared between the SDK-backed stream consumer and the gemini-cli SSE consumer so
+ * the end-of-block event shape stays in lockstep.
+ */
+export declare function pushBlockEndEvent(block: TextContent | ThinkingContent, contentIndex: number, output: AssistantMessage, stream: AssistantMessageEventStream): void;
+/**
+ * Push the three lifecycle events (`toolcall_start` / `toolcall_delta` / `toolcall_end`) for a
+ * fully-assembled `ToolCall`. Caller is responsible for appending the toolCall to `output.content`
+ * before invoking — this helper does not mutate `output.content`.
+ */
+export declare function pushToolCallEvents(toolCall: ToolCall, contentIndex: number, output: AssistantMessage, stream: AssistantMessageEventStream): void;
+/**
+ * Append a new text- or thinking-block to `output.content` and push the matching
+ * `text_start` / `thinking_start` event. `onBeforeStartEvent` lets the SSE consumer
+ * inject its `ensureStarted()` first-token side effect into the canonical event order.
+ */
+export declare function startTextOrThinkingBlock(isThinking: boolean, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent | ThinkingContent;
+/**
+ * Drives the chunked `generateContentStream` iterator into an `AssistantMessage` and
+ * the corresponding `AssistantMessageEventStream`. Shared between `streamGoogle` and
+ * `streamGoogleVertex` — every observable event order and stop-reason rule is preserved.
+ *
+ * The caller still owns: `output` construction, timing fields (`duration`/`ttft`),
+ * `rawRequestDump`, the `client.models.generateContentStream(params)` call itself,
+ * pushing `start`/`done`/`error` events, and the surrounding try/catch that translates
+ * thrown errors into `output.stopReason`/`errorMessage`.
+ *
+ * This helper handles: the chunk loop, currentBlock flush transitions, usage metadata
+ * decoding (`calculateCost` included), tool-call id collision avoidance, finish-reason
+ * mapping, and the abort/stop-reason post-checks that re-throw to bubble into the
+ * caller's catch.
+ */
+export declare function consumeGoogleStream<T extends GoogleApiType>(args: {
+    googleStream: AsyncIterable<GenerateContentResponse>;
+    output: AssistantMessage;
+    stream: AssistantMessageEventStream;
+    model: Model<T>;
+    options: {
+        signal?: AbortSignal;
+        fetch?: unknown;
+    } | undefined;
+    callerFetch?: unknown;
+    adapterInvocation?: ProviderSafetyStopAdapterInvocation;
+    /** Vertex preserves `textSignature` on streamed text deltas; google-generative-ai does not. */
+    retainTextSignature?: boolean;
+    onFirstToken?: () => void;
+}): Promise<void>;
+/**
+ * Build the `GenerateContentParameters` payload for the public Gemini API and Vertex AI.
+ * Both surfaces accept the same `GenerateContentConfig` shape — every numeric/string knob,
+ * tool-config, thinking-config, and system-instruction conversion is identical.
+ *
+ * `google-gemini-cli` is NOT routed through here: its `CloudCodeAssistRequest` body has a
+ * distinct top-level shape (project/request/requestType) and a different thinking-config
+ * placement on `generationConfig`.
+ */
+export declare function buildGoogleGenerateContentParams<T extends "google-generative-ai" | "google-vertex">(model: Model<T>, context: Context, options: GoogleSharedStreamOptions): GenerateContentParameters;
+/**
+ * Drive the `streamGoogle` / `streamGoogleVertex` event flow: build the assistant message,
+ * push start/done/error events, run `consumeGoogleStream`, and translate thrown errors into
+ * the canonical `error` event shape.
+ *
+ * Caller-supplied `prepare()` runs inside the try-block so any failure (missing project,
+ * bad auth, etc.) is funneled through the same error path as a streaming failure.
+ */
+export interface GoogleGenAIRequestPlan {
+    params: GenerateContentParameters;
+    url: string;
+    headers: Record<string, string>;
+    fetch?: FetchImpl;
+}
+export declare function streamGoogleGenAI<T extends "google-generative-ai" | "google-vertex">(args: {
+    model: Model<T>;
+    options: GoogleSharedStreamOptions | undefined;
+    api: T;
+    retainTextSignature?: boolean;
+    prepare: () => GoogleGenAIRequestPlan | Promise<GoogleGenAIRequestPlan>;
+}): AssistantMessageEventStream;
+/**
+ * Lift the SDK's `params.config` fields out of `config` and place them where the
+ * Gemini / Vertex AI REST API expects them on the request body. Mirrors the
+ * generateContentParametersTo{Mldev,Vertex} transformation in @google/genai
+ * for the subset of fields this codebase actually sets.
+ *
+ * `abortSignal` is intentionally dropped — the SDK propagates it via `fetch.signal`,
+ * which our caller already wires up through `options.signal`.
+ */
+export declare function paramsToWireBody(params: GenerateContentParameters): Record<string, unknown>;