locai 2.1.2 → 2.2.0

package/dist/core/pipeline/context.d.ts

@@ -0,0 +1,29 @@
+export interface TranslationResult {
+    key: string;
+    translated: string | null;
+    success: boolean;
+    context: Record<string, any>;
+    error?: string;
+    fromCache?: boolean;
+    qualityChecks?: any;
+    meta?: Record<string, any>;
+}
+export interface TranslationContext {
+    key: string;
+    sourceText: string;
+    sourceLang: string;
+    targetLang: string;
+    options: any;
+    meta: Record<string, any>;
+    existingTranslation: any;
+    result: TranslationResult;
+    protectedText?: string;
+    termMap?: Map<string, any>;
+    translatedText?: string;
+    success?: boolean;
+    error?: string;
+    fromCache?: boolean;
+    qualityChecks?: any;
+    [key: string]: any;
+}
+export declare const createTranslationContext: (key: string, sourceText: string, sourceLang: string, targetLang: string, options: any, meta?: Record<string, any>, existingTranslation?: any) => TranslationContext;

package/dist/core/pipeline/steps/CacheReadStep.d.ts

@@ -0,0 +1,25 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+export interface CacheStats {
+    hits: number;
+    staleHits: number;
+    misses: number;
+    stored: number;
+    [key: string]: any;
+}
+export interface Cache {
+    has(key: string): boolean;
+    get(key: string): any;
+    set(key: string, value: any, options?: any): void;
+    delete(key: string): void;
+    getRemainingTTL?(key: string): number;
+}
+declare class CacheReadStep extends PipelineStep {
+    private cache;
+    private stats;
+    private options;
+    constructor(cache: Cache, cacheStats: CacheStats, options?: any);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+    _generateCacheKey(text: string, targetLang: string, category?: string): string;
+}
+export default CacheReadStep;

package/dist/core/pipeline/steps/CacheWriteStep.d.ts

@@ -0,0 +1,11 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+import { Cache, CacheStats } from "./CacheReadStep.js";
+declare class CacheWriteStep extends PipelineStep {
+    private cache;
+    private stats;
+    private options;
+    constructor(cache: Cache, cacheStats: CacheStats, options?: any);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default CacheWriteStep;

package/dist/core/pipeline/steps/ConfidenceCheckStep.d.ts

@@ -0,0 +1,10 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+import { ConfidenceSettings } from "./TranslationStep.js";
+declare class ConfidenceCheckStep extends PipelineStep {
+    private confidenceSettings;
+    private debug;
+    constructor(confidenceSettings: Partial<ConfidenceSettings>, debug?: boolean);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default ConfidenceCheckStep;

package/dist/core/pipeline/steps/GlossaryPostStep.d.ts

@@ -0,0 +1,9 @@
+import PipelineStep from "../PipelineStep.js";
+import GlossaryManager from "../../../utils/glossary-manager.js";
+import { TranslationContext } from "../context.js";
+declare class GlossaryPostStep extends PipelineStep {
+    private glossaryManager?;
+    constructor(glossaryManager?: GlossaryManager | null);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default GlossaryPostStep;

package/dist/core/pipeline/steps/GlossaryPreStep.d.ts

@@ -0,0 +1,9 @@
+import PipelineStep from "../PipelineStep.js";
+import GlossaryManager from "../../../utils/glossary-manager.js";
+import { TranslationContext } from "../context.js";
+declare class GlossaryPreStep extends PipelineStep {
+    private glossaryManager?;
+    constructor(glossaryManager?: GlossaryManager | null);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default GlossaryPreStep;

package/dist/core/pipeline/steps/InputValidationStep.d.ts

@@ -0,0 +1,8 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+declare class InputValidationStep extends PipelineStep {
+    private maxKeyLength;
+    constructor(maxKeyLength?: number);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default InputValidationStep;

package/dist/core/pipeline/steps/QualityCheckStep.d.ts

@@ -0,0 +1,10 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+import QualityChecker from "../../../utils/quality/index.js";
+declare class QualityCheckStep extends PipelineStep {
+    private qualityChecker;
+    private debug;
+    constructor(qualityChecker: QualityChecker | any, debug?: boolean);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default QualityCheckStep;

package/dist/core/pipeline/steps/ToneCheckStep.d.ts

@@ -0,0 +1,13 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+export declare class ToneCheckStep extends PipelineStep {
+    private verifier;
+    private enabled;
+    private debug;
+    constructor(config?: {
+        enabled?: boolean;
+        debug?: boolean;
+    });
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}
+export default ToneCheckStep;

package/dist/core/pipeline/steps/TranslationStep.d.ts

@@ -0,0 +1,22 @@
+import PipelineStep from "../PipelineStep.js";
+import { AIProvider } from "../../provider-factory.js";
+import { TranslationContext } from "../context.js";
+export interface ConfidenceSettings {
+    enabled: boolean;
+    autoApproveThreshold: number;
+    rejectThreshold: number;
+    reviewThreshold: number;
+    saveReviewQueue: boolean;
+    reviewQueue: any[];
+    autoApprovedCount: number;
+    rejectedCount: number;
+    [key: string]: any;
+}
+declare class TranslationStep extends PipelineStep {
+    private options;
+    private confidenceSettings;
+    constructor(options?: any, confidenceSettings?: Partial<ConfidenceSettings>);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+    _getProvider(): AIProvider;
+}
+export default TranslationStep;

package/dist/core/pipeline/steps/VectorCacheReadStep.d.ts

@@ -0,0 +1,17 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+import { VectorStore } from "../../../services/vector-store.js";
+import { EmbeddingProvider } from "../../../services/embedding-provider.js";
+export interface VectorMemoryStats {
+    hits: number;
+    contextUsed: number;
+    misses: number;
+}
+export declare class VectorCacheReadStep extends PipelineStep {
+    private vectorStore;
+    private embeddingProvider;
+    private stats;
+    private options;
+    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, stats: VectorMemoryStats, options?: any);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}

package/dist/core/pipeline/steps/VectorCacheWriteStep.d.ts

@@ -0,0 +1,11 @@
+import PipelineStep from "../PipelineStep.js";
+import { TranslationContext } from "../context.js";
+import { VectorStore } from "../../../services/vector-store.js";
+import { EmbeddingProvider } from "../../../services/embedding-provider.js";
+export declare class VectorCacheWriteStep extends PipelineStep {
+    private vectorStore;
+    private embeddingProvider;
+    private options;
+    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, options?: any);
+    execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
+}

package/dist/core/pipeline/steps/__tests__/ToneCheckStep.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/provider-factory.d.ts

@@ -0,0 +1,41 @@
+import { ProviderConfig, TranslateOptions } from "../providers/base-provider.js";
+export interface AIProvider {
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze?(prompt: string, options?: ProviderConfig): Promise<string>;
+    chat?(messages: any[], options?: ProviderConfig): Promise<string>;
+}
+/**
+ * Factory for creating and managing AI providers.
+ * Handles provider instantiation, configuration, and fallback chains.
+ */
+declare class ProviderFactory {
+    /**
+     * Get provider instance with intelligent fallback support.
+     * @param {string} providerName - Name of the primary provider.
+     * @param {boolean} [useFallback=true] - Whether to use fallback chain on failure.
+     * @param {Object} [config=null] - Optional configuration overrides.
+     * @returns {AIProvider} - Provider instance or wrapped FallbackProvider.
+     * @throws {Error} If provider is not found or configured.
+     */
+    static getProvider(providerName: string, useFallback?: boolean, config?: {
+        fallbackOrder?: string[];
+    } | null): AIProvider;
+    /**
+     * Get list of available (configured) providers.
+     * @returns {string[]} - Array of provider names with valid API keys.
+     */
+    static getAvailableProviders(): string[];
+    /**
+     * Validate that at least one provider is configured.
+     * @returns {string[]} - Array of available providers.
+     * @throws {Error} If no providers are configured.
+     */
+    static validateProviders(): string[];
+    /**
+     * Check if a specific provider is configured.
+     * @param {string} providerName - Name of the provider.
+     * @returns {boolean} - True if provider has an API key configured.
+     */
+    static isProviderConfigured(providerName: string): boolean;
+}
+export default ProviderFactory;

package/dist/core/provider-factory.js

@@ -1,6 +1,7 @@
 import * as deepseekProvider from "../providers/deepseek.js";
 import * as geminiProvider from "../providers/gemini.js";
 import * as openaiProvider from "../providers/openai.js";
+import * as anthropicProvider from "../providers/anthropic.js";
 import * as dashscopeProvider from "../providers/dashscope.js";
 import * as xaiProvider from "../providers/xai.js";
 import FallbackProvider from "./fallback-provider.js";
@@ -23,6 +24,7 @@ class ProviderFactory {
             dashscope: dashscopeProvider,
             xai: xaiProvider,
             openai: openaiProvider,
+            anthropic: anthropicProvider,
             deepseek: deepseekProvider,
             gemini: geminiProvider,
         };
@@ -100,6 +102,7 @@ class ProviderFactory {
             dashscope: process.env.DASHSCOPE_API_KEY,
             xai: process.env.XAI_API_KEY,
             openai: process.env.OPENAI_API_KEY,
+            anthropic: process.env.ANTHROPIC_API_KEY,
             deepseek: process.env.DEEPSEEK_API_KEY,
             gemini: process.env.GEMINI_API_KEY,
         };
@@ -129,6 +132,7 @@ class ProviderFactory {
             dashscope: "DASHSCOPE_API_KEY",
             xai: "XAI_API_KEY",
             openai: "OPENAI_API_KEY",
+            anthropic: "ANTHROPIC_API_KEY",
             deepseek: "DEEPSEEK_API_KEY",
             gemini: "GEMINI_API_KEY",
         };

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,25 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for Anthropic (Claude) models.
+ */
+declare class AnthropicProvider extends BaseProvider {
+    private client;
+    /**
+     * Create a new AnthropicProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    /**
+     * Translate text using Anthropic.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+    chat(messages: any[], options?: ProviderConfig): Promise<string>;
+    extractTranslation(response: any, providerName: string): string;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+declare function chat(messages: any[], options?: ProviderConfig): Promise<string>;
+export { translate, analyze, chat, AnthropicProvider };

package/dist/providers/anthropic.js

@@ -0,0 +1,178 @@
+import axios from "axios";
+import BaseProvider from "./base-provider.js";
+import { getPrompt, getAnalysisPrompt } from "../utils/prompt-templates.js";
+import RetryHelper from "../utils/retry-helper.js";
+/**
+ * Provider implementation for Anthropic (Claude) models.
+ */
+class AnthropicProvider extends BaseProvider {
+    client;
+    /**
+     * Create a new AnthropicProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config = {}) {
+        super("anthropic", config);
+        this.client = axios.create({
+            baseURL: "https://api.anthropic.com/v1",
+            headers: {
+                ...this.commonHeaders,
+                "x-api-key": this.getApiKey(),
+                "anthropic-version": "2023-06-01",
+            },
+            timeout: 30000,
+            maxRedirects: 0,
+            validateStatus: (status) => status < 500,
+        });
+    }
+    getApiKey() {
+        return process.env.ANTHROPIC_API_KEY;
+    }
+    getEndpoint() {
+        return "/messages";
+    }
+    /**
+     * Translate text using Anthropic.
+     */
+    async translate(text, sourceLang, targetLang, options = {}) {
+        this.validateRequest(text, sourceLang, targetLang);
+        // Prioritize user config > options config > default model
+        // Anthropic models: claude-3-5-sonnet-latest, claude-3-5-haiku-latest, claude-3-opus-latest
+        const config = this.getConfig(options.apiConfig?.anthropic);
+        const model = config.model || "claude-haiku-4-5-20251001";
+        const promptData = getPrompt("anthropic", sourceLang, targetLang, text, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: model,
+                    ...promptData, // Contains { system: "...", messages: [...] }
+                    max_tokens: config.maxTokens || 4096,
+                    temperature: config.temperature,
+                });
+                this.validateResponse(response, this.name);
+                const translation = this.extractTranslation(response.data, this.name);
+                return this.sanitizeTranslation(translation);
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.retryOptions?.maxRetries || 2,
+            initialDelay: options.retryOptions?.initialDelay || 1000,
+            context: "Anthropic Provider",
+            logContext: {
+                source: sourceLang,
+                target: targetLang,
+            },
+        });
+    }
+    async analyze(prompt, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "claude-3-5-sonnet-latest",
+            temperature: options.temperature || 0.2,
+            maxTokens: options.maxTokens || 1000,
+        });
+        const promptData = getAnalysisPrompt("anthropic", prompt, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model,
+                    ...promptData,
+                    max_tokens: config.maxTokens,
+                    temperature: config.temperature,
+                });
+                this.validateResponse(response, this.name);
+                const result = this.extractTranslation(response.data, this.name);
+                return this.sanitizeTranslation(result);
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries || 2,
+            initialDelay: options.initialDelay || 1000,
+            context: "Anthropic Provider Analysis",
+        });
+    }
+    async chat(messages, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "claude-3-5-sonnet-latest",
+            temperature: options.temperature || 0.3,
+            maxTokens: options.maxTokens || 4096,
+        });
+        // Anthropic requires system prompt to be top-level, separate from messages array
+        // Note: This simple implementation assumes messages passed in might be mixed.
+        // Ideally, the caller should separate system prompt, but we can do a quick check here.
+        let systemPrompt = undefined;
+        const cleanMessages = messages.filter((msg) => {
+            if (msg.role === "system") {
+                systemPrompt = msg.content;
+                return false;
+            }
+            return true;
+        });
+        return RetryHelper.withRetry(async () => {
+            try {
+                const payload = {
+                    model: config.model,
+                    messages: cleanMessages,
+                    max_tokens: config.maxTokens,
+                    temperature: config.temperature,
+                };
+                if (systemPrompt) {
+                    payload.system = systemPrompt;
+                }
+                const response = await this.client.post(this.getEndpoint(), payload);
+                this.validateResponse(response, this.name);
+                const result = this.extractTranslation(response.data, this.name);
+                return this.sanitizeTranslation(result);
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries || 2,
+            initialDelay: options.initialDelay || 1000,
+            context: "Anthropic Provider Chat",
+        });
+    }
+    // Override extractTranslation to handle Anthropic's specific response structure
+    extractTranslation(response, providerName) {
+        // Check for error response first
+        if (response.error) {
+            const errorMsg = response.error.message || response.error.error || JSON.stringify(response.error);
+            throw new Error(`api: ${providerName} - ${errorMsg}`);
+        }
+        // Anthropic format: { content: [{ type: 'text', text: '...' }] }
+        if (response.content && Array.isArray(response.content) && response.content.length > 0) {
+            const textBlock = response.content.find((block) => block.type === "text");
+            if (textBlock && textBlock.text) {
+                return textBlock.text.trim();
+            }
+        }
+        // Fallback to base implementation for other structures (though unlikely for Anthropic)
+        return super.extractTranslation(response, providerName);
+    }
+}
+// Lazy singleton - created on first use
+let anthropicProvider = null;
+function getProvider() {
+    if (!anthropicProvider) {
+        anthropicProvider = new AnthropicProvider();
+    }
+    return anthropicProvider;
+}
+// Export both class and legacy functions
+async function translate(text, sourceLang, targetLang, options = {}) {
+    return getProvider().translate(text, sourceLang, targetLang, options);
+}
+async function analyze(prompt, options = {}) {
+    return getProvider().analyze(prompt, options);
+}
+async function chat(messages, options = {}) {
+    return getProvider().chat(messages, options);
+}
+export { translate, analyze, chat, AnthropicProvider };

package/dist/providers/base-provider.d.ts

@@ -0,0 +1,66 @@
+export interface ProviderConfig {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    [key: string]: any;
+}
+export interface TranslateOptions {
+    detectedContext?: {
+        category?: string;
+        [key: string]: any;
+    };
+    lengthControl?: {
+        mode?: string;
+        [key: string]: any;
+    };
+    apiConfig?: Record<string, any>;
+    retryOptions?: {
+        maxRetries?: number;
+        initialDelay?: number;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface ConfidenceResult {
+    score: number;
+    metrics?: any;
+    [key: string]: any;
+}
+export interface TranslationResult {
+    translation: string;
+    confidence: ConfidenceResult;
+    rawResponse: any;
+}
+declare class BaseProvider {
+    name: string;
+    config: ProviderConfig;
+    defaultModel?: string;
+    defaultTemperature: number;
+    defaultMaxTokens: number;
+    commonHeaders: Record<string, string>;
+    constructor(name: string, config?: ProviderConfig);
+    translate(text: string, sourceLang: string, targetLang: string, _options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: any): Promise<string>;
+    chat(messages: any[], options?: any): Promise<string>;
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    validateRequest(text: string, sourceLang: string, targetLang: string): void;
+    validateResponse(response: any, providerName: string): boolean;
+    handleApiError(error: any, providerName: string): never;
+    generatePrompt(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): string;
+    getConfig(options?: ProviderConfig): {
+        model: string | undefined;
+        temperature: number;
+        maxTokens: number;
+        max_tokens: number;
+        apiKey: string;
+        endpoint: string;
+    };
+    extractTranslation(response: any, providerName: string): string;
+    /**
+     * Extract translation with confidence score
+     */
+    extractTranslationWithConfidence(response: any, providerName: string, sourceText: string, sourceLang: string, targetLang: string, category?: string): TranslationResult;
+    sanitizeTranslation(translation: string): string;
+}
+export default BaseProvider;

package/dist/providers/dashscope.d.ts

@@ -0,0 +1,24 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for Alibaba DashScope (Qwen) models.
+ */
+declare class DashScopeProvider extends BaseProvider {
+    private client;
+    private generationClient;
+    /**
+     * Create a new DashScopeProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    getGenerationEndpoint(): string;
+    /**
+     * Translate text using DashScope.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+export { translate, analyze, DashScopeProvider };

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,22 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for DeepSeek API.
+ */
+declare class DeepSeekProvider extends BaseProvider {
+    private client;
+    /**
+     * Create a new DeepSeekProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(): string;
+    /**
+     * Translate text using DeepSeek.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+export { translate, analyze, DeepSeekProvider };

package/dist/providers/gemini.d.ts

@@ -0,0 +1,22 @@
+import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+/**
+ * Provider implementation for Google Gemini models.
+ */
+declare class GeminiProvider extends BaseProvider {
+    private client;
+    /**
+     * Create a new GeminiProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config?: ProviderConfig);
+    getApiKey(): string | undefined;
+    getEndpoint(model?: string): string;
+    /**
+     * Translate text using Gemini.
+     */
+    translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+    analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+}
+declare function translate(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): Promise<string>;
+declare function analyze(prompt: string, options?: ProviderConfig): Promise<string>;
+export { translate, analyze, GeminiProvider };

package/dist/providers/gemini.js

@@ -27,7 +27,7 @@ class GeminiProvider extends BaseProvider {
         return process.env.GEMINI_API_KEY;
     }
     getEndpoint(model) {
-        return `/models/${model || "gemini-2.0-flash-exp"}:generateContent`;
+        return `/models/${model || "gemini-3-flash"}:generateContent`;
     }
     /**
      * Translate text using Gemini.
@@ -35,7 +35,7 @@ class GeminiProvider extends BaseProvider {
     async translate(text, sourceLang, targetLang, options = {}) {
         this.validateRequest(text, sourceLang, targetLang);
         const config = this.getConfig(options.apiConfig?.gemini);
-        const model = config.model || "gemini-2.0-flash-exp";
+        const model = config.model || "gemini-3-flash";
         const apiKey = this.getApiKey();
         if (!apiKey) {
             throw new Error("GEMINI_API_KEY environment variable not found");
@@ -77,7 +77,7 @@ class GeminiProvider extends BaseProvider {
     }
     async analyze(prompt, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gemini-2.0-flash-exp",
+            model: options.model || "gemini-3-flash",
             temperature: options.temperature || 0.2,
             maxTokens: options.maxTokens || 1000,
         });