@aryee337/aery-ai 0.1.148 → 0.2.10

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

@@ -0,0 +1,43 @@
+import { type JsonValue } from "@bufbuild/protobuf";
+import type { CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, ToolResultMessage } from "../types";
+export declare const CURSOR_API_URL = "https://api2.cursor.sh";
+export declare const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+export interface CursorOptions extends StreamOptions {
+    customSystemPrompt?: string;
+    conversationId?: string;
+    execHandlers?: CursorExecHandlers;
+    onToolResult?: CursorToolResultHandler;
+}
+export declare const streamCursor: StreamFunction<"cursor-agent">;
+/** 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;
+}>;
+/**
+ * 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 active 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): string[];
+/** Exported for tests: decodes Cursor history blobs built from conversation messages. */
+export declare function buildCursorHistoryForTest(messages: Message[], activeUserMessageIndex?: number): {
+    rootPromptMessagesJson: unknown[];
+    turnUserMessagesJson: JsonValue[];
+    turnStepMessagesJson: JsonValue[][];
+};

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,24 @@
+/**
+ * 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";
+/**
+ * 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,81 @@
+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 {
+    /**
+     * 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;
+    };
+    projectId?: string;
+}
+export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, 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;
+                allowedFunctionNames?: 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-gemini-headers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 function getGeminiCliUserAgent(modelId?: string): string;
+export declare const getGeminiCliHeaders: (modelId?: string) => {
+    "User-Agent": string;
+    "Client-Metadata": string;
+};
+export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION: string;
+/**
+ * Antigravity / Cloud Code Assist user agent. Lives in its own file so discovery
+ * and usage code can read it without pulling the heavy google-gemini-cli provider
+ * (and its @google/genai → google-auth-library dependency chain) into the startup
+ * parse graph.
+ */
+export declare let getAntigravityUserAgent: () => string;

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

@@ -0,0 +1,171 @@
+/**
+ * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
+ */
+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";
+/**
+ * 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;
+    };
+}
+/**
+ * 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;
+/**
+ * Claude 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.).
+ *
+ * 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;
+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;
+    } | 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;
+}
+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,138 @@
+/**
+ * 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;
+    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;
+}
+/** Single SSE chunk's parsed JSON body. */
+export interface GenerateContentResponse {
+    candidates?: Candidate[];
+    usageMetadata?: UsageMetadata;
+    modelVersion?: string;
+    responseId?: string;
+    promptFeedback?: Record<string, unknown>;
+}

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;