jeopi-ai 16.2.13

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

@@ -0,0 +1,118 @@
+import type { Context, Model, ProviderSessionState, 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 {
+    /**
+     * Tool selection mode. String forms map directly to Gemini
+     * `FunctionCallingConfigMode`. The object form forces a single named tool —
+     * `mode: "ANY"` is wire-required when `allowedFunctionNames` is set.
+     */
+    toolChoice?: "auto" | "none" | "any" | {
+        mode: "ANY";
+        allowedFunctionNames: [string, ...string[]];
+    };
+    /**
+     * 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;
+        /**
+         * Explicit wire suppression when `enabled` is false. Cloud Code Assist
+         * re-applies the per-id baked server default when thinkingConfig is
+         * omitted, so models with `thinking.suppressWhenOff` must send
+         * `includeThoughts: false` plus a MINIMAL level (or zero budget).
+         */
+        suppress?: {
+            level: GoogleThinkingLevel;
+        } | {
+            budget: number;
+        };
+    };
+    /**
+     * Upstream wire model id override for collapsed effort-tier variants.
+     * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
+     */
+    requestModelId?: string;
+    projectId?: string;
+    /** Antigravity endpoint routing mode: "auto" (default with failover), "production", "sandbox". */
+    antigravityEndpointMode?: "auto" | "production" | "sandbox";
+    providerSessionState?: Map<string, ProviderSessionState>;
+}
+export interface AntigravityProviderSessionState extends ProviderSessionState {
+    lastGoodEndpoint?: string;
+    /**
+     * Per-conversation request-envelope identity that mirrors the real
+     * Antigravity client. `sessionId` is the signed-decimal session id;
+     * `agentId`/`trajectoryId` are UUIDs; `stepIndex` is the monotonic step
+     * counter; `lastExecutionId` is the prior response id echoed as
+     * `labels.last_execution_id`.
+     */
+    agentId?: string;
+    trajectoryId?: string;
+    sessionId?: string;
+    stepIndex?: number;
+    lastExecutionId?: string;
+}
+export declare function getAntigravityProviderSessionState(providerSessionState: Map<string, ProviderSessionState> | undefined): AntigravityProviderSessionState | undefined;
+export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "jeopi-catalog/wire/gemini-headers";
+interface ParsedGeminiCliCredentials {
+    accessToken: string;
+    projectId: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    email?: string;
+}
+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;
+                allowedFunctionNames?: string[];
+            };
+        };
+        labels?: Record<string, string>;
+    };
+    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-interactions.d.ts

@@ -0,0 +1,65 @@
+import type { Context, FetchImpl, Model, ProviderSessionState } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { type GoogleSharedStreamOptions } from "./google-shared";
+type GoogleInteractionsApi = "google-generative-ai" | "google-vertex";
+/** Provider session state storing the last Gemini Interactions response id. */
+export interface GoogleInteractionsProviderSessionState extends ProviderSessionState {
+    lastInteractionId?: string;
+}
+/** Conversation anchor for continuing an Interactions turn from a prior assistant response. */
+export interface InteractionAnchor {
+    id?: string;
+    messageIndex?: number;
+}
+/** Provider-specific URL, headers, and fetch implementation for an Interactions request. */
+export interface GoogleInteractionsPlan {
+    url: string;
+    headers: Record<string, string>;
+    fetch?: FetchImpl;
+}
+/**
+ * Streams Gemini Interactions API model-mode responses for direct Google and Vertex providers.
+ *
+ * `fallback`, when supplied, is the legacy `:streamGenerateContent` stream factory. It runs
+ * transparently — forwarding its events into this stream — when the Interactions attempt fails
+ * before any content is emitted with a signal that the model/endpoint does not support
+ * Interactions (HTTP 404/400). Provide it only for auto-selected Interactions requests so an
+ * explicit `useInteractionsApi: true` still surfaces failures.
+ */
+export declare function streamGoogleInteractions<T extends GoogleInteractionsApi>(args: {
+    model: Model<T>;
+    context: Context;
+    options: GoogleSharedStreamOptions | undefined;
+    api: T;
+    anchor: InteractionAnchor;
+    state: GoogleInteractionsProviderSessionState | undefined;
+    prepare: () => GoogleInteractionsPlan | Promise<GoogleInteractionsPlan>;
+    fallback?: () => AssistantMessageEventStream;
+}): AssistantMessageEventStream;
+/**
+ * Whether a model is served by the Gemini Interactions API. Interactions is a Gemini 3-era
+ * transport, so the catalog subset that supports it is Gemini 3.0+. Older Gemini and non-Gemini
+ * ids keep `:streamGenerateContent`, which covers the full catalog.
+ */
+export declare function modelSupportsInteractions(model: Pick<Model, "id">): boolean;
+/**
+ * Resolves whether a Google provider call should use Interactions and which lineage anchor to send.
+ *
+ * Precedence: explicit `useInteractionsApi: false` always wins (force generateContent); otherwise
+ * Interactions engages when explicitly requested, when continuing a stored interaction
+ * (`previousInteractionId`/assistant lineage/session state), or when `autoEligible` (the
+ * zero-config default for the capable model subset on the official endpoint). `auto` flags the
+ * last case for the caller — it is the only mode that wires up the generateContent fallback.
+ */
+export declare function resolveInteractionDispatch(args: {
+    context: Context;
+    options: GoogleSharedStreamOptions | undefined;
+    provider: string;
+    autoEligible: boolean;
+}): {
+    useInteractions: boolean;
+    auto: boolean;
+    anchor: InteractionAnchor;
+    state: GoogleInteractionsProviderSessionState | undefined;
+};
+export {};

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

@@ -0,0 +1,203 @@
+/**
+ * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
+ */
+import type { AssistantMessage, Context, FetchImpl, Model, ServiceTier, 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";
+/**
+ * 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 {
+    /**
+     * Tool selection mode. String forms map directly to Gemini
+     * `FunctionCallingConfigMode`. The object form forces a single named tool
+     * — `mode: "ANY"` is wire-required when `allowedFunctionNames` is set.
+     */
+    toolChoice?: "auto" | "none" | "any" | {
+        mode: "ANY";
+        allowedFunctionNames: [string, ...string[]];
+    };
+    thinking?: {
+        enabled: boolean;
+        budgetTokens?: number;
+        level?: GoogleThinkingLevel;
+    };
+    /** Gemini/Vertex serving tier (`flex`/`priority`); other values are omitted. */
+    serviceTier?: ServiceTier;
+    /**
+     * Continues a Gemini Interactions API conversation from a stored interaction.
+     * When set on the direct Google provider, the request uses `/interactions`
+     * with `previous_interaction_id` instead of the legacy generateContent stream.
+     */
+    previousInteractionId?: string;
+    /**
+     * Uses the Gemini Interactions API for direct Google requests, storing the
+     * returned interaction id on the assistant response for follow-up turns.
+     */
+    useInteractionsApi?: boolean;
+    /** Overrides Interactions API request storage; default is the API default (`true`). */
+    storeInteraction?: boolean;
+}
+/**
+ * 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;
+/**
+ * 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.).
+ *
+ * Claude 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;
+/**
+ * Bounded retries for the well-known Gemini "empty response" failure: a benign
+ * `finishReason: STOP` carrying only an empty/whitespace text part and no tool call.
+ * Shared by the public/Vertex `streamGoogleGenAI` path and the Cloud Code Assist
+ * (`google-gemini-cli`/`google-antigravity`) provider so both apply the same policy.
+ */
+export declare const MAX_EMPTY_STREAM_RETRIES = 2;
+export declare const EMPTY_STREAM_BASE_DELAY_MS = 500;
+/**
+ * Whether a completed Google assistant message carries content worth delivering.
+ *
+ * A tool call or any non-whitespace text counts as meaningful. An empty/whitespace-only
+ * text part — or thinking that never produced an answer — is the "empty response" failure:
+ * delivered as-is the agent loop has nothing to act on and silently halts, so the request
+ * must be retried instead of surfaced.
+ */
+export declare function hasMeaningfulGoogleContent(output: AssistantMessage): boolean;
+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: true, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): ThinkingContent;
+export declare function startTextOrThinkingBlock(isThinking: false, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent;
+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;
+    } | undefined;
+    /** 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;
+    /** Optional URL retried once when {@link url} returns 404 (regional Vertex endpoint missing a global-only model). */
+    fallbackUrl?: string;
+}
+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;

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

@@ -0,0 +1,155 @@
+/**
+ * Local mirror of the subset of `@google/genai` types this package consumes.
+ *
+ * Field shapes match Gemini / Vertex AI wire format 1:1. Enum-shaped values are
+ * modelled as string literal unions so they pass through `JSON.stringify` and
+ * `JSON.parse` unchanged.
+ *
+ * Keep this file in sync with the actual request/response surface of:
+ *   - `POST {generativelanguage,aiplatform}.googleapis.com/.../models/{model}:streamGenerateContent?alt=sse`
+ *   - The Cloud Code Assist endpoint used by `google-gemini-cli.ts`
+ */
+/** Mirror of `@google/genai`'s `FinishReason` string enum. */
+export type FinishReason = "FINISH_REASON_UNSPECIFIED" | "STOP" | "MAX_TOKENS" | "SAFETY" | "RECITATION" | "LANGUAGE" | "OTHER" | "BLOCKLIST" | "PROHIBITED_CONTENT" | "SPII" | "MALFORMED_FUNCTION_CALL" | "IMAGE_SAFETY" | "IMAGE_PROHIBITED_CONTENT" | "IMAGE_RECITATION" | "IMAGE_OTHER" | "UNEXPECTED_TOOL_CALL" | "NO_IMAGE";
+/** Mirror of `@google/genai`'s `FunctionCallingConfigMode` string enum. */
+export type FunctionCallingConfigMode = "MODE_UNSPECIFIED" | "AUTO" | "NONE" | "ANY" | "VALIDATED";
+/** Mirror of `@google/genai`'s `ThinkingLevel` string enum. */
+export type ThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/** Inline base64-encoded data part. */
+export interface InlineDataPart {
+    mimeType: string;
+    data: string;
+}
+/** Function call emitted by the model. */
+export interface FunctionCallPart {
+    name?: string;
+    args?: Record<string, unknown>;
+    id?: string;
+}
+/** Tool execution result fed back to the model. */
+export interface FunctionResponsePart {
+    name: string;
+    response: Record<string, unknown>;
+    parts?: Part[];
+    id?: string;
+}
+/**
+ * A single piece of a `Content` message. Mirrors the SDK's union by keeping
+ * every optional field — the model and the wire treat shape as discriminator.
+ */
+export interface Part {
+    text?: string;
+    thought?: boolean;
+    thoughtSignature?: string;
+    inlineData?: InlineDataPart;
+    functionCall?: FunctionCallPart;
+    functionResponse?: FunctionResponsePart;
+}
+/** Conversation turn. Roles: `"user"`, `"model"`, optionally absent for system instructions. */
+export interface Content {
+    role?: string;
+    parts?: Part[];
+}
+/** Thinking/reasoning configuration shared by Gemini 2.x and 3.x models. */
+export interface ThinkingConfig {
+    includeThoughts?: boolean;
+    thinkingBudget?: number;
+    thinkingLevel?: ThinkingLevel;
+}
+/** Function declaration entry inside `tools[].functionDeclarations`. */
+export interface FunctionDeclaration {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    parametersJsonSchema?: Record<string, unknown>;
+}
+/** Tool group as accepted at the request top level. */
+export interface ToolDeclaration {
+    functionDeclarations: Record<string, unknown>[];
+}
+/** Tool selection mode container. */
+export interface ToolConfig {
+    functionCallingConfig?: {
+        mode: FunctionCallingConfigMode;
+        allowedFunctionNames?: string[];
+    };
+}
+/**
+ * Generation/sampling and request-shape options passed via the SDK's `config`.
+ *
+ * Fields that the wire format places at the request body root (systemInstruction,
+ * tools, toolConfig, safetySettings, cachedContent) live here too — the
+ * transformer in `google-shared.ts` lifts them out when serializing.
+ */
+export interface GenerateContentConfig {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    topK?: number;
+    candidateCount?: number;
+    stopSequences?: string[];
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    seed?: number;
+    responseMimeType?: string;
+    responseSchema?: Record<string, unknown>;
+    responseJsonSchema?: Record<string, unknown>;
+    responseModalities?: string[];
+    systemInstruction?: Content | {
+        role?: string;
+        parts: {
+            text: string;
+        }[];
+    };
+    tools?: ToolDeclaration[];
+    toolConfig?: ToolConfig;
+    safetySettings?: Array<Record<string, unknown>>;
+    cachedContent?: string;
+    thinkingConfig?: ThinkingConfig;
+    /**
+     * Gemini/Vertex serving tier. Serialized to the request body root as
+     * `serviceTier` (camelCase) by the transformer in `google-shared.ts`.
+     */
+    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority";
+    abortSignal?: AbortSignal;
+}
+/** Top-level argument to `generateContentStream`. */
+export interface GenerateContentParameters {
+    model: string;
+    contents: Content[];
+    config?: GenerateContentConfig;
+}
+/** Per-stream candidate envelope. */
+export interface Candidate {
+    content?: Content;
+    finishReason?: FinishReason;
+    index?: number;
+}
+/** Cumulative token accounting attached to the trailing chunk. */
+export interface UsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    thoughtsTokenCount?: number;
+    totalTokenCount?: number;
+    cachedContentTokenCount?: number;
+}
+/** Prompt-level safety feedback; `blockReason` is set (with no candidates) when the prompt is blocked. */
+export interface PromptFeedback {
+    blockReason?: string;
+    blockReasonMessage?: string;
+    [key: string]: unknown;
+}
+/** Single SSE chunk's parsed JSON body. */
+export interface GenerateContentResponse {
+    candidates?: Candidate[];
+    usageMetadata?: UsageMetadata;
+    modelVersion?: string;
+    responseId?: string;
+    promptFeedback?: PromptFeedback;
+    /** In-band stream failure (quota, internal error) delivered as a final JSON event. */
+    error?: {
+        code?: number;
+        message?: string;
+        status?: string;
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { StreamFunction } from "../types";
+import { type GoogleSharedStreamOptions } from "./google-shared";
+export interface GoogleVertexOptions extends GoogleSharedStreamOptions {
+    project?: string;
+    location?: string;
+}
+export declare const streamGoogleVertex: StreamFunction<"google-vertex">;

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

@@ -0,0 +1,4 @@
+import type { StreamFunction } from "../types";
+import { type GoogleSharedStreamOptions } from "./google-shared";
+export type GoogleOptions = GoogleSharedStreamOptions;
+export declare const streamGoogle: StreamFunction<"google-generative-ai">;

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

@@ -0,0 +1 @@
+export declare function compactGrammarDefinition(syntax: "lark" | "regex", definition: string): string;

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

@@ -0,0 +1,27 @@
+/**
+ * Kimi Code provider - wraps OpenAI or Anthropic API based on format setting.
+ *
+ * Kimi offers both OpenAI-compatible and Anthropic-compatible APIs:
+ * - OpenAI: https://api.kimi.com/coding/v1/chat/completions
+ * - Anthropic: https://api.kimi.com/coding/v1/messages
+ *
+ * The Anthropic API is generally more stable and recommended.
+ * Note: Kimi calculates TPM rate limits based on max_tokens, not actual output.
+ */
+import type { Api, Context, Model } from "../types";
+import type { AssistantMessageEventStream } from "../utils/event-stream";
+import { type OpenAIAnthropicApiFormat, type OpenAIAnthropicShimOptions } from "./openai-anthropic-shim";
+export type KimiApiFormat = OpenAIAnthropicApiFormat;
+export interface KimiOptions extends OpenAIAnthropicShimOptions {
+    /** API format: "openai" or "anthropic". Default: "anthropic" */
+    format?: KimiApiFormat;
+}
+/**
+ * Stream from Kimi Code, routing to either OpenAI or Anthropic API based on format.
+ * Returns synchronously like other providers - async header fetching happens internally.
+ */
+export declare function streamKimi(model: Model<"openai-completions">, context: Context, options?: KimiOptions): AssistantMessageEventStream;
+/**
+ * Check if a model is a Kimi Code model.
+ */
+export declare function isKimiModel(model: Model<Api>): boolean;