glotto 1.0.2 → 2.9.0

package/esm/src/file.d.ts

@@ -1,55 +1,10 @@
-import type { Chunk, JsonObject } from './types.js';
-/**
- * Resolves a path relative to the current working directory
- * @param paths - Array of path segments to join
- * @returns Absolute path string
- */
+import type { ChunkInfo, JsonObject } from './types.js';
 export declare const resolvePath: (...paths: string[]) => string;
-/**
- * Reads and parses a JSON file from the given path
- * @param input - Path to the JSON file
- * @returns Promise resolving to parsed JSON content
- * @throws Error if file is empty or content is invalid
- */
 export declare const getImportJson: <T = JsonObject>(input: string) => Promise<T>;
-/**
- * Writes JSON content to the specified output path
- * @param outputPath - Destination path for the JSON file
- * @param content - String content to write
- * @returns Promise that resolves when write is complete
- */
 export declare const writeOutput: (outputPath: string, content: string) => Promise<void>;
-/**
- * Checks if a file or directory exists at the given path
- * @param path - Path to check for existence
- * @returns Promise resolving to boolean indicating if path exists
- * @throws Error for system errors other than NotFound
- */
 export declare const existsFile: (path: string) => Promise<boolean>;
-/**
- * Creates a directory if it doesn't already exist
- * @param directory - Path where directory should be created
- * @returns Promise that resolves when directory is ready
- */
 export declare const ensureDirectoryExists: (directory: string) => Promise<void>;
-/**
- * Splits a JSON object into multiple chunks based on key count
- * @param data - Source JSON object to split
- * @param maxKeysPerFile - Maximum number of keys per chunk
- * @returns Set of encoded JSON chunks
- */
-export declare const splitJson: (data: JsonObject, maxKeysPerFile: number) => Set<Chunk>;
-/**
- * Combines multiple JSON objects into a single object
- * @param inputs - Array of JSON objects to merge
- * @returns Single merged JSON object
- */
+export declare const splitJson: (data: JsonObject, maxChunkBytes?: number) => ChunkInfo[];
 export declare const mergeInputs: (inputs: JsonObject[]) => JsonObject;
-/**
- * Creates a temporary JSON file with the specified content
- * @param tempJsonFileName - Name for the temporary file
- * @param content - Content to write to the temporary file
- * @returns Promise that resolves when file is written
- */
-export declare const writeTemp: (tempJsonFileName: string, content: string) => Promise<void>;
+export declare const writeTemp: (targetLanguage: string, tempJsonFileName: string, content: string) => Promise<void>;
 //# sourceMappingURL=file.d.ts.map

package/esm/src/file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/src/file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGpD;;;;GAIG;AACH,eAAO,MAAM,WAAW,aAAc,MAAM,EAAE,WAE7C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAU,CAAC,sBAAsB,MAAM,KAAG,OAAO,CAAC,CAAC,CAS5E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,eAAsB,MAAM,WAAW,MAAM,kBAEpE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,SAAgB,MAAM,qBAW5C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,cAAqB,MAAM,KAAG,OAAO,CAAC,IAAI,CAK3E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,SAAU,UAAU,kBAAkB,MAAM,KAAG,GAAG,CAAC,KAAK,CAwB7E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,WAAY,UAAU,EAAE,KAAG,UAElD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,qBAA4B,MAAM,WAAW,MAAM,kBAIxE,CAAC"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/src/file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxD,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,MAAM,EAAE,WAE7C,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,CAAC,GAAG,UAAU,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,CAS5E,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,YAAY,MAAM,EAAE,SAAS,MAAM,kBAEpE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAU,MAAM,MAAM,qBAW5C,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAK3E,CAAC;AAeF,eAAO,MAAM,SAAS,GAAI,MAAM,UAAU,EAAE,gBAAe,MAAe,KAAG,SAAS,EA4DrF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,QAAQ,UAAU,EAAE,KAAG,UAElD,CAAC;AAkBF,eAAO,MAAM,SAAS,GAAU,gBAAgB,MAAM,EAAE,kBAAkB,MAAM,EAAE,SAAS,MAAM,kBAKhG,CAAC"}

package/esm/src/file.js

@@ -1,20 +1,9 @@
 import * as dntShim from "../_dnt.shims.js";
-import { join } from '../deps/jsr.io/@std/path/1.0.8/mod.js';
-import { TEMP_DIR } from './contants.js';
-/**
- * Resolves a path relative to the current working directory
- * @param paths - Array of path segments to join
- * @returns Absolute path string
- */
+import { join } from '../deps/jsr.io/@std/path/1.1.4/mod.js';
+import { logger } from './logger.js';
 export const resolvePath = (...paths) => {
     return join(dntShim.Deno.cwd(), ...paths);
 };
-/**
- * Reads and parses a JSON file from the given path
- * @param input - Path to the JSON file
- * @returns Promise resolving to parsed JSON content
- * @throws Error if file is empty or content is invalid
- */
 export const getImportJson = async (input) => {
     const filePath = resolvePath(input);
     const fileContent = await dntShim.Deno.readTextFile(filePath);
@@ -23,21 +12,9 @@ export const getImportJson = async (input) => {
     }
     return JSON.parse(fileContent);
 };
-/**
- * Writes JSON content to the specified output path
- * @param outputPath - Destination path for the JSON file
- * @param content - String content to write
- * @returns Promise that resolves when write is complete
- */
 export const writeOutput = async (outputPath, content) => {
     await dntShim.Deno.writeTextFile(outputPath, content, { create: true });
 };
-/**
- * Checks if a file or directory exists at the given path
- * @param path - Path to check for existence
- * @returns Promise resolving to boolean indicating if path exists
- * @throws Error for system errors other than NotFound
- */
 export const existsFile = async (path) => {
     try {
         await dntShim.Deno.stat(path);
@@ -50,58 +27,95 @@ export const existsFile = async (path) => {
         throw error;
     }
 };
-/**
- * Creates a directory if it doesn't already exist
- * @param directory - Path where directory should be created
- * @returns Promise that resolves when directory is ready
- */
 export const ensureDirectoryExists = async (directory) => {
     const directoryExists = await existsFile(directory);
     if (!directoryExists) {
         await dntShim.Deno.mkdir(directory, { recursive: true });
     }
 };
-/**
- * Splits a JSON object into multiple chunks based on key count
- * @param data - Source JSON object to split
- * @param maxKeysPerFile - Maximum number of keys per chunk
- * @returns Set of encoded JSON chunks
- */
-export const splitJson = (data, maxKeysPerFile) => {
+const getByteSize = (str) => {
+    return new TextEncoder().encode(str).byteLength;
+};
+const buildChunkWithSize = (data, keys) => {
+    const chunk = Object.create(null);
+    for (const key of keys) {
+        chunk[key] = data[key];
+    }
+    const json = JSON.stringify(chunk);
+    return { json, size: getByteSize(json) };
+};
+export const splitJson = (data, maxChunkBytes = 30_000) => {
+    const encoder = new TextEncoder();
     const dataKeys = Object.keys(data);
     const totalKeys = dataKeys.length;
-    const numFiles = Math.ceil(totalKeys / maxKeysPerFile);
-    const files = new Set();
-    for (let i = 0; i < numFiles; i++) {
-        const startIdx = i * maxKeysPerFile;
-        const endIdx = Math.min((i + 1) * maxKeysPerFile, totalKeys);
-        const chunkKeys = dataKeys.slice(startIdx, endIdx);
-        const chunkObject = Object.create(null);
-        for (const key of chunkKeys) {
-            chunkObject[key] = data[key];
+    const fullJson = JSON.stringify(data);
+    const totalBytes = getByteSize(fullJson);
+    if (totalBytes <= maxChunkBytes) {
+        return [
+            {
+                data: encoder.encode(fullJson),
+                keyCount: totalKeys,
+                byteSize: totalBytes,
+                index: 0,
+            },
+        ];
+    }
+    const chunks = [];
+    let currentKeys = [];
+    let currentSize = 2;
+    for (let i = 0; i < totalKeys; i++) {
+        const key = dataKeys[i];
+        const keyValueJson = JSON.stringify({ [key]: data[key] });
+        const entrySize = getByteSize(keyValueJson) - 2;
+        const separatorSize = currentKeys.length > 0 ? 1 : 0;
+        const projectedSize = currentSize + entrySize + separatorSize;
+        if (projectedSize > maxChunkBytes && currentKeys.length > 0) {
+            const { json, size } = buildChunkWithSize(data, currentKeys);
+            chunks.push({
+                data: encoder.encode(json),
+                keyCount: currentKeys.length,
+                byteSize: size,
+                index: chunks.length,
+            });
+            currentKeys = [key];
+            currentSize = 2 + entrySize;
+        }
+        else {
+            currentKeys.push(key);
+            currentSize = projectedSize;
         }
-        const chunkString = JSON.stringify(chunkObject);
-        const chunkArray = new TextEncoder().encode(chunkString);
-        files.add(chunkArray);
     }
-    return files;
+    if (currentKeys.length > 0) {
+        const { json, size } = buildChunkWithSize(data, currentKeys);
+        chunks.push({
+            data: encoder.encode(json),
+            keyCount: currentKeys.length,
+            byteSize: size,
+            index: chunks.length,
+        });
+    }
+    return chunks;
 };
-/**
- * Combines multiple JSON objects into a single object
- * @param inputs - Array of JSON objects to merge
- * @returns Single merged JSON object
- */
 export const mergeInputs = (inputs) => {
     return Object.assign({}, ...inputs);
 };
-/**
- * Creates a temporary JSON file with the specified content
- * @param tempJsonFileName - Name for the temporary file
- * @param content - Content to write to the temporary file
- * @returns Promise that resolves when file is written
- */
-export const writeTemp = async (tempJsonFileName, content) => {
-    await ensureDirectoryExists(TEMP_DIR);
-    const tempJsonFilePath = resolvePath(TEMP_DIR, tempJsonFileName);
+const getOsTempDir = () => {
+    if (dntShim.Deno.build.os === 'windows') {
+        return dntShim.Deno.env.get('TEMP') ?? dntShim.Deno.env.get('TMP') ?? 'C:\\Windows\\Temp';
+    }
+    return dntShim.Deno.env.get('TMPDIR') ?? '/tmp';
+};
+const resolveTempDir = async (targetLanguage) => {
+    const tempDir = getOsTempDir();
+    const glottoTempDir = join(tempDir, 'glotto');
+    await ensureDirectoryExists(glottoTempDir);
+    const languageTempDir = join(glottoTempDir, targetLanguage);
+    await ensureDirectoryExists(languageTempDir);
+    return languageTempDir;
+};
+export const writeTemp = async (targetLanguage, tempJsonFileName, content) => {
+    const tempDir = await resolveTempDir(targetLanguage);
+    const tempJsonFilePath = join(tempDir, tempJsonFileName);
     await dntShim.Deno.writeTextFile(tempJsonFilePath, content, { create: true });
+    logger.info(`Temp saved: ${tempJsonFilePath}`);
 };

package/esm/src/logger.d.ts

@@ -1,5 +1,2 @@
-/**
- * Logger
- */
 export declare const logger: import("consola").ConsolaInstance;
 //# sourceMappingURL=logger.d.ts.map

package/esm/src/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/src/logger.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,MAAM,mCAAkB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/src/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,mCAAkB,CAAC"}

package/esm/src/logger.js

@@ -1,5 +1,2 @@
 import { createConsola } from 'consola';
-/**
- * Logger
- */
 export const logger = createConsola();

package/esm/src/providers/anthropic.d.ts

@@ -0,0 +1,14 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { ChunkInfo, Translatable } from '../types.js';
+declare class AnthropicModel implements Translatable {
+    chunks: ChunkInfo[];
+    from: string;
+    to: string;
+    client: Anthropic;
+    model: string;
+    constructor(key: string, chunks: ChunkInfo[], from: string, to: string, baseUrl?: string, modelName?: string);
+    private translateChunk;
+    translate(): Promise<string>;
+}
+export default AnthropicModel;
+//# sourceMappingURL=anthropic.d.ts.map

package/esm/src/providers/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/src/providers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAQvE,cAAM,cAAe,YAAW,YAAY;IAC1C,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;YAW9F,cAAc;IAkEtB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;CAqCnC;AAED,eAAe,cAAc,CAAC"}

package/esm/src/providers/anthropic.js

@@ -0,0 +1,131 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { delay, formatBytes, generatePrompts, isValidJson, stripJsonMarkdown } from '../utilites.js';
+import { logger } from '../logger.js';
+import { mergeInputs, writeTemp } from '../file.js';
+import { BASE_RETRY_DELAY_MS, DEFAULT_MODELS, INTER_CHUNK_DELAY_MS, MAX_RETRIES } from '../contants.js';
+const decoder = new TextDecoder();
+class AnthropicModel {
+    constructor(key, chunks, from, to, baseUrl, modelName) {
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "from", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "to", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chunks = chunks;
+        this.from = from;
+        this.to = to;
+        this.model = modelName ?? DEFAULT_MODELS.anthropic;
+        this.client = new Anthropic({
+            apiKey: key,
+            baseURL: baseUrl,
+        });
+    }
+    async translateChunk(chunk, systemPrompt, userPrompt) {
+        const chunkLabel = `[Chunk ${chunk.index + 1}/${this.chunks.length}]`;
+        const sourceJson = decoder.decode(chunk.data);
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const backoffMs = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+                    logger.warn(`${chunkLabel} Retry ${attempt}/${MAX_RETRIES} after ${backoffMs}ms backoff...`);
+                    await delay(backoffMs);
+                }
+                const message = await this.client.messages.create({
+                    model: this.model,
+                    max_tokens: 4096,
+                    messages: [
+                        {
+                            role: 'user',
+                            content: `${systemPrompt}\n\n${userPrompt}\n\nSOURCE_JSON:\n${sourceJson}`,
+                        },
+                    ],
+                });
+                const textParts = message.content
+                    .filter((part) => part.type === 'text')
+                    .map((part) => part.text);
+                const text = textParts.join('').trim();
+                if (!text) {
+                    logger.error(`${chunkLabel} Empty response from Anthropic`);
+                    continue;
+                }
+                const cleanedText = stripJsonMarkdown(text);
+                const tempJsonFileName = `chunk_${chunk.index + 1}.json`;
+                await writeTemp(this.to, tempJsonFileName, cleanedText);
+                if (!isValidJson(cleanedText)) {
+                    if (attempt === MAX_RETRIES) {
+                        logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: Invalid JSON response`);
+                        return null;
+                    }
+                    logger.error(`${chunkLabel} Invalid JSON response, saved to ${tempJsonFileName}`);
+                    continue;
+                }
+                logger.info(`${chunkLabel} Translated successfully (${formatBytes(chunk.byteSize)}, ${chunk.keyCount} keys)`);
+                return cleanedText;
+            }
+            catch (error) {
+                const isLastAttempt = attempt === MAX_RETRIES;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (isLastAttempt) {
+                    logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: ${errorMessage}`);
+                    return null;
+                }
+                logger.warn(`${chunkLabel} Attempt ${attempt + 1} failed: ${errorMessage}`);
+            }
+        }
+        return null;
+    }
+    async translate() {
+        const { systemPrompt, userPrompt } = generatePrompts(this.from, this.to);
+        const totalChunks = this.chunks.length;
+        logger.info(`Starting translation: ${totalChunks} chunk(s) to process`);
+        const results = [];
+        const failedChunks = [];
+        for (let i = 0; i < totalChunks; i++) {
+            const chunk = this.chunks[i];
+            if (i > 0) {
+                logger.info(`Waiting ${INTER_CHUNK_DELAY_MS}ms before next chunk (rate limit protection)...`);
+                await delay(INTER_CHUNK_DELAY_MS);
+            }
+            const result = await this.translateChunk(chunk, systemPrompt, userPrompt);
+            if (result) {
+                results.push(result);
+            }
+            else {
+                failedChunks.push(chunk.index + 1);
+            }
+        }
+        if (failedChunks.length > 0) {
+            throw new Error(`Translation failed for chunk(s): ${failedChunks.join(', ')}. Check temp files for partial results.`);
+        }
+        logger.info(`All ${totalChunks} chunk(s) translated successfully, merging results...`);
+        const jsonInputs = results.map((r) => JSON.parse(r));
+        const mergedContent = mergeInputs(jsonInputs);
+        return JSON.stringify(mergedContent, null, 2);
+    }
+}
+export default AnthropicModel;

package/esm/src/providers/gemini.d.ts

@@ -0,0 +1,14 @@
+import { GoogleGenAI } from '@google/genai';
+import type { ChunkInfo, Translatable } from '../types.js';
+declare class Gemini implements Translatable {
+    chunks: ChunkInfo[];
+    from: string;
+    to: string;
+    genAI: GoogleGenAI;
+    model: string;
+    constructor(key: string, chunks: ChunkInfo[], from: string, to: string, modelName?: string);
+    private translateChunk;
+    translate(): Promise<string>;
+}
+export default Gemini;
+//# sourceMappingURL=gemini.d.ts.map

package/esm/src/providers/gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../src/src/providers/gemini.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAa,MAAM,eAAe,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAMvE,cAAM,MAAO,YAAW,YAAY;IAClC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;YAU5E,cAAc;IAwEtB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;CAqCnC;AAED,eAAe,MAAM,CAAC"}

package/esm/src/providers/gemini.js

@@ -0,0 +1,136 @@
+import { GoogleGenAI } from '@google/genai';
+import { encodeBase64 } from '../../deps/jsr.io/@std/encoding/1.0.10/mod.js';
+import { delay, formatBytes, generatePrompts, isValidJson, stripJsonMarkdown } from '../utilites.js';
+import { logger } from '../logger.js';
+import { mergeInputs, writeTemp } from '../file.js';
+import { BASE_RETRY_DELAY_MS, DEFAULT_MODELS, INTER_CHUNK_DELAY_MS, MAX_RETRIES } from '../contants.js';
+class Gemini {
+    constructor(key, chunks, from, to, modelName) {
+        Object.defineProperty(this, "chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "from", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "to", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "genAI", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chunks = chunks;
+        this.from = from;
+        this.to = to;
+        this.model = modelName ?? DEFAULT_MODELS.gemini;
+        this.genAI = new GoogleGenAI({
+            apiKey: key,
+        });
+    }
+    async translateChunk(chunk, systemPrompt, userPrompt) {
+        const chunkLabel = `[Chunk ${chunk.index + 1}/${this.chunks.length}]`;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const backoffMs = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+                    logger.warn(`${chunkLabel} Retry ${attempt}/${MAX_RETRIES} after ${backoffMs}ms backoff...`);
+                    await delay(backoffMs);
+                }
+                const fileBase64 = encodeBase64(chunk.data);
+                const part = {
+                    inlineData: {
+                        data: fileBase64,
+                        mimeType: 'text/plain',
+                    },
+                };
+                const { text } = await this.genAI.models.generateContent({
+                    model: this.model,
+                    contents: [systemPrompt, userPrompt, part],
+                    config: {
+                        systemInstruction: systemPrompt,
+                        candidateCount: 1,
+                        responseMimeType: 'application/json',
+                        responseLogprobs: false,
+                        temperature: 0.3,
+                        topP: 0.7,
+                        topK: 20,
+                        maxOutputTokens: Number.POSITIVE_INFINITY,
+                    },
+                });
+                if (!text) {
+                    logger.error(`${chunkLabel} Empty response from Gemini AI`);
+                    continue;
+                }
+                const cleanedText = stripJsonMarkdown(text);
+                const tempJsonFileName = `chunk_${chunk.index + 1}.json`;
+                await writeTemp(this.to, tempJsonFileName, cleanedText);
+                if (!isValidJson(cleanedText)) {
+                    if (attempt === MAX_RETRIES) {
+                        logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: Invalid JSON response`);
+                        return null;
+                    }
+                    logger.error(`${chunkLabel} Invalid JSON response, saved to ${tempJsonFileName}`);
+                    continue;
+                }
+                logger.info(`${chunkLabel} Translated successfully (${formatBytes(chunk.byteSize)}, ${chunk.keyCount} keys)`);
+                return cleanedText;
+            }
+            catch (error) {
+                const isLastAttempt = attempt === MAX_RETRIES;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (isLastAttempt) {
+                    logger.error(`${chunkLabel} Failed after ${MAX_RETRIES + 1} attempts: ${errorMessage}`);
+                    return null;
+                }
+                logger.warn(`${chunkLabel} Attempt ${attempt + 1} failed: ${errorMessage}`);
+            }
+        }
+        return null;
+    }
+    async translate() {
+        const { systemPrompt, userPrompt } = generatePrompts(this.from, this.to);
+        const totalChunks = this.chunks.length;
+        logger.info(`Starting translation: ${totalChunks} chunk(s) to process`);
+        const results = [];
+        const failedChunks = [];
+        for (let i = 0; i < totalChunks; i++) {
+            const chunk = this.chunks[i];
+            if (i > 0) {
+                logger.info(`Waiting ${INTER_CHUNK_DELAY_MS}ms before next chunk (rate limit protection)...`);
+                await delay(INTER_CHUNK_DELAY_MS);
+            }
+            const result = await this.translateChunk(chunk, systemPrompt, userPrompt);
+            if (result) {
+                results.push(result);
+            }
+            else {
+                failedChunks.push(chunk.index + 1);
+            }
+        }
+        if (failedChunks.length > 0) {
+            throw new Error(`Translation failed for chunk(s): ${failedChunks.join(', ')}. Check temp files for partial results.`);
+        }
+        logger.info(`All ${totalChunks} chunk(s) translated successfully, merging results...`);
+        const jsonInputs = results.map((r) => JSON.parse(r));
+        const mergedContent = mergeInputs(jsonInputs);
+        return JSON.stringify(mergedContent, null, 2);
+    }
+}
+export default Gemini;

package/esm/src/providers/openai.d.ts

@@ -0,0 +1,14 @@
+import OpenAI from 'openai';
+import type { ChunkInfo, Translatable } from '../types.js';
+declare class OpenAIModel implements Translatable {
+    chunks: ChunkInfo[];
+    from: string;
+    to: string;
+    client: OpenAI;
+    model: string;
+    constructor(key: string, chunks: ChunkInfo[], from: string, to: string, baseUrl?: string, modelName?: string);
+    private translateChunk;
+    translate(): Promise<string>;
+}
+export default OpenAIModel;
+//# sourceMappingURL=openai.d.ts.map

package/esm/src/providers/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/src/providers/openai.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAQvE,cAAM,WAAY,YAAW,YAAY;IACvC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;YAW9F,cAAc;IAkEtB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;CAqCnC;AAED,eAAe,WAAW,CAAC"}