locai 2.1.3 → 2.2.0

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/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,
         });

package/dist/providers/openai.js

@@ -40,7 +40,7 @@ class OpenAIProvider extends BaseProvider {
         return RetryHelper.withRetry(async () => {
             try {
                 const response = await this.client.post(this.getEndpoint(), {
-                    model: config.model || "gpt-4o",
+                    model: config.model || "gpt-5.2-chat-latest",
                     ...promptData,
                     temperature: config.temperature,
                     max_completion_tokens: config.maxTokens || config.max_tokens,
@@ -65,7 +65,7 @@ class OpenAIProvider extends BaseProvider {
     }
     async analyze(prompt, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gpt-4o",
+            model: options.model || "gpt-5.2-chat-latest",
             temperature: options.temperature || 0.2,
             maxTokens: options.maxTokens || 1000,
         });
@@ -94,7 +94,7 @@ class OpenAIProvider extends BaseProvider {
     }
     async chat(messages, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gpt-4o",
+            model: options.model || "gpt-5.2-chat-latest",
             temperature: options.temperature || 0.3,
             maxTokens: options.maxTokens || 2000,
         });

package/dist/utils/error-helper.js

@@ -321,6 +321,7 @@ class ErrorHelper {
             deepseek: "DEEPSEEK_API_KEY",
             dashscope: "DASHSCOPE_API_KEY",
             xai: "XAI_API_KEY",
+            anthropic: "ANTHROPIC_API_KEY",
         };
         return envMap[provider?.toLowerCase()] || `${provider?.toUpperCase()}_API_KEY`;
     }
@@ -334,6 +335,7 @@ class ErrorHelper {
             deepseek: "https://platform.deepseek.com/api-keys",
             dashscope: "https://dashscope.console.aliyun.com/",
             xai: "https://console.x.ai/",
+            anthropic: "https://console.anthropic.com/settings/keys",
         };
         return urlMap[provider?.toLowerCase()] || "provider console";
     }
@@ -341,7 +343,7 @@ class ErrorHelper {
      * Suggest fallback provider
      */
     static _suggestFallbackProvider(currentProvider) {
-        const fallbackOrder = ["openai", "gemini", "deepseek", "dashscope", "xai"];
+        const fallbackOrder = ["openai", "anthropic", "gemini", "deepseek", "dashscope", "xai"];
         const current = currentProvider?.toLowerCase();
         const index = fallbackOrder.indexOf(current);
         if (index === -1 || index === fallbackOrder.length - 1) {

package/dist/utils/input-validator.js

@@ -5,7 +5,14 @@
 import path from "path";
 class InputValidator {
     static LANGUAGE_CODE_PATTERN = /^[a-z]{2}(-[a-z]{2})?$/;
-    static VALID_PROVIDERS = ["dashscope", "xai", "openai", "deepseek", "gemini"];
+    static VALID_PROVIDERS = [
+        "dashscope",
+        "xai",
+        "openai",
+        "deepseek",
+        "gemini",
+        "anthropic",
+    ];
     static MAX_TEXT_LENGTH = 10000;
     static MAX_KEY_LENGTH = 500;
     static MAX_PATH_LENGTH = 1000;

package/dist/utils/prompt-templates.js

@@ -236,6 +236,15 @@ Original Text: "${text}"`,
             },
         ],
     }),
+    anthropic: (sourceLang, targetLang, text, options) => ({
+        system: baseTranslationPromptTemplate(sourceLang, targetLang, text, options),
+        messages: [
+            {
+                role: "user",
+                content: text,
+            },
+        ],
+    }),
     deepseek: (sourceLang, targetLang, text, options) => ({
         messages: [
             {
@@ -317,6 +326,15 @@ const analysisPrompts = {
             max_tokens: options.maxTokens || 1000,
         },
     }),
+    anthropic: (text, options) => ({
+        system: "You are a context analysis assistant that helps identify the category and context of text.",
+        messages: [
+            {
+                role: "user",
+                content: baseAnalysisPromptTemplate(text, options),
+            },
+        ],
+    }),
     deepseek: (text, options) => ({
         messages: [
             {

package/dist/utils/rate-limiter.js

@@ -59,6 +59,12 @@ class RateLimiter {
                 lastReset: performance.now(),
                 maxConcurrent: 8,
             },
+            anthropic: {
+                requestsPerMinute: 50,
+                currentRequests: 0,
+                lastReset: performance.now(),
+                maxConcurrent: 5,
+            },
         };
         this._processingLocks = {};
         Object.keys(this.providers).forEach((provider) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "locai",
-	"version": "2.1.3",
+	"version": "2.2.0",
 	"type": "module",
 	"main": "dist/core/orchestrator.js",
 	"types": "dist/core/orchestrator.d.ts",