transduck 0.1.5 → 0.2.2

package/dist/backend.d.ts

@@ -1,40 +1,7 @@
-interface BuildMessagesParams {
-    sourceText: string;
-    sourceLang: string;
-    targetLang: string;
-    projectContext: string;
-    stringContext: string | null;
-}
-interface TranslateParams extends BuildMessagesParams {
-    apiKey: string;
-    model: string;
-    timeout: number;
-    maxRetries: number;
-    _clientOverride?: any;
-}
-interface BuildPluralMessagesParams {
-    one: string;
-    other: string;
-    sourceLang: string;
-    targetLang: string;
-    projectContext: string;
-    stringContext: string | null;
-}
-interface TranslatePluralParams extends BuildPluralMessagesParams {
-    apiKey: string;
-    model: string;
-    timeout: number;
-    maxRetries: number;
-    _clientOverride?: any;
-}
-export declare function buildMessages(params: BuildMessagesParams): Array<{
-    role: string;
-    content: string;
-}>;
-export declare function translate(params: TranslateParams): Promise<string>;
-export declare function buildPluralMessages(params: BuildPluralMessagesParams): Array<{
-    role: string;
-    content: string;
-}>;
-export declare function translatePlural(params: TranslatePluralParams): Promise<Record<string, string>>;
-export {};
+/**
+ * Translation backend router -- delegates to the configured provider.
+ */
+import type { TransduckConfig } from './config.js';
+export { buildMessages, buildPluralMessages } from './providers/prompts.js';
+export declare function translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<string>;
+export declare function translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<Record<string, string>>;

package/dist/backend.js

@@ -1,89 +1,14 @@
-import OpenAI from 'openai';
-/* eslint-disable no-template-curly-in-string */
-const SYSTEM_TEMPLATE = 'You are a professional translator. Translate the given text from {source_lang} ' +
-    'to {target_lang}. Return ONLY the translated text, nothing else. Preserve any ' +
-    'placeholders like {name}, {{count}}, %s, ${value} exactly as they appear. ' +
-    'Preserve brand names. Match the tone and formality of the original.\n\n' +
-    'Project context: {project_context}';
-const USER_TEMPLATE = `Translate: "{source_text}"\nString context: {string_context}`;
-const PLURAL_SYSTEM_TEMPLATE = 'You are a professional translator. You will be given two plural forms ' +
-    '(one and other) in {source_lang}. Generate ALL plural forms needed in ' +
-    '{target_lang} according to CLDR plural rules. Return ONLY a JSON object ' +
-    'mapping plural categories to translated strings. Do not include explanation.\n\n' +
-    'CRITICAL: Placeholders like {count}, {name}, %s, ${value} are SOFTWARE VARIABLES ' +
-    'that will be replaced by code at runtime. You MUST include them exactly as written ' +
-    'in EVERY plural form, even for zero, one, and two categories where the language ' +
-    'would not normally use a numeral. For example, for Arabic zero: use "{count} ..." ' +
-    'not "لا توجد ...". For Arabic one: use "{count} ..." not "واحدة ...".\n\n' +
-    'Preserve brand names. Match the tone and formality of the original.\n\n' +
-    'CLDR plural categories are: zero, one, two, few, many, other.\n' +
-    'Only include categories that {target_lang} actually uses.\n\n' +
-    'Project context: {project_context}';
-const PLURAL_USER_TEMPLATE = 'Source one form: "{one}"\n' +
-    'Source other form: "{other}"\n' +
-    'String context: {string_context}';
-function safeRender(template, vars) {
-    let result = template;
-    for (const [key, value] of Object.entries(vars)) {
-        result = result.replaceAll(`{${key}}`, value);
-    }
-    return result;
-}
-export function buildMessages(params) {
-    const systemMsg = SYSTEM_TEMPLATE
-        .replace('{source_lang}', params.sourceLang)
-        .replace('{target_lang}', params.targetLang)
-        .replace('{project_context}', params.projectContext);
-    const userMsg = USER_TEMPLATE
-        .replace('{source_text}', params.sourceText)
-        .replace('{string_context}', params.stringContext || 'none');
-    return [
-        { role: 'system', content: systemMsg },
-        { role: 'user', content: userMsg },
-    ];
-}
-export async function translate(params) {
-    const client = params._clientOverride ?? new OpenAI({
-        apiKey: params.apiKey,
-        timeout: params.timeout * 1000,
-        maxRetries: params.maxRetries,
-    });
-    const messages = buildMessages(params);
-    const response = await client.chat.completions.create({
-        model: params.model,
-        messages,
-        temperature: 0.3,
-    });
-    return response.choices[0].message.content.trim();
-}
-export function buildPluralMessages(params) {
-    const systemMsg = safeRender(PLURAL_SYSTEM_TEMPLATE, {
-        source_lang: params.sourceLang,
-        target_lang: params.targetLang,
-        project_context: params.projectContext,
-    });
-    const userMsg = safeRender(PLURAL_USER_TEMPLATE, {
-        one: params.one,
-        other: params.other,
-        string_context: params.stringContext || 'none',
-    });
-    return [
-        { role: 'system', content: systemMsg },
-        { role: 'user', content: userMsg },
-    ];
-}
-export async function translatePlural(params) {
-    const client = params._clientOverride ?? new OpenAI({
-        apiKey: params.apiKey,
-        timeout: params.timeout * 1000,
-        maxRetries: params.maxRetries,
-    });
-    const messages = buildPluralMessages(params);
-    const response = await client.chat.completions.create({
-        model: params.model,
-        messages,
-        temperature: 0.3,
-    });
-    const raw = response.choices[0].message.content.trim();
-    return JSON.parse(raw);
+/**
+ * Translation backend router -- delegates to the configured provider.
+ */
+import { getProvider } from './providers/index.js';
+// Re-export prompts for backward compat (tests import buildMessages from backend)
+export { buildMessages, buildPluralMessages } from './providers/prompts.js';
+export async function translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride) {
+    const provider = await getProvider(config);
+    return provider.translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride);
+}
+export async function translatePlural(one, other, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride) {
+    const provider = await getProvider(config);
+    return provider.translatePlural(one, other, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride);
 }

package/dist/cli.d.ts

@@ -6,6 +6,7 @@ export interface InitOptions {
     context: string;
     sourceLang: string;
     targetLangs: string[];
+    provider?: number;
 }
 export declare function runInit(opts: InitOptions): Promise<string>;
 export interface TranslateOptions {

package/dist/cli.js

@@ -14,19 +14,53 @@ function hash(text) {
     return createHash('sha256').update(text).digest('hex');
 }
 export async function runInit(opts) {
+    const providerChoice = opts.provider ?? 1;
     const config = {
         project: { name: opts.name, context: opts.context },
         languages: { source: opts.sourceLang.toUpperCase(), targets: opts.targetLangs.map(l => l.toUpperCase()) },
         storage: { path: './translations.duckdb' },
-        backend: { api_key_env: 'OPENAI_API_KEY', model: 'gpt-4.1-mini', timeout_seconds: 10, max_retries: 2 },
     };
+    if (providerChoice === 2) {
+        config.backend = {
+            provider: 'claude_api',
+            api_key_env: 'ANTHROPIC_API_KEY',
+            model: 'claude-haiku-4-5-20251001',
+            timeout_seconds: 10,
+            max_retries: 2,
+        };
+    }
+    else if (providerChoice === 3) {
+        config.backend = {
+            provider: 'claude_code',
+            token_env: 'CLAUDE_CODE_OAUTH_TOKEN',
+        };
+    }
+    else {
+        config.backend = {
+            provider: 'openai',
+            api_key_env: 'OPENAI_API_KEY',
+            model: 'gpt-4.1-mini',
+            timeout_seconds: 10,
+            max_retries: 2,
+        };
+    }
     const configPath = join(opts.dir, 'transduck.yaml');
     writeFileSync(configPath, yamlStringify(config));
     const dbPath = join(opts.dir, 'translations.duckdb');
     const store = new TranslationStore(dbPath);
     await store.initialize();
     store.close();
-    return `Created ${configPath}\nCreated ${dbPath}`;
+    const lines = [`Created ${configPath}`, `Created ${dbPath}`];
+    if (providerChoice === 2) {
+        lines.push('', 'Add to your .env file: ANTHROPIC_API_KEY=your-key-here');
+    }
+    else if (providerChoice === 3) {
+        lines.push('', "Run 'claude setup-token' to get your OAuth token, then add to your .env file:", '  CLAUDE_CODE_OAUTH_TOKEN=your-token-here', '', 'Note: claude_code works for CLI warming only. Your app will run in read-only mode.');
+    }
+    else {
+        lines.push('', 'Add to your .env file: OPENAI_API_KEY=your-key-here');
+    }
+    return lines.join('\n');
 }
 export async function runTranslate(opts) {
     const cfg = loadConfig(opts.configPath);
@@ -43,13 +77,7 @@ export async function runTranslate(opts) {
         store.close();
         return `[cached] ${interpolateVars(cached, opts.vars)}`;
     }
-    const apiKey = process.env[cfg.apiKeyEnv];
-    const translated = await backendTranslate({
-        sourceText: opts.text, sourceLang: cfg.sourceLang, targetLang,
-        projectContext: cfg.projectContext, stringContext: opts.stringContext ?? null,
-        apiKey: apiKey, model: cfg.backendModel,
-        timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-    });
+    const translated = await backendTranslate(opts.text, cfg.sourceLang, targetLang, cfg.projectContext, opts.stringContext ?? null, cfg);
     if (!validateTranslation(opts.text, translated)) {
         await store.insert({
             sourceText: opts.text, sourceLang: cfg.sourceLang, targetLang,
@@ -93,14 +121,7 @@ export async function runTranslatePlural(opts) {
     }
     // Cache miss — call backend
     try {
-        const apiKey = process.env[cfg.apiKeyEnv];
-        const forms = await backendTranslatePlural({
-            one: opts.one, other: opts.other,
-            sourceLang: cfg.sourceLang, targetLang,
-            projectContext: cfg.projectContext, stringContext: opts.stringContext ?? null,
-            apiKey: apiKey, model: cfg.backendModel,
-            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-        });
+        const forms = await backendTranslatePlural(opts.one, opts.other, cfg.sourceLang, targetLang, cfg.projectContext, opts.stringContext ?? null, cfg);
         // Validate each form
         const sourcePlaceholders = new Set([
             ...extractPlaceholders(opts.one),
@@ -181,7 +202,6 @@ export async function runWarm(opts) {
     else {
         entries = content.split('\n').filter(l => l.trim()).map(text => ({ text: text.trim() }));
     }
-    const apiKey = process.env[cfg.apiKeyEnv];
     const projectContextHash = hash(cfg.projectContext);
     let translated = 0, skipped = 0, failed = 0;
     for (const entry of entries) {
@@ -199,13 +219,7 @@ export async function runWarm(opts) {
                     continue;
                 }
                 try {
-                    const forms = await backendTranslatePlural({
-                        one: entry.one, other: entry.other,
-                        sourceLang: cfg.sourceLang, targetLang: lang,
-                        projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                        apiKey: apiKey, model: cfg.backendModel,
-                        timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-                    });
+                    const forms = await backendTranslatePlural(entry.one, entry.other, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                     const sourcePlaceholders = new Set([
                         ...extractPlaceholders(entry.one),
                         ...extractPlaceholders(entry.other),
@@ -254,12 +268,7 @@ export async function runWarm(opts) {
                     continue;
                 }
                 try {
-                    const result = await backendTranslate({
-                        sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
-                        projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                        apiKey: apiKey, model: cfg.backendModel,
-                        timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-                    });
+                    const result = await backendTranslate(entry.text, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                     if (validateTranslation(entry.text, result)) {
                         await store.insert({
                             sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
@@ -289,6 +298,7 @@ export async function runWarm(opts) {
 export async function runScan(opts) {
     const cfg = loadConfig(opts.configPath);
     const scanDirs = opts.dirs.length > 0 ? opts.dirs : [process.cwd()];
+    console.log('Scanning...');
     const entries = scanDirectory(scanDirs);
     const regular = entries.filter(e => !e.plural);
     const plurals = entries.filter(e => e.plural);
@@ -328,90 +338,96 @@ export async function runScan(opts) {
     }
     // Warm
     if (opts.warm) {
-        const targetLangs = opts.langs && opts.langs.length > 0
-            ? opts.langs.map(l => l.toUpperCase())
-            : cfg.targetLangs;
-        const store = new TranslationStore(cfg.storagePath);
-        await store.initialize();
-        const apiKey = process.env[cfg.apiKeyEnv];
-        const projectContextHash = hash(cfg.projectContext);
-        let translated = 0;
-        let skipped = 0;
-        let failed = 0;
-        for (const entry of entries) {
-            if (entry.plural) {
-                const sourceKey = entry.one + '\x00' + entry.other;
-                const stringContextHash = hash(entry.context ?? '');
-                for (const lang of targetLangs) {
-                    const cachedForms = await store.lookupPlural({
-                        sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
-                        projectContextHash, stringContextHash,
-                    });
-                    if (Object.keys(cachedForms).length > 0) {
-                        skipped++;
-                        continue;
-                    }
-                    try {
-                        const forms = await backendTranslatePlural({
-                            one: entry.one, other: entry.other,
-                            sourceLang: cfg.sourceLang, targetLang: lang,
-                            projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                            apiKey: apiKey, model: cfg.backendModel,
-                            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
+        if (entries.length === 0) {
+            lines.push('\nNothing to warm — no translatable strings found.');
+        }
+        else {
+            const targetLangs = opts.langs && opts.langs.length > 0
+                ? opts.langs.map(l => l.toUpperCase())
+                : cfg.targetLangs;
+            const store = new TranslationStore(cfg.storagePath);
+            await store.initialize();
+            const projectContextHash = hash(cfg.projectContext);
+            let translated = 0;
+            let skipped = 0;
+            let failed = 0;
+            const total = entries.length * targetLangs.length;
+            let done = 0;
+            for (const entry of entries) {
+                if (entry.plural) {
+                    const sourceKey = entry.one + '\x00' + entry.other;
+                    const stringContextHash = hash(entry.context ?? '');
+                    const label = (entry.one ?? '').slice(0, 40);
+                    for (const lang of targetLangs) {
+                        done++;
+                        const cachedForms = await store.lookupPlural({
+                            sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
+                            projectContextHash, stringContextHash,
                         });
-                        for (const [cat, translatedText] of Object.entries(forms)) {
-                            await store.insertPlural({
-                                sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
-                                projectContextHash, stringContextHash,
-                                pluralCategory: cat, translatedText: translatedText,
-                                model: cfg.backendModel, status: 'translated',
-                            });
+                        if (Object.keys(cachedForms).length > 0) {
+                            skipped++;
+                            console.log(`  [${done}/${total}] ${lang} skipped (cached): ${label}`);
+                            continue;
+                        }
+                        try {
+                            const forms = await backendTranslatePlural(entry.one, entry.other, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
+                            for (const [cat, translatedText] of Object.entries(forms)) {
+                                await store.insertPlural({
+                                    sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
+                                    projectContextHash, stringContextHash,
+                                    pluralCategory: cat, translatedText: translatedText,
+                                    model: cfg.backendModel, status: 'translated',
+                                });
+                            }
+                            translated++;
+                            console.log(`  [${done}/${total}] ${lang} translated: ${label}`);
+                        }
+                        catch {
+                            failed++;
+                            console.log(`  [${done}/${total}] ${lang} failed: ${label}`);
                         }
-                        translated++;
-                    }
-                    catch {
-                        failed++;
                     }
                 }
-            }
-            else {
-                const stringContextHash = hash(entry.context ?? '');
-                for (const lang of targetLangs) {
-                    const cached = await store.lookup({
-                        sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
-                        projectContextHash, stringContextHash,
-                    });
-                    if (cached !== null) {
-                        skipped++;
-                        continue;
-                    }
-                    try {
-                        const result = await backendTranslate({
+                else {
+                    const stringContextHash = hash(entry.context ?? '');
+                    const label = (entry.text ?? '').slice(0, 40);
+                    for (const lang of targetLangs) {
+                        done++;
+                        const cached = await store.lookup({
                             sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
-                            projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                            apiKey: apiKey, model: cfg.backendModel,
-                            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
+                            projectContextHash, stringContextHash,
                         });
-                        if (validateTranslation(entry.text, result)) {
-                            await store.insert({
-                                sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
-                                projectContextHash, stringContextHash,
-                                translatedText: result, model: cfg.backendModel, status: 'translated',
-                            });
-                            translated++;
+                        if (cached !== null) {
+                            skipped++;
+                            console.log(`  [${done}/${total}] ${lang} skipped (cached): ${label}`);
+                            continue;
                         }
-                        else {
+                        try {
+                            const result = await backendTranslate(entry.text, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
+                            if (validateTranslation(entry.text, result)) {
+                                await store.insert({
+                                    sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
+                                    projectContextHash, stringContextHash,
+                                    translatedText: result, model: cfg.backendModel, status: 'translated',
+                                });
+                                translated++;
+                                console.log(`  [${done}/${total}] ${lang} translated: ${label}`);
+                            }
+                            else {
+                                failed++;
+                                console.log(`  [${done}/${total}] ${lang} failed: ${label}`);
+                            }
+                        }
+                        catch {
                             failed++;
+                            console.log(`  [${done}/${total}] ${lang} failed: ${label}`);
                         }
                     }
-                    catch {
-                        failed++;
-                    }
                 }
             }
-        }
-        store.close();
-        lines.push(`\nTranslated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`);
+            store.close();
+            lines.push(`\nTranslated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`);
+        } // end if entries.length > 0
     }
     if (!opts.warm && !opts.outputPath) {
         lines.push(`\nRun 'transduck scan --warm --langs DE,ES' to translate all strings.`);
@@ -450,10 +466,17 @@ program.command('init')
     const context = await ask('Project context: ');
     const sourceLang = await ask('Source language (e.g. EN): ');
     const targetsRaw = await ask('Target languages (comma-separated): ');
+    console.log('\nTranslation provider:');
+    console.log('  1. OpenAI (requires API key)');
+    console.log('  2. Claude API (requires API key)');
+    console.log('  3. Claude Code (uses your Claude Code subscription, warming only)');
+    const providerRaw = await ask('Select provider [1]: ');
+    const providerChoice = parseInt(providerRaw, 10) || 1;
     rl.close();
     const output = await runInit({
         dir, name, context, sourceLang,
         targetLangs: targetsRaw.split(',').map(s => s.trim()),
+        provider: providerChoice,
     });
     console.log(output);
     const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });

package/dist/config.d.ts

@@ -4,7 +4,9 @@ export interface TransduckConfig {
     sourceLang: string;
     targetLangs: string[];
     storagePath: string;
+    provider: string;
     apiKeyEnv: string;
+    tokenEnv: string;
     backendModel: string;
     backendTimeout: number;
     backendMaxRetries: number;

package/dist/config.js

@@ -29,16 +29,29 @@ export function loadConfig(path) {
     const raw = parseYaml(readFileSync(configPath, 'utf-8'));
     const configDir = dirname(configPath);
     const storagePath = resolve(configDir, raw.storage.path);
+    const backend = raw.backend ?? {};
+    const provider = backend.provider ?? 'openai';
+    const apiKeyEnv = backend.api_key_env ?? 'OPENAI_API_KEY';
+    const tokenEnv = backend.token_env ?? 'CLAUDE_CODE_OAUTH_TOKEN';
+    const backendModel = backend.model ?? 'gpt-4.1-mini';
+    const backendTimeout = backend.timeout_seconds ?? 10;
+    const backendMaxRetries = backend.max_retries ?? 2;
+    let readOnly = raw.runtime?.read_only ?? false;
+    if (provider === 'claude_code') {
+        readOnly = true;
+    }
     return {
         projectName: raw.project.name,
         projectContext: raw.project.context,
         sourceLang: String(raw.languages.source).toUpperCase(),
         targetLangs: raw.languages.targets.map((l) => String(l).toUpperCase()),
         storagePath,
-        apiKeyEnv: raw.backend.api_key_env,
-        backendModel: raw.backend.model,
-        backendTimeout: raw.backend.timeout_seconds,
-        backendMaxRetries: raw.backend.max_retries,
-        readOnly: raw.runtime?.read_only ?? false,
+        provider,
+        apiKeyEnv,
+        tokenEnv,
+        backendModel,
+        backendTimeout,
+        backendMaxRetries,
+        readOnly,
     };
 }

package/dist/handler.js

@@ -27,7 +27,6 @@ export async function handleTranslationRequest(body, configPath) {
     const store = await getStore(configPath);
     const targetLang = body.language.toUpperCase();
     const projectContextHash = hash(cfg.projectContext);
-    const apiKey = process.env[cfg.apiKeyEnv];
     const translations = {};
     const plurals = {};
     // Translate regular strings
@@ -48,17 +47,7 @@ export async function handleTranslationRequest(body, configPath) {
         }
         // Backend call
         try {
-            const translated = await backendTranslate({
-                sourceText: item.text,
-                sourceLang: cfg.sourceLang,
-                targetLang,
-                projectContext: cfg.projectContext,
-                stringContext: item.context ?? null,
-                apiKey: apiKey,
-                model: cfg.backendModel,
-                timeout: cfg.backendTimeout,
-                maxRetries: cfg.backendMaxRetries,
-            });
+            const translated = await backendTranslate(item.text, cfg.sourceLang, targetLang, cfg.projectContext, item.context ?? null, cfg);
             if (validateTranslation(item.text, translated)) {
                 await store.insert({
                     sourceText: item.text,
@@ -99,18 +88,7 @@ export async function handleTranslationRequest(body, configPath) {
         }
         // Backend call
         try {
-            const forms = await backendTranslatePlural({
-                one: item.one,
-                other: item.other,
-                sourceLang: cfg.sourceLang,
-                targetLang,
-                projectContext: cfg.projectContext,
-                stringContext: item.context ?? null,
-                apiKey: apiKey,
-                model: cfg.backendModel,
-                timeout: cfg.backendTimeout,
-                maxRetries: cfg.backendMaxRetries,
-            });
+            const forms = await backendTranslatePlural(item.one, item.other, cfg.sourceLang, targetLang, cfg.projectContext, item.context ?? null, cfg);
             for (const [cat, translatedText] of Object.entries(forms)) {
                 await store.insertPlural({
                     sourceText: sourceKey,

package/dist/index.js

@@ -67,14 +67,8 @@ export async function ait(sourceText, context, vars) {
         });
         if (rechecked !== null)
             return rechecked;
-        const apiKey = process.env[cfg.apiKeyEnv];
         try {
-            const translated = await backendTranslate({
-                sourceText, sourceLang: cfg.sourceLang, targetLang: state.targetLang,
-                projectContext: cfg.projectContext, stringContext: context ?? null,
-                apiKey: apiKey, model: cfg.backendModel,
-                timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-            });
+            const translated = await backendTranslate(sourceText, cfg.sourceLang, state.targetLang, cfg.projectContext, context ?? null, cfg);
             if (!validateTranslation(sourceText, translated)) {
                 console.warn(`[transduck] Validation failed for: ${sourceText} -> ${translated}`);
                 await state.store.insert({
@@ -153,15 +147,8 @@ export async function aitPlural(one, other, count, opts) {
         return interpolateVars(fallback, vars);
     }
     // Cache miss — call backend
-    const apiKey = process.env[cfg.apiKeyEnv];
     try {
-        const forms = await backendTranslatePlural({
-            one, other,
-            sourceLang: cfg.sourceLang, targetLang: state.targetLang,
-            projectContext: cfg.projectContext, stringContext: context ?? null,
-            apiKey: apiKey, model: cfg.backendModel,
-            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-        });
+        const forms = await backendTranslatePlural(one, other, cfg.sourceLang, state.targetLang, cfg.projectContext, context ?? null, cfg);
         // Validate and store each form
         const validCategories = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
         const sourcePlaceholders = new Set([

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

@@ -0,0 +1,7 @@
+/**
+ * Claude API translation provider.
+ * Uses the @anthropic-ai/sdk package (optional peer dependency, lazy imported).
+ */
+import type { TransduckConfig } from '../config.js';
+export declare function translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig): Promise<string>;
+export declare function translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig): Promise<Record<string, string>>;