@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/translator/client/byok.provider.js

@@ -0,0 +1,319 @@
+"use strict";
+/**
+ * BYOK (Bring Your Own Key) Translation Provider
+ *
+ * Direct integration with Anthropic, OpenAI, Gemini, Groq and OpenRouter for
+ * users who provide their own API keys. Zero Babelize AI credits consumed.
+ *
+ * Contract: returns a translation only for entries the model actually
+ * translated. An entry it skipped or garbled is simply absent from the
+ * response, and the engine reports it as a failed key — never as the source
+ * text.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BYOKTranslatorClient = void 0;
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.parseTranslations = parseTranslations;
+const types_1 = require("@babelize/types");
+const retry_1 = require("./retry");
+const language_codes_1 = require("../language-codes");
+const icu_message_1 = require("../../../utils/icu-message");
+// Rough character to token ratio
+const CHAR_TO_TOKEN_RATIO = 4;
+const RETRY = { baseDelayMs: 1000, maxRetries: 3, timeoutMs: 120000 };
+const TOOL_NAME = 'submit_translations';
+class BYOKTranslatorClient {
+    constructor(config) {
+        this.config = config;
+    }
+    async health() {
+        try {
+            const def = types_1.PROVIDER_DEFINITIONS[this.config.provider];
+            if (!def)
+                return false;
+            // Lightweight call that validates the key is live: list models.
+            if (this.config.provider === 'anthropic') {
+                const res = await fetch(`${def.baseUrl}/models`, {
+                    headers: { 'x-api-key': this.config.apiKey, 'anthropic-version': '2023-06-01' },
+                    signal: AbortSignal.timeout(10000),
+                });
+                return res.ok;
+            }
+            const res = await fetch(`${def.baseUrl}/models`, {
+                headers: { Authorization: `Bearer ${this.config.apiKey}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async warmup() {
+        return true;
+    }
+    async translate(req, signal) {
+        const entries = req.entries.map((e) => ({
+            id: e.key,
+            text: e.value,
+            ...(e.context ? { context: e.context } : {}),
+            ...(e.extractionContext ? { element: e.extractionContext.replace(/^hardcoded-/, '') } : {}),
+            ...(req.hints?.[e.key] ? { note: req.hints[e.key] } : {}),
+        }));
+        const system = buildSystemPrompt(req, entries);
+        const user = JSON.stringify({ entries }, null, 1);
+        // Resolved before any request: a missing model is a configuration error,
+        // not something a retry can fix.
+        const model = this.getModel();
+        const retry = { ...RETRY, signal };
+        const { content, usage } = this.config.provider === 'anthropic'
+            ? await this.callAnthropic(model, system, user, retry)
+            : await this.callOpenAICompatible(model, system, user, retry);
+        const ids = new Set(entries.map((e) => e.id));
+        return {
+            translations: parseTranslations(content, ids),
+            model,
+            metadata: { provider: this.config.provider, usage },
+        };
+    }
+    getModel() {
+        if (this.config.model)
+            return this.config.model;
+        const def = types_1.PROVIDER_DEFINITIONS[this.config.provider];
+        if (!def?.defaultModel) {
+            throw new Error(`No model configured for ${this.getProviderDisplayName()}. Pass a model explicitly.`);
+        }
+        return def.defaultModel;
+    }
+    getBaseUrl() {
+        const def = types_1.PROVIDER_DEFINITIONS[this.config.provider];
+        if (!def)
+            throw new Error(`Unknown provider: ${this.config.provider}`);
+        if (this.config.provider === 'anthropic') {
+            return `${def.baseUrl}/messages`;
+        }
+        return `${def.baseUrl}/chat/completions`;
+    }
+    getProviderDisplayName() {
+        return types_1.PROVIDER_DEFINITIONS[this.config.provider]?.name || this.config.provider;
+    }
+    /** Anthropic: force a tool call so the output is schema-shaped JSON. */
+    async callAnthropic(model, system, user, retry = RETRY) {
+        const response = await (0, retry_1.withRetry)(async (signal) => {
+            const res = await fetch(this.getBaseUrl(), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.config.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 8192,
+                    temperature: 0,
+                    system,
+                    tools: [{
+                            name: TOOL_NAME,
+                            description: 'Submit the translation of every entry.',
+                            input_schema: {
+                                type: 'object',
+                                properties: {
+                                    translations: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: { id: { type: 'string' }, value: { type: 'string' } },
+                                            required: ['id', 'value'],
+                                        },
+                                    },
+                                },
+                                required: ['translations'],
+                            },
+                        }],
+                    tool_choice: { type: 'tool', name: TOOL_NAME },
+                    messages: [{ role: 'user', content: user }],
+                }),
+                signal,
+            });
+            if (!res.ok)
+                throw await this.httpError(res);
+            return res.json();
+        }, retry);
+        const block = (response.content ?? []).find((b) => b.type === 'tool_use');
+        return { content: block?.input ?? response.content?.find((b) => b.type === 'text')?.text, usage: response.usage };
+    }
+    async callOpenAICompatible(model, system, user, retry = RETRY) {
+        const body = {
+            model,
+            messages: [
+                { role: 'system', content: system },
+                { role: 'user', content: user },
+            ],
+        };
+        // Reasoning models reject a temperature other than the default.
+        if (!/^(?:openai\/)?(?:o\d|gpt-5)/.test(model))
+            body.temperature = 0;
+        // JSON mode where the API guarantees it.
+        if (this.config.provider === 'openai' || this.config.provider === 'groq') {
+            body.response_format = { type: 'json_object' };
+        }
+        const response = await (0, retry_1.withRetry)(async (signal) => {
+            const res = await fetch(this.getBaseUrl(), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!res.ok)
+                throw await this.httpError(res);
+            return res.json();
+        }, retry);
+        return { content: response.choices?.[0]?.message?.content ?? '', usage: response.usage };
+    }
+    async httpError(res) {
+        const detail = this.redactApiKey((await res.text().catch(() => '')).slice(0, 300));
+        return new retry_1.ProviderHttpError(this.formatApiError(res.status, detail), res.status, (0, retry_1.parseRetryAfter)(res.headers.get('retry-after')));
+    }
+    formatApiError(status, detail) {
+        const name = this.getProviderDisplayName();
+        switch (status) {
+            case 401:
+            case 403:
+                return `${name} API error: Invalid or expired API key. Check your key in Settings.`;
+            case 402:
+                return `${name} API error: Insufficient credits on your account.`;
+            case 429:
+                return `${name} API error: Rate limit exceeded. Please wait and try again, or upgrade your plan.`;
+            case 404:
+                return `${name} API error: Model "${this.getModel()}" was not found. Check the selected model.`;
+            default:
+                if (status >= 500) {
+                    return `${name} API error (${status}). Server issue — please try again later.`;
+                }
+                return `${name} API error (${status})${detail ? `: ${detail}` : '. Please try again.'}`;
+        }
+    }
+    redactApiKey(body) {
+        if (typeof body === 'string' && this.config.apiKey) {
+            return body.split(this.config.apiKey).join('[REDACTED]');
+        }
+        return body;
+    }
+    /**
+     * Estimate token count and cost for a translation request
+     */
+    static estimateCost(entries, provider) {
+        const totalChars = entries.reduce((sum, e) => sum + e.value.length, 0);
+        const estimatedTokens = Math.ceil(totalChars / CHAR_TO_TOKEN_RATIO);
+        const pricing = types_1.PROVIDER_PRICING[provider];
+        const estimatedCost = pricing
+            ? Math.round((estimatedTokens / 1000000) * pricing.input * 10000) / 10000
+            : null;
+        return {
+            estimatedTokens,
+            estimatedCost,
+            currency: 'USD',
+        };
+    }
+}
+exports.BYOKTranslatorClient = BYOKTranslatorClient;
+function languageName(code) {
+    try {
+        const name = new Intl.DisplayNames(['en'], { type: 'language' }).of(code);
+        return name && name !== code ? `${name} (${code})` : code;
+    }
+    catch {
+        return code;
+    }
+}
+function safeFromFlores(flores) {
+    try {
+        return (0, language_codes_1.fromFlores)(flores);
+    }
+    catch {
+        return flores;
+    }
+}
+function buildSystemPrompt(req, entries) {
+    const targetCode = req.targetLocale || safeFromFlores(req.targetLang);
+    const source = languageName(safeFromFlores(req.sourceLang));
+    const target = languageName(targetCode);
+    const rules = [
+        `You are a professional software localizer. Translate the user-interface strings of a web application from ${source} into ${target}.`,
+        '',
+        'Input: a JSON object with `entries`. Each entry has `id` (the string key in the codebase — a hint about meaning, never translate it), `text` (translate this), and optionally `context` (the full sentence this fragment belongs to — use it to pick the right words, but translate only `text`), `element` (where the string appears, e.g. button, label, placeholder, aria-label) and `note` (a correction from a previous attempt — follow it).',
+        '',
+        `Output: call ${TOOL_NAME} (or reply with only a JSON object) of the form {"translations":[{"id":"…","value":"…"}]}, with exactly one item per input id and nothing else.`,
+        '',
+        'Rules:',
+        '1. Tokens such as [#VAR_0#] stand for variables, markup tags, links or brand names. Copy every token exactly once and unchanged; move it if the target grammar needs a different word order. Never translate, add, merge or drop tokens.',
+        '2. Write natural, idiomatic UI text as a native speaker would — not a word-for-word rendering. Keep it concise: buttons, labels and menu items should stay short.',
+        '3. Use one consistent formality level and terminology across all entries, matching what is conventional for modern software in the target language.',
+        "4. Follow the target language's punctuation, capitalization and spacing conventions. Keep any leading or trailing whitespace.",
+        '5. If a text is a proper name, a code identifier, or is already correct in the target language (e.g. "OK", "Email" where that is the norm), return it unchanged.',
+        '6. Never explain, never add quotes or notes, never leave text in the source language unless rule 5 applies.',
+    ];
+    if (entries.some((e) => (0, icu_message_1.isIcuMessage)(e.text))) {
+        const { cardinal, ordinal } = (0, icu_message_1.requiredPluralCategories)(targetCode);
+        rules.push(`7. Some texts are ICU MessageFormat messages ({name, plural, …}, {name, select, …}, {name, selectordinal, …}). Keep argument names, select keys, "=N" keys, "#", and any tags, links and code exactly; translate only the text inside the branches. For plural use exactly the ${target} categories [${cardinal.join(', ')}] and for selectordinal [${ordinal.join(', ')}], always including "other". The result must be a valid ICU message.`);
+    }
+    if (entries.some((e) => (0, icu_message_1.countArguments)(e.text).length > 0)) {
+        const { cardinal } = (0, icu_message_1.requiredPluralCategories)(targetCode);
+        rules.push(`8. Some texts contain {name} arguments in braces instead of tokens. Keep every argument name and tag exactly. When the note says an argument is a number and ${target} changes the surrounding words by number, return an ICU plural over that argument, e.g. {files, plural, one {# …} other {# …}}, with exactly the ${target} categories [${cardinal.join(', ')}], "other" included and "#" in every branch. If ${target} doesn't change words by number, return plain text with the {name} argument.`);
+    }
+    if (req.glossary?.length) {
+        rules.push('', 'Required terminology — use these translations whenever the term appears (inflect them if grammar requires):');
+        for (const g of req.glossary)
+            rules.push(`- "${g.term}" → "${g.translation}"`);
+    }
+    if (req.brandVoice) {
+        rules.push('', 'Brand voice — follow this tone and style; it takes priority over rule 3:', req.brandVoice);
+    }
+    return rules.join('\n');
+}
+/**
+ * Pull `{translations:[{id, value}]}` out of a tool input object or a text
+ * reply (tolerating code fences and surrounding prose). Returns only entries
+ * whose id was requested and whose value is a string; nothing is invented.
+ */
+function parseTranslations(content, requestedIds) {
+    let data = content;
+    if (typeof content === 'string') {
+        data = parseJsonLoosely(content);
+    }
+    const list = data?.translations;
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        const id = item && typeof item === 'object' ? String(item.id ?? '') : '';
+        const value = item?.value;
+        if (!requestedIds.has(id) || seen.has(id) || typeof value !== 'string')
+            continue;
+        seen.add(id);
+        out.push({ key: id, value });
+    }
+    return out;
+}
+function parseJsonLoosely(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const start = trimmed.indexOf('{');
+        const end = trimmed.lastIndexOf('}');
+        if (start === -1 || end <= start)
+            return null;
+        try {
+            return JSON.parse(trimmed.slice(start, end + 1));
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/modules/translator/client/direct-translator.client.d.ts

@@ -0,0 +1,12 @@
+import type { HFTranslateRequest, HFTranslateResponse } from './request.types';
+import type { TranslatorClient } from './translator.interface';
+/**
+ * HTTP client for the Babelize translator service.
+ */
+export declare class DirectTranslatorClient implements TranslatorClient {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    health(): Promise<boolean>;
+    warmup(): Promise<boolean>;
+    translate(req: HFTranslateRequest): Promise<HFTranslateResponse>;
+}

package/dist/modules/translator/client/direct-translator.client.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectTranslatorClient = void 0;
+const retry_1 = require("./retry");
+/**
+ * HTTP client for the Babelize translator service.
+ */
+class DirectTranslatorClient {
+    constructor(baseUrl) {
+        const url = baseUrl?.trim() || process.env.TRANSLATOR_URL?.trim();
+        if (!url) {
+            throw new Error('TRANSLATOR_URL environment variable is required');
+        }
+        this.baseUrl = url;
+    }
+    async health() {
+        return await (0, retry_1.withRetry503)(async (signal) => {
+            const res = await fetch(`${this.baseUrl}/health`, { method: 'GET', signal });
+            return res.ok;
+        }, { baseDelayMs: 5000, maxRetries: 3, timeoutMs: 30000 });
+    }
+    async warmup() {
+        // Warmup should be tolerant of cold starts; 30s per call, exponential backoff.
+        try {
+            return await (0, retry_1.withRetry503)(async (signal) => {
+                const res = await fetch(`${this.baseUrl}/warmup`, { method: 'POST', signal });
+                return res.ok;
+            }, { baseDelayMs: 5000, maxRetries: 3, timeoutMs: 30000 });
+        }
+        catch {
+            return false;
+        }
+    }
+    async translate(req) {
+        const payload = {
+            entries: req.entries,
+            sourceLang: req.sourceLang,
+            targetLang: req.targetLang,
+        };
+        const res = await (0, retry_1.withRetry503)(async (signal) => {
+            const r = await fetch(`${this.baseUrl}/translate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal,
+            });
+            if (r.status === 503) {
+                throw new Error('Translator service warming (503)');
+            }
+            if (!r.ok) {
+                const body = await safeReadText(r);
+                throw new Error(`Translate failed: ${r.status} ${r.statusText}${body ? ` — ${body}` : ''}`);
+            }
+            const data = (await r.json());
+            if (!data || !Array.isArray(data.translations)) {
+                throw new Error('Translate returned invalid response');
+            }
+            return data;
+        }, { baseDelayMs: 5000, maxRetries: 3, timeoutMs: 30000 });
+        return res;
+    }
+}
+exports.DirectTranslatorClient = DirectTranslatorClient;
+async function safeReadText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}

package/dist/modules/translator/client/gemini.provider.d.ts

@@ -0,0 +1 @@
+export declare function polishWithBrandVoice(translations: Record<string, string>, brandVoice: string, targetLocale: string): Promise<Record<string, string>>;

package/dist/modules/translator/client/gemini.provider.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polishWithBrandVoice = polishWithBrandVoice;
+const env_1 = require("../../../config/env");
+const logger_1 = require("../../../utils/logger");
+const GEMINI_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/openai';
+const DEFAULT_MODEL = 'models/gemini-3.1-flash-lite';
+function getGeminiApiKey() {
+    return env_1.config.GEMINI_API_KEY?.trim() || null;
+}
+function buildSystemPrompt(brandVoice) {
+    return `You are a brand voice editor. Adjust the tone and style of the following translations to match this brand voice:
+
+"${brandVoice}"
+
+Rules:
+- Never change the meaning, only the tone
+- Preserve ALL keys exactly as provided
+- Return ONLY valid JSON with the same keys
+- Preserve all placeholders like {0}, {name}, [#VAR_0#], etc.
+- Keep proper nouns and technical terms unchanged`;
+}
+function buildUserMessage(translations, targetLocale) {
+    return `Polish these ${targetLocale} translations to match the brand voice. Return JSON with the same keys:
+
+${JSON.stringify(translations, null, 2)}
+
+Return ONLY the JSON response:`;
+}
+function parseResponse(content, originalKeys) {
+    try {
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return null;
+        const parsed = JSON.parse(jsonMatch[0]);
+        const translations = parsed.translations || parsed.polished || parsed;
+        if (typeof translations !== 'object' || translations === null)
+            return null;
+        const result = {};
+        for (const key of originalKeys) {
+            const val = translations[key];
+            result[key] = typeof val === 'string' ? val : '';
+        }
+        for (const key of originalKeys) {
+            if (!result[key]) {
+                return null;
+            }
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+async function polishWithBrandVoice(translations, brandVoice, targetLocale) {
+    const apiKey = getGeminiApiKey();
+    if (!apiKey) {
+        logger_1.engineLogger.warn('GEMINI_API_KEY not set, skipping brand voice polish');
+        return translations;
+    }
+    const originalKeys = Object.keys(translations);
+    if (originalKeys.length === 0)
+        return translations;
+    try {
+        const response = await fetch(`${GEMINI_BASE_URL}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model: DEFAULT_MODEL,
+                messages: [
+                    { role: 'system', content: buildSystemPrompt(brandVoice) },
+                    { role: 'user', content: buildUserMessage(translations, targetLocale) },
+                ],
+                temperature: 0.3,
+                max_tokens: Math.min(originalKeys.length * 200, 8192),
+            }),
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            logger_1.engineLogger.warn('Gemini brand voice API error', {
+                status: response.status,
+                error: errorText,
+            });
+            return translations;
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content || '';
+        const polished = parseResponse(content, originalKeys);
+        if (!polished) {
+            logger_1.engineLogger.warn('Gemini brand voice response parse failed, falling back to original');
+            return translations;
+        }
+        logger_1.engineLogger.info('Brand voice polish applied via Gemini', {
+            model: data.model || DEFAULT_MODEL,
+            keys: originalKeys.length,
+            usage: data.usage,
+        });
+        return polished;
+    }
+    catch (err) {
+        logger_1.engineLogger.warn('Gemini brand voice request failed, falling back to original', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return translations;
+    }
+}

package/dist/modules/translator/client/groq.provider.d.ts

@@ -0,0 +1 @@
+export declare function polishWithBrandVoice(translations: Record<string, string>, brandVoice: string, targetLocale: string): Promise<Record<string, string>>;

package/dist/modules/translator/client/groq.provider.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polishWithBrandVoice = polishWithBrandVoice;
+const env_1 = require("../../../config/env");
+const logger_1 = require("../../../utils/logger");
+const GROQ_BASE_URL = 'https://api.groq.com/openai/v1';
+function getGroqApiKey() {
+    return env_1.config.GROQ_API_KEY?.trim() || null;
+}
+function buildSystemPrompt(brandVoice) {
+    return `You are a brand voice editor. Adjust the tone and style of the following translations to match this brand voice:
+
+"${brandVoice}"
+
+Rules:
+- Never change the meaning, only the tone
+- Preserve ALL keys exactly as provided
+- Return ONLY valid JSON with the same keys
+- Preserve all placeholders like {0}, {name}, [#VAR_0#], etc.
+- Keep proper nouns and technical terms unchanged`;
+}
+function buildUserMessage(translations, targetLocale) {
+    return `Polish these ${targetLocale} translations to match the brand voice. Return JSON with the same keys:
+
+${JSON.stringify(translations, null, 2)}
+
+Return ONLY the JSON response:`;
+}
+function parseResponse(content, originalKeys) {
+    try {
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return null;
+        const parsed = JSON.parse(jsonMatch[0]);
+        // Try to find the translations object - could be the top-level or nested
+        const translations = parsed.translations || parsed.polished || parsed;
+        if (typeof translations !== 'object' || translations === null)
+            return null;
+        const result = {};
+        for (const key of originalKeys) {
+            const val = translations[key];
+            result[key] = typeof val === 'string' ? val : '';
+        }
+        // Ensure all keys are present (fallback to original if missing)
+        for (const key of originalKeys) {
+            if (!result[key]) {
+                return null; // Missing keys, return null to trigger fallback
+            }
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+async function polishWithBrandVoice(translations, brandVoice, targetLocale) {
+    const apiKey = getGroqApiKey();
+    if (!apiKey) {
+        logger_1.engineLogger.warn('GROQ_API_KEY not set, skipping brand voice polish');
+        return translations;
+    }
+    const originalKeys = Object.keys(translations);
+    if (originalKeys.length === 0)
+        return translations;
+    try {
+        const response = await fetch(`${GROQ_BASE_URL}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model: 'llama-3.3-70b-versatile',
+                messages: [
+                    { role: 'system', content: buildSystemPrompt(brandVoice) },
+                    { role: 'user', content: buildUserMessage(translations, targetLocale) },
+                ],
+                temperature: 0.3,
+                max_tokens: Math.min(originalKeys.length * 200, 4096),
+            }),
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            logger_1.engineLogger.warn('Groq brand voice API error', {
+                status: response.status,
+                error: errorText,
+            });
+            return translations;
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content || '';
+        const polished = parseResponse(content, originalKeys);
+        if (!polished) {
+            logger_1.engineLogger.warn('Groq brand voice response parse failed, falling back to original');
+            return translations;
+        }
+        logger_1.engineLogger.info('Brand voice polish applied via Groq', {
+            model: data.model || 'llama-3.3-70b-versatile',
+            keys: originalKeys.length,
+            usage: data.usage,
+        });
+        return polished;
+    }
+    catch (err) {
+        logger_1.engineLogger.warn('Groq brand voice request failed, falling back to original', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return translations;
+    }
+}

package/dist/modules/translator/client/request.types.d.ts

@@ -0,0 +1 @@
+export type { HFTranslateRequest, HFTranslateResponse } from '../../../types';

package/dist/modules/translator/client/request.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/translator/client/retry.d.ts

@@ -0,0 +1,29 @@
+export interface RetryOptions {
+    baseDelayMs: number;
+    maxRetries: number;
+    timeoutMs: number;
+    /** Upper bound for a single wait, including server-requested Retry-After. */
+    maxDelayMs?: number;
+    /** Aborts the attempt in flight and stops any further retries. */
+    signal?: AbortSignal;
+}
+/** An HTTP error from a translation API, carrying what retry decisions need. */
+export declare class ProviderHttpError extends Error {
+    readonly status: number;
+    /** Server-requested wait from a Retry-After header, in ms. */
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, status: number, 
+    /** Server-requested wait from a Retry-After header, in ms. */
+    retryAfterMs?: number | undefined);
+}
+/** Parse a Retry-After header (seconds or HTTP date) into milliseconds. */
+export declare function parseRetryAfter(header: string | null): number | undefined;
+/**
+ * Retry only what can succeed on a second try: timeouts, network errors,
+ * 408/409/425/429 and 5xx. Auth, bad request and unknown model (other 4xx)
+ * fail immediately — retrying a bad key just delays the error.
+ */
+export declare function isRetryable(err: unknown): boolean;
+export declare function withRetry<T>(fn: (signal: AbortSignal) => Promise<T>, opts: RetryOptions): Promise<T>;
+/** @deprecated Use withRetry — kept for existing callers. */
+export declare const withRetry503: typeof withRetry;