locai 2.6.1 → 2.7.0

package/dist/core/pipeline/steps/ContextEnrichmentStep.js

@@ -14,26 +14,15 @@ export default class ContextEnrichmentStep extends PipelineStep {
                 await this.analyzer.ensureInitialized();
                 const codeContext = this.analyzer.getContext(context.key);
                 if (codeContext) {
-                    // Enrich the context meta
+                    // TranslationStep forwards meta to the provider as `detectedContext`,
+                    // and the prompt templates render `code` (see prompt-templates.ts).
                     context.meta = {
                         ...context.meta,
                         code: codeContext,
                     };
-                    // Also append to the AI prompt context if it exists
-                    // (Assuming existing translation prompt uses contextData)
-                    context.contextData = {
-                        ...(context.contextData || {}),
-                        visualContext: {
-                            component: codeContext.component,
-                            file: codeContext.filePath,
-                            comments: codeContext.comments,
-                            props: codeContext.props,
-                            snippet: codeContext.usageSnippet,
-                        },
-                    };
                 }
             }
-            catch (error) {
+            catch {
                 // Non-blocking error
                 // console.warn(`Context enrichment failed for ${context.key}`, error);
             }

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

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

package/dist/core/pipeline/steps/QualityCheckStep.js

@@ -18,7 +18,6 @@ class QualityCheckStep extends PipelineStep {
         if (this.qualityChecker && this.qualityChecker.rules?.enabled !== false) {
             const qualityResult = this.qualityChecker.validateAndFix(context.sourceText, context.translatedText);
             translated = qualityResult.fixedText;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             context.qualityResult = qualityResult;
         }
         // 2. JSON Validity Check
@@ -39,7 +38,6 @@ class QualityCheckStep extends PipelineStep {
             translated: context.translatedText,
             context: context.meta,
             success: true,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             qualityChecks: context.qualityResult,
         };
         await next();

package/dist/core/pipeline/steps/ToneCheckStep.js

@@ -23,7 +23,7 @@ export class ToneCheckStep extends PipelineStep {
             const styleGuide = context.options.styleGuide;
             const provider = styleGuide.toneProvider;
             const options = styleGuide.analysisOptions;
-            const result = await this.verifier.verify(context.sourceText, context.translatedText, context.sourceLang, context.targetLang, styleGuide.toneOfVoice, provider, options);
+            const result = await this.verifier.verify(context.sourceText, context.translatedText, context.sourceLang, context.targetLang, context.options.styleGuide.toneOfVoice, provider, options);
             if (!result.passed) {
                 if (this.debug) {
                     console.warn(`[ToneCheck] Failed: Score ${result.score}/10. Reason: ${result.reasoning}`);

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

@@ -1,21 +1,31 @@
 import PipelineStep from "../PipelineStep.js";
 import { AIProvider } from "../../provider-factory.js";
 import { TranslationContext } from "../context.js";
+import type { TranslateOptions } from "../../../providers/base-provider.js";
+import type { ReviewQueueItem, TranslationRef } from "../../../utils/review-queue.js";
 export interface ConfidenceSettings {
     enabled: boolean;
     autoApproveThreshold: number;
     rejectThreshold: number;
     reviewThreshold: number;
     saveReviewQueue: boolean;
-    reviewQueue: any[];
+    /** Translations scored below reviewThreshold in this run, rejected ones included. */
+    reviewQueue: ReviewQueueItem[];
+    /** Every translation scored in this run. */
+    scored: TranslationRef[];
     autoApprovedCount: number;
     rejectedCount: number;
-    [key: string]: any;
+}
+/** Options TranslationStep reads; the whole object is also forwarded to the provider. */
+export interface TranslationStepOptions extends TranslateOptions {
+    apiProvider?: string;
+    useFallback?: boolean;
+    fallbackOrder?: string[];
 }
 declare class TranslationStep extends PipelineStep {
     private options;
     private confidenceSettings;
-    constructor(options?: any, confidenceSettings?: Partial<ConfidenceSettings>);
+    constructor(options?: TranslationStepOptions, confidenceSettings?: Partial<ConfidenceSettings>);
     execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
     _getProvider(): AIProvider;
 }

package/dist/core/pipeline/steps/TranslationStep.js

@@ -1,12 +1,10 @@
 import PipelineStep from "../PipelineStep.js";
 import ProviderFactory from "../../provider-factory.js";
+import ConfidenceScorer from "../../../utils/confidence-scorer.js";
 class TranslationStep extends PipelineStep {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options;
     confidenceSettings;
-    constructor(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    options = {}, confidenceSettings = {}) {
+    constructor(options = {}, confidenceSettings = {}) {
         super();
         this.options = options;
         this.confidenceSettings = confidenceSettings;
@@ -14,6 +12,7 @@ class TranslationStep extends PipelineStep {
     async execute(context, next) {
         try {
             const provider = this._getProvider();
+            const text = context.protectedText || context.sourceText;
             // Setup translation options
             const translationOpts = {
                 ...this.options,
@@ -22,29 +21,29 @@ class TranslationStep extends PipelineStep {
                     existingTranslation: context.existingTranslation || null,
                 },
             };
-            // Handling Confidence Scoring if enabled
-            if (this.confidenceSettings.enabled &&
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                typeof provider.extractTranslationWithConfidence === "function") {
-                const rawResponse = await provider.translate(context.protectedText || context.sourceText, context.sourceLang, context.targetLang, { ...translationOpts, returnRawResponse: true });
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const result = provider.extractTranslationWithConfidence(rawResponse, 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                provider.name || "unknown", context.protectedText || context.sourceText, context.sourceLang, context.targetLang, context.meta?.category);
-                context.translatedText = result.translation;
-                context.confidence = result.confidence;
-            }
-            else {
-                // Standard translation
-                context.translatedText = await provider.translate(context.protectedText || context.sourceText, context.sourceLang, context.targetLang, translationOpts);
-                context.confidence = undefined; // Use undefined instead of null for optional typings often
+            context.translatedText = await provider.translate(text, context.sourceLang, context.targetLang, translationOpts);
+            // Score what the provider returned, before glossary restoration and quality fixes
+            if (this.confidenceSettings.enabled) {
+                context.confidence = ConfidenceScorer.calculateConfidence({
+                    sourceText: text,
+                    translation: context.translatedText,
+                    sourceLang: context.sourceLang,
+                    targetLang: context.targetLang,
+                    provider: this.options.apiProvider?.toLowerCase() || "unknown",
+                    category: context.meta?.category,
+                });
             }
             // Continue to next steps (restore glossary, quality check, etc.)
             await next();
         }
         catch (error) {
-            console.error(`Translation error - key "${context.key}":`, error);
-            context.result.error = error.message;
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Translation error - key "${context.key}": ${message}`);
+            // The stack is for debugging LocAI itself; show it only with --debug
+            if (process.env.DEBUG === "true" && error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+            context.result.error = message;
             context.result.success = false;
             context.result.translated = context.sourceText; // Fallback to source
             // Stop pipeline or proceed?
@@ -55,7 +54,6 @@ class TranslationStep extends PipelineStep {
     }
     _getProvider() {
         const provider = ProviderFactory.getProvider(this.options.apiProvider, this.options.useFallback !== false, this.options);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!provider || typeof provider.translate !== "function") {
             throw new Error(`Translation provider not available or invalid: ${this.options.apiProvider}`);
         }

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

@@ -7,11 +7,19 @@ export interface VectorMemoryStats {
     contextUsed: number;
     misses: number;
 }
+/** Vector memory settings read by the vector cache steps. */
+export interface VectorCacheOptions {
+    enabled?: boolean;
+    /** Similarity at which a stored translation is reused as-is (default 0.98). */
+    exactMatchThreshold?: number;
+    /** Similarity at which a stored translation is offered to the provider as reference (default 0.85). */
+    similarityThreshold?: number;
+}
 export declare class VectorCacheReadStep extends PipelineStep {
     private vectorStore;
     private embeddingProvider;
     private stats;
     private options;
-    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, stats: VectorMemoryStats, options?: any);
+    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, stats: VectorMemoryStats, options?: VectorCacheOptions);
     execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
 }

package/dist/core/pipeline/steps/VectorCacheReadStep.js

@@ -13,10 +13,7 @@ export class VectorCacheReadStep extends PipelineStep {
     }
     async execute(context, next) {
         // Skip if disabled, or already has result (Exact Cache hit)
-        if (!this.options.enabled ||
-            context.result?.success ||
-            context.result?.fromCache ||
-            context.options?.skipCache) {
+        if (!this.options.enabled || context.result?.success || context.result?.fromCache) {
             await next();
             return;
         }
@@ -76,7 +73,8 @@ export class VectorCacheReadStep extends PipelineStep {
             }
         }
         catch (error) {
-            console.warn(`Vector cache read failed: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Vector cache read failed: ${message}`);
             // Continue pipeline on error
         }
         await next();

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

@@ -2,10 +2,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";
+import { VectorCacheOptions } from "./VectorCacheReadStep.js";
 export declare class VectorCacheWriteStep extends PipelineStep {
     private vectorStore;
     private embeddingProvider;
     private options;
-    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, options?: any);
+    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider, options?: VectorCacheOptions);
     execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
 }

package/dist/core/pipeline/steps/VectorCacheWriteStep.js

@@ -36,7 +36,8 @@ export class VectorCacheWriteStep extends PipelineStep {
             }
         }
         catch (error) {
-            console.warn(`Vector cache write failed: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Vector cache write failed: ${message}`);
         }
     }
 }

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

@@ -1,8 +1,12 @@
-import { ProviderConfig, TranslateOptions } from "../providers/base-provider.js";
+import { ChatMessage, 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>;
+    chat?(messages: ChatMessage[], options?: ProviderConfig): Promise<string>;
+}
+/** No configured provider can translate (no API key); thrown before any per-key work. */
+export declare class NoProviderError extends Error {
+    constructor(message: string);
 }
 /**
  * Factory for creating and managing AI providers.
@@ -11,26 +15,28 @@ export interface AIProvider {
 declare class ProviderFactory {
     /**
      * Get provider instance with intelligent fallback support.
-     * @param {string} providerName - Name of the primary provider.
+     * @param {string} [providerName] - Name of the primary provider; omitted → default fallback chain.
      * @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?: {
+    static getProvider(providerName: string | undefined, useFallback?: boolean, config?: {
         fallbackOrder?: string[];
     } | null): AIProvider;
     /**
      * Get list of available (configured) providers.
-     * @returns {string[]} - Array of provider names with valid API keys.
+     * @returns {string[]} - Array of provider names with valid API keys, in default chain order.
      */
     static getAvailableProviders(): string[];
     /**
-     * Validate that at least one provider is configured.
-     * @returns {string[]} - Array of available providers.
-     * @throws {Error} If no providers are configured.
+     * Fail fast when no provider can translate: with fallback, no provider has an API key;
+     * without it, the configured provider has none.
+     * @param {string} [providerName] - The configured `apiProvider`.
+     * @param {boolean} [useFallback=true] - Whether other providers may be used.
+     * @throws {NoProviderError} If no usable provider is configured.
      */
-    static validateProviders(): string[];
+    static assertProviderAvailable(providerName?: string, useFallback?: boolean): void;
     /**
      * Check if a specific provider is configured.
      * @param {string} providerName - Name of the provider.

package/dist/core/provider-factory.js

@@ -6,6 +6,22 @@ import * as dashscopeProvider from "../providers/dashscope.js";
 import * as xaiProvider from "../providers/xai.js";
 import FallbackProvider from "./fallback-provider.js";
 import rateLimiter from "../utils/rate-limiter.js";
+/** API key environment variable per provider, in the default fallback-chain order. */
+const PROVIDER_API_KEYS = {
+    dashscope: "DASHSCOPE_API_KEY",
+    xai: "XAI_API_KEY",
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    gemini: "GEMINI_API_KEY",
+};
+/** No configured provider can translate (no API key); thrown before any per-key work. */
+export class NoProviderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NoProviderError";
+    }
+}
 /**
  * Factory for creating and managing AI providers.
  * Handles provider instantiation, configuration, and fallback chains.
@@ -13,7 +29,7 @@ import rateLimiter from "../utils/rate-limiter.js";
 class ProviderFactory {
     /**
      * Get provider instance with intelligent fallback support.
-     * @param {string} providerName - Name of the primary provider.
+     * @param {string} [providerName] - Name of the primary provider; omitted → default fallback chain.
      * @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.
@@ -45,13 +61,11 @@ class ProviderFactory {
             };
             if (selected.analyze) {
                 wrappedProvider.analyze = (prompt, options = {}) => {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                     return rateLimiter.enqueue(normalizedProviderName, () => selected.analyze(prompt, options));
                 };
             }
             if (selected.chat) {
                 wrappedProvider.chat = (messages, options = {}) => {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                     return rateLimiter.enqueue(normalizedProviderName, () => selected.chat(messages, options));
                 };
             }
@@ -95,32 +109,36 @@ class ProviderFactory {
     }
     /**
      * Get list of available (configured) providers.
-     * @returns {string[]} - Array of provider names with valid API keys.
+     * @returns {string[]} - Array of provider names with valid API keys, in default chain order.
      */
     static getAvailableProviders() {
-        const providers = {
-            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,
-        };
-        return Object.entries(providers)
-            .filter(([, key]) => !!key)
-            .map(([name]) => name);
+        return Object.keys(PROVIDER_API_KEYS).filter((name) => this.isProviderConfigured(name));
     }
     /**
-     * Validate that at least one provider is configured.
-     * @returns {string[]} - Array of available providers.
-     * @throws {Error} If no providers are configured.
+     * Fail fast when no provider can translate: with fallback, no provider has an API key;
+     * without it, the configured provider has none.
+     * @param {string} [providerName] - The configured `apiProvider`.
+     * @param {boolean} [useFallback=true] - Whether other providers may be used.
+     * @throws {NoProviderError} If no usable provider is configured.
      */
-    static validateProviders() {
-        const available = this.getAvailableProviders();
-        if (available.length === 0) {
-            throw new Error("No API providers configured. Please set at least one API key.");
+    static assertProviderAvailable(providerName, useFallback = true) {
+        const name = (providerName || "").toLowerCase();
+        if (!useFallback) {
+            const envKey = PROVIDER_API_KEYS[name];
+            if (!envKey) {
+                throw new NoProviderError(`Unknown provider "${providerName}" and useFallback is false. ` +
+                    `Supported providers: ${Object.keys(PROVIDER_API_KEYS).join(", ")}.`);
+            }
+            if (!this.isProviderConfigured(name)) {
+                throw new NoProviderError(`No API key for provider "${name}" (useFallback is false, so no other ` +
+                    `provider is tried). Set ${envKey} in the environment, .env or .env.local.`);
+            }
+            return;
+        }
+        if (this.getAvailableProviders().length === 0) {
+            throw new NoProviderError("No AI provider has an API key, so nothing can be translated. Set at least one of " +
+                `${Object.values(PROVIDER_API_KEYS).join(", ")} in the environment, .env or .env.local.`);
         }
-        return available;
     }
     /**
      * Check if a specific provider is configured.
@@ -128,15 +146,7 @@ class ProviderFactory {
      * @returns {boolean} - True if provider has an API key configured.
      */
     static isProviderConfigured(providerName) {
-        const envVarMap = {
-            dashscope: "DASHSCOPE_API_KEY",
-            xai: "XAI_API_KEY",
-            openai: "OPENAI_API_KEY",
-            anthropic: "ANTHROPIC_API_KEY",
-            deepseek: "DEEPSEEK_API_KEY",
-            gemini: "GEMINI_API_KEY",
-        };
-        const envKey = envVarMap[providerName.toLowerCase()];
+        const envKey = PROVIDER_API_KEYS[providerName.toLowerCase()];
         return !!(envKey && process.env[envKey]);
     }
 }

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,5 @@
-import BaseProvider, { ProviderConfig, TranslateOptions } from "./base-provider.js";
+import BaseProvider, { ChatMessage, ProviderConfig, TranslateOptions } from "./base-provider.js";
+import type { AnthropicMessagesResponse, ProviderResponseBody } from "./api-types.js";
 /**
  * Provider implementation for Anthropic (Claude) models.
  */
@@ -16,10 +17,10 @@ declare class AnthropicProvider extends BaseProvider {
      */
     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;
+    chat(messages: ChatMessage[], options?: ProviderConfig): Promise<string>;
+    extractTranslation(response: AnthropicMessagesResponse | ProviderResponseBody, 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>;
+declare function chat(messages: ChatMessage[], options?: ProviderConfig): Promise<string>;
 export { translate, analyze, chat, AnthropicProvider };

package/dist/providers/anthropic.js

@@ -22,7 +22,6 @@ class AnthropicProvider extends BaseProvider {
             },
             timeout: config.timeoutMs || 60000,
             maxRedirects: 0,
-            validateStatus: (status) => status < 500,
         });
     }
     getApiKey() {
@@ -153,7 +152,9 @@ class AnthropicProvider extends BaseProvider {
                 return textBlock.text.trim();
             }
         }
-        // Fallback to base implementation for other structures (though unlikely for Anthropic)
+        // Fallback to base implementation for other structures (though unlikely for Anthropic).
+        // The base only reads a string `content`, so a reply without a text block ends in its
+        // "Unable to extract translation" error.
         return super.extractTranslation(response, providerName);
     }
 }

package/dist/providers/api-types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Response bodies of the provider HTTP APIs, limited to the fields LocAI reads.
+ * Every field is optional: bodies come from the network and are checked before use.
+ */
+/** Error object some APIs return in a 2xx/4xx body instead of a result. */
+export interface ApiErrorBody {
+    message?: string;
+    error?: string;
+}
+interface ApiErrorEnvelope {
+    error?: ApiErrorBody;
+}
+/** One choice of an OpenAI-compatible chat completion (OpenAI, DeepSeek, xAI, DashScope compatible mode). */
+export interface ChatCompletionChoice {
+    message?: {
+        content?: string | null;
+    };
+    /** Legacy completions API. */
+    text?: string;
+    /** Streaming chunk. */
+    delta?: {
+        content?: string;
+    };
+    finish_reason?: string;
+}
+export interface ChatCompletionResponse extends ApiErrorEnvelope {
+    choices?: ChatCompletionChoice[];
+}
+/** Google Gemini `models/{model}:generateContent`. */
+export interface GeminiGenerateContentResponse extends ApiErrorEnvelope {
+    candidates?: Array<{
+        content?: {
+            parts?: Array<{
+                text?: string;
+            }>;
+        };
+        finishReason?: string;
+    }>;
+}
+/** Alibaba DashScope native `text-generation/generation`. */
+export interface DashScopeGenerationResponse extends ApiErrorEnvelope {
+    output?: {
+        text?: string;
+    };
+}
+/** One block of an Anthropic Messages reply; only `type: "text"` blocks carry `text`. */
+export interface AnthropicContentBlock {
+    type: string;
+    text?: string;
+}
+/** Anthropic `/v1/messages`. */
+export interface AnthropicMessagesResponse extends ApiErrorEnvelope {
+    content?: AnthropicContentBlock[];
+}
+/** OpenAI `/v1/embeddings`. */
+export interface EmbeddingResponse {
+    data?: Array<{
+        index: number;
+        embedding: number[];
+    }>;
+}
+/**
+ * Every body shape the generic `BaseProvider.extractTranslation` understands:
+ * the OpenAI-compatible, Gemini and DashScope responses, plain `text` / `content`
+ * strings, and an un-unwrapped Axios response whose `data` is a chat completion.
+ * `content` may also be an Anthropic block array; only a string `content` is read here,
+ * text blocks are extracted by `AnthropicProvider`.
+ */
+export interface ProviderResponseBody extends ChatCompletionResponse, GeminiGenerateContentResponse, DashScopeGenerationResponse {
+    text?: string;
+    content?: string | AnthropicContentBlock[];
+    data?: ChatCompletionResponse;
+}
+export {};

package/dist/providers/api-types.js

@@ -0,0 +1,5 @@
+/**
+ * Response bodies of the provider HTTP APIs, limited to the fields LocAI reads.
+ * Every field is optional: bodies come from the network and are checked before use.
+ */
+export {};

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

@@ -1,35 +1,33 @@
+import type { PromptOptions } from "../utils/prompt-templates.js";
+import type { ProviderResponseBody } from "./api-types.js";
+/**
+ * Model settings for one provider: constructor config, `apiConfig.<provider>` entries,
+ * and per-call options of `analyze()` / `chat()` / `embed()`.
+ */
 export interface ProviderConfig {
     model?: string;
     temperature?: number;
     maxTokens?: number;
-    [key: string]: any;
+    /** HTTP timeout, read once by the provider constructor. */
+    timeoutMs?: number;
+    /** Retry overrides for `analyze()` / `chat()` / `embed()`. */
+    maxRetries?: number;
+    initialDelay?: number;
+    /** OpenAI `chat()`: request a JSON object response. */
+    json?: boolean;
 }
-export interface TranslateOptions {
-    detectedContext?: {
-        category?: string;
-        [key: string]: any;
-    };
-    lengthControl?: {
-        mode?: string;
-        [key: string]: any;
-    };
-    apiConfig?: Record<string, any>;
+/** Options of `translate()`; forwarded to the prompt templates as well. */
+export interface TranslateOptions extends PromptOptions {
+    /** Per-provider overrides, keyed by provider name. */
+    apiConfig?: Record<string, ProviderConfig>;
     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;
+export interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
 }
 declare class BaseProvider {
     name: string;
@@ -40,13 +38,15 @@ declare class BaseProvider {
     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>;
+    analyze(_prompt: string, _options?: ProviderConfig): Promise<string>;
+    chat(_messages: ChatMessage[], _options?: ProviderConfig): 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;
+    validateResponse(response: {
+        data?: unknown;
+    } | null | undefined, providerName: string): boolean;
+    handleApiError(error: unknown, providerName: string): never;
     generatePrompt(text: string, sourceLang: string, targetLang: string, options?: TranslateOptions): string;
     getConfig(options?: ProviderConfig): {
         model: string | undefined;
@@ -56,11 +56,7 @@ declare class BaseProvider {
         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;
+    extractTranslation(response: ProviderResponseBody, providerName: string): string;
     sanitizeTranslation(translation: string): string;
 }
 export default BaseProvider;