locai 2.1.0

package/dist/providers/openai.js

@@ -0,0 +1,203 @@
+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 OpenAI (GPT) models.
+ */
+class OpenAIProvider extends BaseProvider {
+    client;
+    /**
+     * Create a new OpenAIProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config = {}) {
+        super("openai", config);
+        this.client = axios.create({
+            baseURL: "https://api.openai.com/v1",
+            headers: {
+                ...this.commonHeaders,
+                Authorization: `Bearer ${this.getApiKey()}`,
+            },
+            timeout: 30000,
+            maxRedirects: 0,
+            validateStatus: (status) => status < 500,
+        });
+    }
+    getApiKey() {
+        return process.env.OPENAI_API_KEY;
+    }
+    getEndpoint() {
+        return "/chat/completions";
+    }
+    /**
+     * Translate text using OpenAI.
+     */
+    async translate(text, sourceLang, targetLang, options = {}) {
+        this.validateRequest(text, sourceLang, targetLang);
+        const config = this.getConfig(options.apiConfig?.openai);
+        const promptData = getPrompt("openai", sourceLang, targetLang, text, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model || "gpt-4o",
+                    ...promptData,
+                    temperature: config.temperature,
+                    max_completion_tokens: config.maxTokens || config.max_tokens,
+                });
+                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; // handleApiError throws, but TS might need this
+            }
+        }, {
+            maxRetries: options.retryOptions?.maxRetries || 2,
+            initialDelay: options.retryOptions?.initialDelay || 1000,
+            context: "OpenAI Provider",
+            logContext: {
+                source: sourceLang,
+                target: targetLang,
+            },
+        });
+    }
+    async analyze(prompt, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "gpt-4o",
+            temperature: options.temperature || 0.2,
+            maxTokens: options.maxTokens || 1000,
+        });
+        const promptData = getAnalysisPrompt("openai", prompt, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model,
+                    ...promptData,
+                    temperature: config.temperature,
+                    max_completion_tokens: config.maxTokens || config.max_tokens,
+                });
+                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: "OpenAI Provider Analysis",
+        });
+    }
+    async chat(messages, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "gpt-4o",
+            temperature: options.temperature || 0.3,
+            maxTokens: options.maxTokens || 2000,
+        });
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model,
+                    messages: messages,
+                    temperature: config.temperature,
+                    max_completion_tokens: config.maxTokens || config.max_tokens,
+                    response_format: options.json ? { type: "json_object" } : undefined,
+                });
+                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: "OpenAI Provider Chat",
+        });
+    }
+    async embed(text, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "text-embedding-3-small",
+        });
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post("/embeddings", {
+                    model: config.model,
+                    input: text,
+                });
+                if (response.data && response.data.data && response.data.data[0]) {
+                    return response.data.data[0].embedding;
+                }
+                return [];
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries || 2,
+            initialDelay: options.initialDelay || 1000,
+            context: "OpenAI Provider Embed",
+        });
+    }
+    async embedBatch(texts, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "text-embedding-3-small",
+        });
+        return RetryHelper.withRetry(async () => {
+            try {
+                // OpenAI suggests replacing newlines for best results
+                const cleanTexts = texts.map((t) => t.replace(/\n/g, " "));
+                const response = await this.client.post("/embeddings", {
+                    model: config.model,
+                    input: cleanTexts,
+                });
+                if (response.data && response.data.data) {
+                    return response.data.data
+                        .sort((a, b) => a.index - b.index)
+                        .map((item) => item.embedding);
+                }
+                return [];
+            }
+            catch (error) {
+                this.handleApiError(error, this.name);
+                throw error;
+            }
+        }, {
+            maxRetries: options.maxRetries || 2,
+            initialDelay: options.initialDelay || 1000,
+            context: "OpenAI Provider Embed Batch",
+        });
+    }
+}
+// Lazy singleton - created on first use
+let openaiProvider = null;
+function getProvider() {
+    if (!openaiProvider) {
+        openaiProvider = new OpenAIProvider();
+    }
+    return openaiProvider;
+}
+// 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);
+}
+async function embed(text, options = {}) {
+    return getProvider().embed(text, options);
+}
+async function embedBatch(texts, options = {}) {
+    return getProvider().embedBatch(texts, options);
+}
+export { translate, analyze, chat, embed, embedBatch, OpenAIProvider };

package/dist/providers/xai.js

@@ -0,0 +1,111 @@
+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 X.AI (Grok) models.
+ */
+class XAIProvider extends BaseProvider {
+    client;
+    /**
+     * Create a new XAIProvider instance.
+     * @param {ProviderConfig} config - Provider configuration.
+     */
+    constructor(config = {}) {
+        super("xai", config);
+        this.client = axios.create({
+            baseURL: "https://api.x.ai/v1",
+            headers: {
+                ...this.commonHeaders,
+                Authorization: `Bearer ${this.getApiKey()}`,
+            },
+            timeout: 30000,
+            maxRedirects: 0,
+            validateStatus: (status) => status < 500,
+        });
+    }
+    getApiKey() {
+        return process.env.XAI_API_KEY;
+    }
+    getEndpoint() {
+        return "/chat/completions";
+    }
+    /**
+     * Translate text using X.AI.
+     */
+    async translate(text, sourceLang, targetLang, options = {}) {
+        this.validateRequest(text, sourceLang, targetLang);
+        const config = this.getConfig(options.apiConfig?.xai);
+        const promptData = getPrompt("xai", sourceLang, targetLang, text, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model || "grok-4",
+                    ...promptData,
+                    temperature: config.temperature || 0.3,
+                    max_tokens: config.maxTokens || 2000,
+                });
+                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: "X.AI Provider",
+            logContext: {
+                source: sourceLang,
+                target: targetLang,
+            },
+        });
+    }
+    async analyze(prompt, options = {}) {
+        const config = this.getConfig({
+            model: options.model || "grok-4",
+            temperature: options.temperature || 0.2,
+            maxTokens: options.maxTokens || 1000,
+        });
+        const promptData = getAnalysisPrompt("xai", prompt, options);
+        return RetryHelper.withRetry(async () => {
+            try {
+                const response = await this.client.post(this.getEndpoint(), {
+                    model: config.model,
+                    ...promptData,
+                    temperature: config.temperature,
+                    max_tokens: config.maxTokens,
+                });
+                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: "X.AI Provider Analysis",
+        });
+    }
+}
+// Lazy singleton - created on first use
+let xaiProvider = null;
+function getProvider() {
+    if (!xaiProvider) {
+        xaiProvider = new XAIProvider();
+    }
+    return xaiProvider;
+}
+// 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);
+}
+export { translate, analyze, XAIProvider };

package/dist/services/embedding-provider.js

@@ -0,0 +1,50 @@
+import * as openaiProvider from "../providers/openai.js";
+/**
+ * Service to generate embeddings for text
+ */
+export class EmbeddingProvider {
+    provider;
+    model;
+    constructor(config = {}) {
+        this.provider = config.provider || "openai";
+        this.model = config.model || "text-embedding-3-small";
+    }
+    /**
+     * Get embedding for a single text
+     */
+    async getEmbedding(text) {
+        if (!text)
+            return [];
+        try {
+            if (this.provider === "openai") {
+                // Use the shared provider implementation
+                // Note: OpenAIProvider will handle auth, retries, and error logging
+                return await openaiProvider.embed(text, { model: this.model });
+            }
+            // Fallback or other providers would go here
+            console.warn(`Provider ${this.provider} not supported for embeddings yet.`);
+            return [];
+        }
+        catch (error) {
+            console.error(`Failed to generate embedding: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Get embeddings for multiple texts (batch)
+     */
+    async getEmbeddings(texts) {
+        if (!texts || texts.length === 0)
+            return [];
+        try {
+            if (this.provider === "openai") {
+                return await openaiProvider.embedBatch(texts, { model: this.model });
+            }
+            return [];
+        }
+        catch (error) {
+            console.error(`Failed to generate batch embeddings: ${error.message}`);
+            return [];
+        }
+    }
+}