@memberjunction/ai-vertex 2.128.0 → 2.130.0

package/dist/models/vertexLLM.d.ts

@@ -1,63 +1,118 @@
-import { BaseLLM, ChatParams, ChatResult, ClassifyParams, ClassifyResult, SummarizeParams, SummarizeResult } from '@memberjunction/ai';
-import { VertexAI } from '@google-cloud/vertexai';
-export declare class VertexLLM extends BaseLLM {
-    private _client;
-    private _projectId;
-    private _location;
-    constructor(apiKey: string, projectId: string, location?: string);
-    get Client(): VertexAI;
-    /**
-     * Google Vertex AI supports streaming
-     */
-    get SupportsStreaming(): boolean;
-    /**
-     * Implementation of non-streaming chat completion for Google Vertex AI
-     */
-    protected nonStreamingChatCompletion(params: ChatParams): Promise<ChatResult>;
-    /**
-     * Create a streaming request for Vertex AI
-     */
-    protected createStreamingRequest(params: ChatParams): Promise<any>;
-    /**
-     * Process a streaming chunk from Vertex AI
-     */
-    protected processStreamingChunk(chunk: any): {
-        content: string;
-        finishReason?: string;
-        usage?: any;
-    };
-    /**
-     * Create the final response from streaming results for Vertex AI
-     */
-    protected finalizeStreamingResponse(accumulatedContent: string | null | undefined, lastChunk: any | null | undefined, usage: any | null | undefined): ChatResult;
-    /**
-     * Not implemented yet
-     */
-    SummarizeText(params: SummarizeParams): Promise<SummarizeResult>;
-    /**
-     * Not implemented yet
-     */
-    ClassifyText(params: ClassifyParams): Promise<ClassifyResult>;
-    /**
-     * Map MemberJunction ChatParams to Vertex-specific params
-     */
-    private mapToVertexParams;
-    /**
-     * Convert MemberJunction chat messages to Vertex-compatible messages
-     */
-    private convertToVertexMessages;
+import { GeminiLLM } from '@memberjunction/ai-gemini';
+import { GoogleGenAI } from '@google/genai';
+/**
+ * Credentials format for Vertex AI authentication
+ *
+ * This interface supports four authentication methods:
+ * 1. Application Default Credentials (ADC) - Just provide project and location
+ * 2. Service Account JSON String - Provide serviceAccountJson with full JSON as string
+ * 3. Service Account JSON Inline - Provide full service account fields directly
+ * 4. Key File Path - Provide path to service account JSON file
+ */
+export interface VertexAICredentials {
+    /** GCP Project ID (required) */
+    project: string;
+    /** GCP Location/Region (default: 'us-central1') */
+    location?: string;
+    serviceAccountJson?: string;
+    type?: 'service_account';
+    project_id?: string;
+    private_key_id?: string;
+    private_key?: string;
+    client_email?: string;
+    client_id?: string;
+    auth_uri?: string;
+    token_uri?: string;
+    auth_provider_x509_cert_url?: string;
+    client_x509_cert_url?: string;
+    keyFilePath?: string;
+}
+/**
+ * VertexLLM - Google Vertex AI implementation
+ *
+ * Extends GeminiLLM and reuses all its logic (chat, streaming, thinking, parameters,
+ * multimodal content, message alternation, error handling, etc.).
+ *
+ * The only difference is authentication - this class overrides the constructor to
+ * handle GCP authentication instead of API keys.
+ *
+ * @example
+ * // Option 1: ADC (Application Default Credentials)
+ * // Set GOOGLE_APPLICATION_CREDENTIALS env var or use gcloud auth
+ * const llm = new VertexLLM(JSON.stringify({
+ *   project: 'my-project',
+ *   location: 'us-central1'
+ * }));
+ *
+ * @example
+ * // Option 2: Service account JSON as string (from credential system)
+ * const serviceAccountJson = JSON.stringify({
+ *   type: 'service_account',
+ *   project_id: 'my-project',
+ *   private_key: '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n',
+ *   client_email: 'sa@my-project.iam.gserviceaccount.com',
+ *   client_id: '123456789'
+ *   // ... other service account fields
+ * });
+ * const llm = new VertexLLM(JSON.stringify({
+ *   project: 'my-project',
+ *   location: 'us-central1',
+ *   serviceAccountJson: serviceAccountJson
+ * }));
+ *
+ * @example
+ * // Option 3: Service account JSON inline
+ * const llm = new VertexLLM(JSON.stringify({
+ *   type: 'service_account',
+ *   project_id: 'my-project',
+ *   private_key: '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n',
+ *   client_email: 'sa@my-project.iam.gserviceaccount.com',
+ *   client_id: '123456789',
+ *   // ... other service account fields
+ *   location: 'us-central1'
+ * }));
+ *
+ * @example
+ * // Option 4: Key file path reference
+ * const llm = new VertexLLM(JSON.stringify({
+ *   keyFilePath: '/path/to/service-account.json',
+ *   project: 'my-project',
+ *   location: 'us-central1'
+ * }));
+ */
+export declare class VertexLLM extends GeminiLLM {
+    private _credentials;
     /**
-     * Map message roles to Vertex format
+     * Create a new VertexLLM instance
+     *
+     * @param credentialsJson - JSON string containing Vertex AI credentials.
+     *   Must include at minimum: { project: 'id', location?: 'region' }
+     *   Can include full service account JSON or keyFilePath for authentication.
+     *
+     *   If neither service account fields nor keyFilePath are provided,
+     *   will use Application Default Credentials (ADC).
      */
-    private mapRole;
+    constructor(credentialsJson: string);
     /**
-     * Get the appropriate generative model based on model name
+     * Override parent's createClient() factory method to create Vertex AI client
+     *
+     * This factory method is called lazily on first use, so _credentials will always be set.
+     * The rest of the functionality (chat, streaming, etc.) remains identical.
      */
-    private getGenerativeModelForModel;
+    protected createClient(): Promise<GoogleGenAI>;
     /**
-     * Convert messages to Vertex content format
+     * Get Vertex AI credentials (for debugging/logging)
+     *
+     * Note: Returns a copy to prevent external modification.
+     * Sensitive fields like private_key are included, so be careful when logging.
      */
-    private mapToVertexContents;
+    get Credentials(): VertexAICredentials;
 }
+/**
+ * Load function to prevent tree-shaking
+ *
+ * Call this function from your module's public-api.ts to ensure
+ * the class is not removed during tree-shaking optimization.
+ */
 export declare function LoadVertexLLM(): void;
 //# sourceMappingURL=vertexLLM.d.ts.map

package/dist/models/vertexLLM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertexLLM.d.ts","sourceRoot":"","sources":["../../src/models/vertexLLM.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,UAAU,EACV,UAAU,EAGV,cAAc,EACd,cAAc,EACd,eAAe,EACf,eAAe,EAIhB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAElD,qBACa,SAAU,SAAQ,OAAO;IACpC,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAsB;IAgB/E,IAAW,MAAM,IAAI,QAAQ,CAE5B;IAED;;OAEG;IACH,IAAoB,iBAAiB,IAAI,OAAO,CAE/C;IAED;;OAEG;cACa,0BAA0B,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAiHnF;;OAEG;cACa,sBAAsB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BxE;;OAEG;IACH,SAAS,CAAC,qBAAqB,CAAC,KAAK,EAAE,GAAG,GAAG;QAC3C,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,KAAK,CAAC,EAAE,GAAG,CAAC;KACb;IAoCD;;OAEG;IACH,SAAS,CAAC,yBAAyB,CACjC,kBAAkB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7C,SAAS,EAAE,GAAG,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,GAAG,GAAG,IAAI,GAAG,SAAS,GAC5B,UAAU;IA2Bb;;OAEG;IACU,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAI7E;;OAEG;IACU,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;IAI1E;;OAEG;IACH,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAS/B;;OAEG;IACH,OAAO,CAAC,OAAO;IAYf;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAclC;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAS5B;AAED,wBAAgB,aAAa,SAE5B"}
+{"version":3,"file":"vertexLLM.d.ts","sourceRoot":"","sources":["../../src/models/vertexLLM.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAEhB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAG5B,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAG9B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,qBACa,SAAU,SAAQ,SAAS;IACtC,OAAO,CAAC,YAAY,CAAsB;IAE1C;;;;;;;;;OASG;gBACS,eAAe,EAAE,MAAM;IAiDnC;;;;;OAKG;cACa,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC;IAiDpD;;;;;OAKG;IACH,IAAW,WAAW,IAAI,mBAAmB,CAE5C;CACF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC"}

package/dist/models/vertexLLM.js

@@ -7,304 +7,184 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadVertexLLM = exports.VertexLLM = void 0;
-const ai_1 = require("@memberjunction/ai");
+const ai_gemini_1 = require("@memberjunction/ai-gemini");
+const genai_1 = require("@google/genai");
 const global_1 = require("@memberjunction/global");
-const vertexai_1 = require("@google-cloud/vertexai");
-let VertexLLM = class VertexLLM extends ai_1.BaseLLM {
-    constructor(apiKey, projectId, location = 'us-central1') {
-        super(apiKey);
-        this._projectId = projectId;
-        this._location = location;
-        // Initialize Google Vertex AI client
-        this._client = new vertexai_1.VertexAI({
-            project: this._projectId,
-            location: this._location,
-            apiEndpoint: `${this._location}-aiplatform.googleapis.com`,
-            googleAuthOptions: {
-                keyFile: apiKey // assumes apiKey is a path to a service account key file
-            }
-        });
-    }
-    get Client() {
-        return this._client;
-    }
-    /**
-     * Google Vertex AI supports streaming
-     */
-    get SupportsStreaming() {
-        return true;
-    }
+const ai_1 = require("@memberjunction/ai");
+/**
+ * VertexLLM - Google Vertex AI implementation
+ *
+ * Extends GeminiLLM and reuses all its logic (chat, streaming, thinking, parameters,
+ * multimodal content, message alternation, error handling, etc.).
+ *
+ * The only difference is authentication - this class overrides the constructor to
+ * handle GCP authentication instead of API keys.
+ *
+ * @example
+ * // Option 1: ADC (Application Default Credentials)
+ * // Set GOOGLE_APPLICATION_CREDENTIALS env var or use gcloud auth
+ * const llm = new VertexLLM(JSON.stringify({
+ *   project: 'my-project',
+ *   location: 'us-central1'
+ * }));
+ *
+ * @example
+ * // Option 2: Service account JSON as string (from credential system)
+ * const serviceAccountJson = JSON.stringify({
+ *   type: 'service_account',
+ *   project_id: 'my-project',
+ *   private_key: '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n',
+ *   client_email: 'sa@my-project.iam.gserviceaccount.com',
+ *   client_id: '123456789'
+ *   // ... other service account fields
+ * });
+ * const llm = new VertexLLM(JSON.stringify({
+ *   project: 'my-project',
+ *   location: 'us-central1',
+ *   serviceAccountJson: serviceAccountJson
+ * }));
+ *
+ * @example
+ * // Option 3: Service account JSON inline
+ * const llm = new VertexLLM(JSON.stringify({
+ *   type: 'service_account',
+ *   project_id: 'my-project',
+ *   private_key: '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n',
+ *   client_email: 'sa@my-project.iam.gserviceaccount.com',
+ *   client_id: '123456789',
+ *   // ... other service account fields
+ *   location: 'us-central1'
+ * }));
+ *
+ * @example
+ * // Option 4: Key file path reference
+ * const llm = new VertexLLM(JSON.stringify({
+ *   keyFilePath: '/path/to/service-account.json',
+ *   project: 'my-project',
+ *   location: 'us-central1'
+ * }));
+ */
+let VertexLLM = class VertexLLM extends ai_gemini_1.GeminiLLM {
     /**
-     * Implementation of non-streaming chat completion for Google Vertex AI
+     * Create a new VertexLLM instance
+     *
+     * @param credentialsJson - JSON string containing Vertex AI credentials.
+     *   Must include at minimum: { project: 'id', location?: 'region' }
+     *   Can include full service account JSON or keyFilePath for authentication.
+     *
+     *   If neither service account fields nor keyFilePath are provided,
+     *   will use Application Default Credentials (ADC).
      */
-    async nonStreamingChatCompletion(params) {
-        const startTime = new Date();
+    constructor(credentialsJson) {
+        // Parse credentials
+        let credentials;
         try {
-            // Map provider-agnostic params to Vertex-specific format
-            const vertexParams = this.mapToVertexParams(params);
-            // The model ID should be in the format like "gemini-pro", "text-bison", etc.
-            const modelName = params.model;
-            // Get the appropriate service for the model
-            const generativeModel = this.getGenerativeModelForModel(modelName);
-            // Prepare request parameters
-            const requestParams = {
-                model: modelName,
-                temperature: vertexParams.temperature,
-                maxOutputTokens: vertexParams.maxOutputTokens,
-                topP: vertexParams.topP,
-                topK: vertexParams.topK,
-                safetySettings: vertexParams.safetySettings
-            };
-            // Send the request
-            const response = await generativeModel.generateContent({
-                contents: this.mapToVertexContents(vertexParams.messages),
-                generationConfig: requestParams
-            });
-            const result = response.response;
-            // Extract the response content
-            let content = '';
-            if (result.candidates && result.candidates.length > 0) {
-                const candidate = result.candidates[0];
-                if (candidate.content && candidate.content.parts && candidate.content.parts.length > 0) {
-                    content = candidate.content.parts.map(part => {
-                        if (typeof part === 'string') {
-                            return part;
-                        }
-                        else if (part.text) {
-                            return part.text;
-                        }
-                        return '';
-                    }).join('');
-                }
-            }
-            // Extract usage information
-            const tokenUsage = {
-                promptTokens: result.usageMetadata?.promptTokenCount || 0,
-                completionTokens: result.usageMetadata?.candidatesTokenCount || 0,
-                totalTokens: (result.usageMetadata?.promptTokenCount || 0) + (result.usageMetadata?.candidatesTokenCount || 0)
-            };
-            const endTime = new Date();
-            // Create ModelUsage 
-            const usage = new ai_1.ModelUsage(tokenUsage.promptTokens, tokenUsage.completionTokens);
-            // Create the ChatResult
-            const choices = [{
-                    message: {
-                        role: ai_1.ChatMessageRole.assistant,
-                        content: content
-                    },
-                    finish_reason: result.candidates?.[0]?.finishReason || 'stop',
-                    index: 0
-                }];
-            const chatResult = {
-                success: true,
-                statusText: "OK",
-                startTime: startTime,
-                endTime: endTime,
-                timeElapsed: endTime.getTime() - startTime.getTime(),
-                data: {
-                    choices: choices,
-                    usage: usage
-                },
-                errorMessage: "",
-                exception: null,
-            };
-            // Add model-specific response details
-            chatResult.modelSpecificResponseDetails = {
-                provider: 'vertex',
-                model: params.model,
-                promptFeedback: result.promptFeedback,
-                safetyRatings: result.candidates?.[0]?.safetyRatings,
-                citationMetadata: result.candidates?.[0]?.citationMetadata,
-                finishReason: result.candidates?.[0]?.finishReason
-            };
-            return chatResult;
+            credentials = JSON.parse(credentialsJson);
         }
         catch (error) {
-            const endTime = new Date();
-            return {
-                success: false,
-                statusText: "Error",
-                startTime: startTime,
-                endTime: endTime,
-                timeElapsed: endTime.getTime() - startTime.getTime(),
-                data: {
-                    choices: [],
-                    usage: new ai_1.ModelUsage(0, 0)
-                },
-                errorMessage: error.message || "Error calling Google Vertex AI",
-                exception: error,
-                errorInfo: ai_1.ErrorAnalyzer.analyzeError(error, 'Vertex')
-            };
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Invalid Vertex AI credentials JSON: ${message}`);
         }
-    }
-    /**
-     * Create a streaming request for Vertex AI
-     */
-    async createStreamingRequest(params) {
-        // Map provider-agnostic params to Vertex-specific format
-        const vertexParams = this.mapToVertexParams(params);
-        // The model ID should be in the format like "gemini-pro", "text-bison", etc.
-        const modelName = params.model;
-        // Get the appropriate service for the model
-        const generativeModel = this.getGenerativeModelForModel(modelName);
-        // Prepare request parameters
-        const requestParams = {
-            model: modelName,
-            temperature: vertexParams.temperature,
-            maxOutputTokens: vertexParams.maxOutputTokens,
-            topP: vertexParams.topP,
-            topK: vertexParams.topK,
-            safetySettings: vertexParams.safetySettings
-        };
-        // Send the streaming request
-        return generativeModel.generateContentStream({
-            contents: this.mapToVertexContents(vertexParams.messages),
-            generationConfig: requestParams
-        });
-    }
-    /**
-     * Process a streaming chunk from Vertex AI
-     */
-    processStreamingChunk(chunk) {
-        let content = '';
-        let finishReason = null;
-        let usage = null;
-        if (chunk && chunk.candidates && chunk.candidates.length > 0) {
-            const candidate = chunk.candidates[0];
-            if (candidate.content && candidate.content.parts && candidate.content.parts.length > 0) {
-                content = candidate.content.parts.map(part => {
-                    if (typeof part === 'string') {
-                        return part;
-                    }
-                    else if (part.text) {
-                        return part.text;
-                    }
-                    return '';
-                }).join('');
+        // If serviceAccountJson is provided as a string, parse it and merge with credentials
+        if (credentials.serviceAccountJson) {
+            try {
+                const serviceAccount = JSON.parse(credentials.serviceAccountJson);
+                // Merge service account fields into credentials (serviceAccountJson fields take precedence)
+                credentials = {
+                    ...credentials,
+                    ...serviceAccount,
+                    // Keep top-level project and location if they exist
+                    project: credentials.project || serviceAccount.project_id,
+                    location: credentials.location
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                throw new Error(`Invalid serviceAccountJson: ${message}`);
             }
-            finishReason = candidate.finishReason || null;
         }
-        // Save usage information if available
-        if (chunk && chunk.usageMetadata) {
-            usage = new ai_1.ModelUsage(chunk.usageMetadata.promptTokenCount || 0, chunk.usageMetadata.candidatesTokenCount || 0);
+        // Validate required fields
+        if (!credentials.project && !credentials.project_id) {
+            throw new Error('Vertex AI credentials must include "project" or "project_id"');
         }
-        return {
-            content,
-            finishReason,
-            usage
-        };
+        // Use project_id if provided, otherwise use project
+        const projectId = credentials.project_id || credentials.project;
+        const location = credentials.location || 'us-central1';
+        // Normalize credentials
+        credentials.project = projectId;
+        credentials.location = location;
+        // Call parent constructor with project ID (BaseLLM stores this as apiKey)
+        super(projectId);
+        // Set credentials after super() call
+        // Parent constructor doesn't initialize the client, so this is safe
+        this._credentials = credentials;
     }
     /**
-     * Create the final response from streaming results for Vertex AI
+     * Override parent's createClient() factory method to create Vertex AI client
+     *
+     * This factory method is called lazily on first use, so _credentials will always be set.
+     * The rest of the functionality (chat, streaming, etc.) remains identical.
      */
-    finalizeStreamingResponse(accumulatedContent, lastChunk, usage) {
-        // Create dates (will be overridden by base class)
-        const now = new Date();
-        // Create a proper ChatResult instance with constructor params
-        const result = new ai_1.ChatResult(true, now, now);
-        // Set all properties
-        result.data = {
-            choices: [{
-                    message: {
-                        role: ai_1.ChatMessageRole.assistant,
-                        content: accumulatedContent ? accumulatedContent : ''
-                    },
-                    finish_reason: lastChunk?.finishReason || 'stop',
-                    index: 0
-                }],
-            usage: usage || new ai_1.ModelUsage(0, 0)
+    async createClient() {
+        // Build Vertex AI config
+        const config = {
+            vertexai: true,
+            project: this._credentials.project,
+            location: this._credentials.location
         };
-        result.statusText = 'success';
-        result.errorMessage = null;
-        result.exception = null;
-        return result;
-    }
-    /**
-     * Not implemented yet
-     */
-    async SummarizeText(params) {
-        throw new Error("Method not implemented.");
-    }
-    /**
-     * Not implemented yet
-     */
-    async ClassifyText(params) {
-        throw new Error("Method not implemented.");
-    }
-    /**
-     * Map MemberJunction ChatParams to Vertex-specific params
-     */
-    mapToVertexParams(params) {
-        return {
-            model: params.model,
-            messages: this.convertToVertexMessages(params.messages),
-            temperature: params.temperature,
-            maxOutputTokens: params.maxOutputTokens
-        };
-    }
-    /**
-     * Convert MemberJunction chat messages to Vertex-compatible messages
-     */
-    convertToVertexMessages(messages) {
-        return messages.map(msg => {
-            return {
-                role: this.mapRole(msg.role),
-                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+        // If keyFilePath is provided, configure file-based auth
+        if (this._credentials.keyFilePath) {
+            config.googleAuthOptions = {
+                keyFile: this._credentials.keyFilePath
             };
-        });
-    }
-    /**
-     * Map message roles to Vertex format
-     */
-    mapRole(role) {
-        switch (role) {
-            case ai_1.ChatMessageRole.system:
-                return 'system';
-            case ai_1.ChatMessageRole.assistant:
-                return 'model';
-            case ai_1.ChatMessageRole.user:
-            default:
-                return 'user';
-        }
-    }
-    /**
-     * Get the appropriate generative model based on model name
-     */
-    getGenerativeModelForModel(modelName) {
-        // For different model types, we might need different parameters
-        if (modelName.startsWith('gemini-')) {
-            return this._client.getGenerativeModel({ model: modelName });
-        }
-        else if (modelName.startsWith('text-')) {
-            return this._client.getGenerativeModel({ model: modelName });
-        }
-        else if (modelName.startsWith('code-')) {
-            return this._client.getGenerativeModel({ model: modelName });
         }
-        else {
-            // Default case
-            return this._client.getGenerativeModel({ model: modelName });
+        // If full service account JSON is provided, use inline credentials
+        else if (this._credentials.type === 'service_account' && this._credentials.private_key) {
+            config.googleAuthOptions = {
+                credentials: {
+                    type: this._credentials.type,
+                    project_id: this._credentials.project_id || this._credentials.project,
+                    private_key_id: this._credentials.private_key_id || '',
+                    private_key: this._credentials.private_key,
+                    client_email: this._credentials.client_email || '',
+                    client_id: this._credentials.client_id || '',
+                    auth_uri: this._credentials.auth_uri || 'https://accounts.google.com/o/oauth2/auth',
+                    token_uri: this._credentials.token_uri || 'https://oauth2.googleapis.com/token',
+                    auth_provider_x509_cert_url: this._credentials.auth_provider_x509_cert_url || 'https://www.googleapis.com/oauth2/v1/certs',
+                    client_x509_cert_url: this._credentials.client_x509_cert_url || ''
+                }
+            };
         }
+        // Otherwise, use Application Default Credentials (ADC)
+        // This will look for:
+        // 1. GOOGLE_APPLICATION_CREDENTIALS environment variable pointing to key file
+        // 2. gcloud auth application-default login credentials
+        // 3. GCE/GKE/Cloud Run service account (when running in Google Cloud)
+        // Create Vertex AI client with the configured options
+        return new genai_1.GoogleGenAI(config);
     }
     /**
-     * Convert messages to Vertex content format
+     * Get Vertex AI credentials (for debugging/logging)
+     *
+     * Note: Returns a copy to prevent external modification.
+     * Sensitive fields like private_key are included, so be careful when logging.
      */
-    mapToVertexContents(messages) {
-        // Convert messages to the format expected by Vertex AI
-        return messages.map(msg => {
-            return {
-                role: msg.role,
-                parts: [{ text: msg.content }]
-            };
-        });
+    get Credentials() {
+        return { ...this._credentials };
     }
 };
 exports.VertexLLM = VertexLLM;
 exports.VertexLLM = VertexLLM = __decorate([
     (0, global_1.RegisterClass)(ai_1.BaseLLM, "VertexLLM")
 ], VertexLLM);
+/**
+ * Load function to prevent tree-shaking
+ *
+ * Call this function from your module's public-api.ts to ensure
+ * the class is not removed during tree-shaking optimization.
+ */
 function LoadVertexLLM() {
-    // this does nothing but prevents the class from being removed by the tree shaker
+    // Intentionally empty - just prevents tree-shaking
 }
 exports.LoadVertexLLM = LoadVertexLLM;
 //# sourceMappingURL=vertexLLM.js.map