@juspay/neurolink 8.26.0 → 8.27.0

package/dist/lib/providers/sagemaker/language-model.d.ts

@@ -131,7 +131,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "llama" | "claude" | "jumpstart" | "custom" | undefined;
+        modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
         region: string;
     };
     /**
@@ -178,7 +178,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "llama" | "claude" | "jumpstart" | "custom" | undefined;
+        modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
         region: string;
     };
 }

package/dist/lib/types/analytics.d.ts

@@ -10,6 +10,10 @@ export type TokenUsage = {
     input: number;
     output: number;
     total: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    reasoning?: number;
+    cacheSavingsPercent?: number;
 };
 /**
  * Error info type for analytics

package/dist/lib/types/cli.d.ts

@@ -60,6 +60,14 @@ export type GenerateCommandArgs = BaseCommandArgs & {
     maxSteps?: number;
     /** Output file */
     output?: string;
+    /** Enable extended thinking/reasoning */
+    thinking?: boolean;
+    /** Token budget for thinking */
+    thinkingBudget?: number;
+    /** Thinking level for extended reasoning */
+    thinkingLevel?: "minimal" | "low" | "medium" | "high";
+    /** Vertex AI region */
+    region?: string;
 };
 /**
  * Stream command arguments
@@ -79,6 +87,14 @@ export type StreamCommandArgs = BaseCommandArgs & {
     maxTokens?: number;
     /** Disable tools */
     disableTools?: boolean;
+    /** Enable extended thinking/reasoning */
+    thinking?: boolean;
+    /** Token budget for thinking */
+    thinkingBudget?: number;
+    /** Thinking level for extended reasoning */
+    thinkingLevel?: "minimal" | "low" | "medium" | "high";
+    /** Vertex AI region */
+    region?: string;
 };
 /**
  * Batch command arguments

package/dist/lib/types/conversation.d.ts

@@ -1,6 +1,36 @@
 /**
  * Conversation Memory Types for NeuroLink
  * Provides type-safe conversation storage and context management
+ *
+ * ## Timestamp Conventions
+ *
+ * NeuroLink uses two timestamp formats throughout the conversation system:
+ *
+ * ### Unix Milliseconds (number)
+ * Used for internal storage, event timestamps, and performance-critical operations.
+ * - `SessionMemory.createdAt` - Session creation time as Unix epoch milliseconds
+ * - `SessionMemory.lastActivity` - Last activity time as Unix epoch milliseconds
+ * - `SessionMemory.lastCountedAt` - Token count timestamp as Unix epoch milliseconds
+ * - `ConversationMemoryEvents.*.timestamp` - Event timestamps as Unix epoch milliseconds
+ * - `ChatMessage.metadata.timestamp` - Optional numeric timestamp for internal tracking
+ *
+ * Example: `1735689600000` represents January 1, 2025, 00:00:00 UTC
+ *
+ * ### ISO 8601 String (string)
+ * Used for human-readable fields and API responses.
+ * - `ChatMessage.timestamp` - Message timestamp as ISO 8601 string
+ * - `ConversationBase.createdAt` - Conversation creation as ISO 8601 string
+ * - `ConversationBase.updatedAt` - Last update as ISO 8601 string
+ * - `ConversationSummary.firstMessage.timestamp` - Message preview timestamp
+ * - `ConversationSummary.lastMessage.timestamp` - Message preview timestamp
+ *
+ * Example: `"2025-01-01T00:00:00.000Z"`
+ *
+ * ### Conversion Guidelines
+ * - Unix ms to ISO: `new Date(unixMs).toISOString()`
+ * - ISO to Unix ms: `new Date(isoString).getTime()`
+ * - Current time (Unix ms): `Date.now()`
+ * - Current time (ISO): `new Date().toISOString()`
  */
 import type { Mem0Config } from "../memory/mem0Initializer.js";
 /**
@@ -45,9 +75,17 @@ export type SessionMemory = {
     title?: string;
     /** Direct message storage - ready for immediate AI consumption */
     messages: ChatMessage[];
-    /** When this session was created */
+    /**
+     * When this session was created.
+     * Format: Unix epoch milliseconds (number).
+     * Example: 1735689600000 for January 1, 2025, 00:00:00 UTC.
+     */
     createdAt: number;
-    /** When this session was last active */
+    /**
+     * When this session was last active.
+     * Format: Unix epoch milliseconds (number).
+     * Updated on every message addition or session interaction.
+     */
     lastActivity: number;
     /** Pointer to last summarized message ID (NEW - for token-based memory) */
     summarizedUpToMessageId?: string;
@@ -88,7 +126,12 @@ export type ChatMessage = {
     role: "user" | "assistant" | "system" | "tool_call" | "tool_result";
     /** Content of the message */
     content: string;
-    /** Timestamp (ISO string) */
+    /**
+     * Message timestamp.
+     * Format: ISO 8601 string (e.g., "2025-01-01T12:30:00.000Z").
+     * Optional - may be omitted for system-generated messages.
+     * Use `metadata.timestamp` for numeric Unix ms representation.
+     */
     timestamp?: string;
     /** Tool name (optional) - for tool_call/tool_result messages */
     tool?: string;
@@ -112,6 +155,27 @@ export type ChatMessage = {
         summarizesTo?: string;
         /** Was this message truncated due to token limits? */
         truncated?: boolean;
+        /** Source of the message (e.g., provider name, user input) */
+        source?: string;
+        /** Language of the message content */
+        language?: string;
+        /** Confidence score for AI-generated content */
+        confidence?: number;
+        /**
+         * Numeric timestamp for internal tracking and efficient comparisons.
+         * Format: Unix epoch milliseconds (number).
+         * Complements the ISO string `ChatMessage.timestamp` field.
+         * Use this for sorting, filtering, and performance-critical operations.
+         */
+        timestamp?: number;
+        /** Model used to generate this message */
+        modelUsed?: string;
+        /** Unique signature identifying thought/reasoning patterns */
+        thoughtSignature?: string;
+        /** Hash of the thinking/reasoning content for deduplication */
+        thoughtHash?: string;
+        /** Whether extended thinking was used for this message */
+        thinkingExpanded?: boolean;
     };
 };
 /**
@@ -123,10 +187,14 @@ export type { MessageContent, MultimodalChatMessage } from "./multimodal.js";
  * Events emitted by conversation memory system
  */
 export type ConversationMemoryEvents = {
-    /** Emitted when a new session is created */
+    /**
+     * Emitted when a new session is created.
+     * The timestamp field is Unix epoch milliseconds.
+     */
     "session:created": {
         sessionId: string;
         userId?: string;
+        /** Event timestamp as Unix epoch milliseconds */
         timestamp: number;
     };
     /** Emitted when a conversation turn is stored */

package/dist/lib/types/conversation.js

@@ -1,6 +1,36 @@
 /**
  * Conversation Memory Types for NeuroLink
  * Provides type-safe conversation storage and context management
+ *
+ * ## Timestamp Conventions
+ *
+ * NeuroLink uses two timestamp formats throughout the conversation system:
+ *
+ * ### Unix Milliseconds (number)
+ * Used for internal storage, event timestamps, and performance-critical operations.
+ * - `SessionMemory.createdAt` - Session creation time as Unix epoch milliseconds
+ * - `SessionMemory.lastActivity` - Last activity time as Unix epoch milliseconds
+ * - `SessionMemory.lastCountedAt` - Token count timestamp as Unix epoch milliseconds
+ * - `ConversationMemoryEvents.*.timestamp` - Event timestamps as Unix epoch milliseconds
+ * - `ChatMessage.metadata.timestamp` - Optional numeric timestamp for internal tracking
+ *
+ * Example: `1735689600000` represents January 1, 2025, 00:00:00 UTC
+ *
+ * ### ISO 8601 String (string)
+ * Used for human-readable fields and API responses.
+ * - `ChatMessage.timestamp` - Message timestamp as ISO 8601 string
+ * - `ConversationBase.createdAt` - Conversation creation as ISO 8601 string
+ * - `ConversationBase.updatedAt` - Last update as ISO 8601 string
+ * - `ConversationSummary.firstMessage.timestamp` - Message preview timestamp
+ * - `ConversationSummary.lastMessage.timestamp` - Message preview timestamp
+ *
+ * Example: `"2025-01-01T00:00:00.000Z"`
+ *
+ * ### Conversion Guidelines
+ * - Unix ms to ISO: `new Date(unixMs).toISOString()`
+ * - ISO to Unix ms: `new Date(isoString).getTime()`
+ * - Current time (Unix ms): `Date.now()`
+ * - Current time (ISO): `new Date().toISOString()`
  */
 /**
  * Error types specific to conversation memory

package/dist/lib/types/generateTypes.d.ts

@@ -120,6 +120,54 @@ export type GenerateOptions = {
      * ```
      */
     tts?: TTSOptions;
+    /**
+     * Thinking/reasoning configuration for extended thinking models
+     *
+     * Enables extended thinking capabilities for supported models.
+     *
+     * **Gemini 3 Models** (gemini-3-pro-preview, gemini-3-flash-preview):
+     * Use `thinkingLevel` to control reasoning depth:
+     * - `minimal` - Near-zero thinking (Flash only)
+     * - `low` - Fast reasoning for simple tasks
+     * - `medium` - Balanced reasoning/latency
+     * - `high` - Maximum reasoning depth (default for Pro)
+     *
+     * **Anthropic Claude** (claude-3-7-sonnet, etc.):
+     * Use `budgetTokens` to set token budget for thinking.
+     *
+     * @example Gemini 3 with thinking level
+     * ```typescript
+     * const result = await neurolink.generate({
+     *   input: { text: "Solve this complex problem..." },
+     *   provider: "google-ai",
+     *   model: "gemini-3-pro-preview",
+     *   thinkingConfig: {
+     *     thinkingLevel: "high"
+     *   }
+     * });
+     * ```
+     *
+     * @example Anthropic with budget tokens
+     * ```typescript
+     * const result = await neurolink.generate({
+     *   input: { text: "Solve this complex math problem..." },
+     *   provider: "anthropic",
+     *   model: "claude-3-7-sonnet-20250219",
+     *   thinkingConfig: {
+     *     enabled: true,
+     *     budgetTokens: 10000
+     *   }
+     * });
+     * ```
+     */
+    thinkingConfig?: {
+        enabled?: boolean;
+        type?: "enabled" | "disabled";
+        /** Token budget for thinking (Anthropic models) */
+        budgetTokens?: number;
+        /** Thinking level for Gemini 3 models: minimal, low, medium, high */
+        thinkingLevel?: "minimal" | "low" | "medium" | "high";
+    };
     provider?: AIProviderName | string;
     model?: string;
     region?: string;
@@ -408,6 +456,93 @@ export type TextGenerationOptions = {
         includeHeaders?: boolean;
     };
     enableSummarization?: boolean;
+    /**
+     * ## Extended Thinking Options
+     *
+     * NeuroLink provides multiple ways to configure extended thinking/reasoning.
+     * These options interact as follows:
+     *
+     * ### Option Hierarchy (Priority: thinkingConfig > individual options)
+     *
+     * 1. **`thinkingConfig`** (recommended) - Full configuration object, highest priority
+     * 2. **`thinking`**, **`thinkingBudget`**, **`thinkingLevel`** - Simplified CLI-friendly options
+     *
+     * When both are provided, `thinkingConfig` takes precedence. The simplified options
+     * are automatically merged into `thinkingConfig` internally.
+     *
+     * ### Provider-Specific Behavior
+     *
+     * **Anthropic Claude (claude-3-7-sonnet, etc.):**
+     * - Use `thinkingConfig.budgetTokens` or `thinkingBudget`
+     * - Range: 5000-100000 tokens
+     * - `thinkingLevel` is ignored for Anthropic
+     *
+     * **Google Gemini 3 (gemini-3-pro-preview, gemini-3-flash-preview):**
+     * - Use `thinkingConfig.thinkingLevel` or `thinkingLevel`
+     * - Levels: minimal, low, medium, high
+     * - `budgetTokens` is ignored for Gemini (uses level-based allocation)
+     *
+     * ### Option Compatibility Matrix
+     *
+     * | Option         | Anthropic | Gemini 3 | Other Providers |
+     * |----------------|-----------|----------|-----------------|
+     * | thinking       | Yes       | Yes      | Ignored         |
+     * | thinkingBudget | Yes       | Ignored  | Ignored         |
+     * | thinkingLevel  | Ignored   | Yes      | Ignored         |
+     * | thinkingConfig | Yes       | Yes      | Ignored         |
+     *
+     * ### Examples
+     *
+     * ```typescript
+     * // Simplified (CLI-friendly) - Anthropic
+     * { thinking: true, thinkingBudget: 10000 }
+     *
+     * // Simplified (CLI-friendly) - Gemini 3
+     * { thinking: true, thinkingLevel: "high" }
+     *
+     * // Full config (recommended for SDK)
+     * { thinkingConfig: { enabled: true, budgetTokens: 10000 } } // Anthropic
+     * { thinkingConfig: { thinkingLevel: "high" } }              // Gemini 3
+     * ```
+     */
+    /**
+     * Enable extended thinking capability (simplified option).
+     * Equivalent to `thinkingConfig.enabled = true`.
+     * Works with both Anthropic and Gemini 3 models.
+     */
+    thinking?: boolean;
+    /**
+     * Token budget for thinking (Anthropic models only).
+     * Equivalent to `thinkingConfig.budgetTokens`.
+     * Range: 5000-100000 tokens. Ignored for Gemini models.
+     */
+    thinkingBudget?: number;
+    /**
+     * Thinking level for Gemini 3 models only.
+     * Equivalent to `thinkingConfig.thinkingLevel`.
+     * - `minimal` - Near-zero thinking (Flash only)
+     * - `low` - Light reasoning
+     * - `medium` - Balanced reasoning/latency
+     * - `high` - Deep reasoning (Pro default)
+     * Ignored for Anthropic models.
+     */
+    thinkingLevel?: "minimal" | "low" | "medium" | "high";
+    /**
+     * Full thinking/reasoning configuration (recommended for SDK usage).
+     * Takes precedence over simplified options (thinking, thinkingBudget, thinkingLevel).
+     *
+     * @see Above documentation for provider-specific behavior and option compatibility.
+     */
+    thinkingConfig?: {
+        /** Enable extended thinking. Default: false */
+        enabled?: boolean;
+        /** Explicit enable/disable type. Alternative to `enabled` boolean. */
+        type?: "enabled" | "disabled";
+        /** Token budget for thinking (Anthropic: 5000-100000). Ignored for Gemini. */
+        budgetTokens?: number;
+        /** Thinking level (Gemini 3: minimal|low|medium|high). Ignored for Anthropic. */
+        thinkingLevel?: "minimal" | "low" | "medium" | "high";
+    };
 };
 /**
  * Text generation result (consolidated from core types)

package/dist/lib/types/groundingTypes.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Enhanced grounding metadata types for web search and source attribution.
+ *
+ * This module provides type definitions for grounding AI responses with
+ * web search results and source attribution. Grounding helps ensure AI
+ * responses are backed by verifiable sources and provides transparency
+ * about where information originates.
+ *
+ * @module groundingTypes
+ */
+/**
+ * Represents a grounding source with enhanced metadata for search results.
+ * Used when grounding responses with web search or retrieval results to
+ * provide detailed information about each source that supports the AI response.
+ *
+ * @example
+ * const source: EnhancedGroundingSource = {
+ *   uri: "https://docs.example.com/api-reference",
+ *   title: "API Reference Documentation",
+ *   domain: "docs.example.com",
+ *   confidenceScore: 0.95,
+ *   isPrimary: true,
+ *   chunkIndex: 0
+ * };
+ */
+export type EnhancedGroundingSource = {
+    /** The full URI/URL of the source document */
+    uri: string;
+    /** The title of the source document or web page */
+    title: string;
+    /** The domain name extracted from the URI (e.g., "example.com") */
+    domain: string;
+    /** Confidence score (0-1) indicating how well this source supports the response */
+    confidenceScore?: number;
+    /** Whether this is a primary source for the grounded response */
+    isPrimary?: boolean;
+    /** Index of the chunk within the source document that was used */
+    chunkIndex?: number;
+};
+/**
+ * Represents the support relationship between a text segment and a source.
+ * Links a specific source (by index) to the segment it supports with a
+ * confidence score indicating the strength of the attribution.
+ *
+ * @example
+ * const support: SegmentSupport = {
+ *   sourceIndex: 0,  // References first source in the sources array
+ *   confidence: 0.92
+ * };
+ */
+export type SegmentSupport = {
+    /** Index into the sources array identifying which source supports this segment */
+    sourceIndex: number;
+    /** Confidence score (0-1) for how strongly this source supports the segment */
+    confidence: number;
+};
+/**
+ * Represents attribution information for a specific segment of the AI response.
+ * Maps portions of the generated text to their supporting sources, enabling
+ * fine-grained source attribution throughout the response.
+ *
+ * @example
+ * const attribution: SegmentAttribution = {
+ *   text: "The API supports RESTful operations",
+ *   startIndex: 0,
+ *   endIndex: 35,
+ *   partIndex: 0,
+ *   supportingSources: [
+ *     { sourceIndex: 0, confidence: 0.95 },
+ *     { sourceIndex: 2, confidence: 0.78 }
+ *   ]
+ * };
+ */
+export type SegmentAttribution = {
+    /** The actual text content of this segment from the response */
+    text: string;
+    /** Starting character index of this segment in the full response text */
+    startIndex: number;
+    /** Ending character index of this segment in the full response text */
+    endIndex: number;
+    /** Index of the response part this segment belongs to (for multi-part responses) */
+    partIndex: number;
+    /** Array of sources that support this segment with their confidence scores */
+    supportingSources: SegmentSupport[];
+};
+/**
+ * Represents a search result returned from web search grounding.
+ * Contains the essential information from a web search result that
+ * can be used to ground and verify AI responses.
+ *
+ * @example
+ * const result: EnhancedSearchResult = {
+ *   uri: "https://blog.example.com/best-practices",
+ *   title: "Best Practices Guide",
+ *   snippet: "This guide covers the essential best practices for..."
+ * };
+ */
+export type EnhancedSearchResult = {
+    /** The full URI/URL of the search result */
+    uri: string;
+    /** The title of the search result page */
+    title: string;
+    /** Optional text snippet from the search result showing relevant content */
+    snippet?: string;
+};
+/**
+ * Comprehensive grounding metadata containing all information about how
+ * an AI response is grounded in external sources. This is the primary
+ * type used to represent the complete grounding context for a response.
+ *
+ * @example
+ * const metadata: EnhancedGroundingMetadata = {
+ *   query: "What are the system requirements?",
+ *   webSearchQueries: ["system requirements documentation"],
+ *   searchResults: [
+ *     { uri: "https://docs.example.com/requirements", title: "Requirements" }
+ *   ],
+ *   sources: [
+ *     { uri: "https://docs.example.com/requirements", title: "Requirements", domain: "docs.example.com" }
+ *   ],
+ *   averageConfidence: 0.89,
+ *   grounded: true
+ * };
+ */
+export type EnhancedGroundingMetadata = {
+    /** The original user query that triggered the grounded response */
+    query: string;
+    /** Array of search queries used to find grounding sources */
+    webSearchQueries?: string[];
+    /** Array of search results returned from web search */
+    searchResults: EnhancedSearchResult[];
+    /** Fine-grained attributions mapping response segments to sources */
+    segmentAttributions?: SegmentAttribution[];
+    /** Array of all sources used to ground the response */
+    sources: EnhancedGroundingSource[];
+    /** Average confidence score across all grounding attributions (0-1) */
+    averageConfidence?: number;
+    /** Whether the response is successfully grounded in sources */
+    grounded: boolean;
+};
+/**
+ * Represents a grounding chunk from raw provider responses.
+ * This is the low-level representation of a grounding source chunk
+ * as returned directly from AI providers like Google Vertex AI.
+ *
+ * @example
+ * const chunk: GroundingChunk = {
+ *   web: {
+ *     uri: "https://example.com/article",
+ *     title: "Relevant Article"
+ *   },
+ *   confidenceScore: 0.87
+ * };
+ */
+export type GroundingChunk = {
+    /** Web source information for this grounding chunk */
+    web?: {
+        /** The URI of the web source */
+        uri?: string;
+        /** The title of the web source */
+        title?: string;
+    };
+    /** Confidence score for this grounding chunk (0-1) */
+    confidenceScore?: number;
+};
+/**
+ * Represents grounding support information from raw provider responses.
+ * Contains segment information and links to the grounding chunks that
+ * support that segment, as returned directly from AI providers.
+ *
+ * @example
+ * const support: GroundingSupport = {
+ *   segment: {
+ *     text: "The feature was released in 2024",
+ *     startIndex: 0,
+ *     endIndex: 32,
+ *     partIndex: 0
+ *   },
+ *   groundingChunkIndices: [0, 1],
+ *   confidenceScores: [0.92, 0.85]
+ * };
+ */
+export type GroundingSupport = {
+    /** The text segment that is being grounded */
+    segment?: {
+        /** The text content of the segment */
+        text?: string;
+        /** Starting character index in the response */
+        startIndex?: number;
+        /** Ending character index in the response */
+        endIndex?: number;
+        /** Index of the response part this segment belongs to */
+        partIndex?: number;
+    };
+    /** Indices into the groundingChunks array that support this segment */
+    groundingChunkIndices?: number[];
+    /** Confidence scores corresponding to each grounding chunk index */
+    confidenceScores?: number[];
+};
+/**
+ * Raw grounding metadata as returned directly from AI providers.
+ * This is the unprocessed format that gets transformed into
+ * EnhancedGroundingMetadata for consistent consumption across the SDK.
+ *
+ * @example
+ * const rawMetadata: RawGroundingMetadata = {
+ *   webSearchQueries: ["neurolink documentation"],
+ *   searchEntryPoint: {
+ *     renderedContent: "<div>Search results widget HTML</div>"
+ *   },
+ *   groundingChunks: [
+ *     { web: { uri: "https://docs.neurolink.dev", title: "NeuroLink Docs" } }
+ *   ],
+ *   groundingSupports: [
+ *     { segment: { text: "NeuroLink is..." }, groundingChunkIndices: [0] }
+ *   ]
+ * };
+ */
+export type RawGroundingMetadata = {
+    /** Array of search queries used by the provider for web grounding */
+    webSearchQueries?: string[];
+    /** Search entry point with rendered HTML content for display */
+    searchEntryPoint?: {
+        /** HTML content that can be rendered to show search results */
+        renderedContent?: string;
+    };
+    /** Array of grounding chunks from the provider */
+    groundingChunks?: GroundingChunk[];
+    /** Array of grounding support information linking segments to chunks */
+    groundingSupports?: GroundingSupport[];
+};

package/dist/lib/types/groundingTypes.js

@@ -0,0 +1,12 @@
+/**
+ * Enhanced grounding metadata types for web search and source attribution.
+ *
+ * This module provides type definitions for grounding AI responses with
+ * web search results and source attribution. Grounding helps ensure AI
+ * responses are backed by verifiable sources and provides transparency
+ * about where information originates.
+ *
+ * @module groundingTypes
+ */
+export {};
+//# sourceMappingURL=groundingTypes.js.map

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

@@ -432,6 +432,29 @@ export type GenAILiveSession = {
     }) => Promise<void> | void;
     close?: (code?: number, reason?: string) => Promise<void> | void;
 };
+/**
+ * Google AI generateContentStream response chunk
+ */
+export type GenAIStreamChunk = {
+    text?: string;
+    functionCalls?: Array<{
+        name: string;
+        args: Record<string, unknown>;
+    }>;
+};
+/**
+ * Google AI models API interface
+ */
+export type GenAIModelsAPI = {
+    generateContentStream: (params: {
+        model: string;
+        contents: Array<{
+            role: string;
+            parts: unknown[];
+        }>;
+        config?: Record<string, unknown>;
+    }) => Promise<AsyncIterable<GenAIStreamChunk>>;
+};
 /**
  * Google AI client interface
  */
@@ -439,12 +462,18 @@ export type GenAIClient = {
     live: {
         connect: (config: LiveConnectConfig) => Promise<GenAILiveSession>;
     };
+    models: GenAIModelsAPI;
 };
 /**
  * Google GenAI constructor type
+ * Supports both API key (Google AI Studio) and Vertex AI configurations
  */
 export type GoogleGenAIClass = new (cfg: {
     apiKey: string;
+} | {
+    vertexai: boolean;
+    project: string;
+    location: string;
 }) => GenAIClient;
 /**
  * OpenAI-compatible models endpoint response structure