@djangocfg/llm 2.1.164

package/dist/index.cjs

@@ -0,0 +1,1164 @@
+'use strict';
+
+var OpenAI = require('openai');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/translator/text-utils.ts
+function isTechnicalContent(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return true;
+  if (/^(https?:\/\/|\/\/|www\.)/i.test(trimmed)) return true;
+  if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) return true;
+  if (/^\/[a-zA-Z]/.test(trimmed)) return true;
+  if (/\.(js|ts|tsx|jsx|json|css|scss|html|md|py|go|rs)$/i.test(trimmed)) return true;
+  if (/^[\d.,]+%?$/.test(trimmed)) return true;
+  if (/^[A-Z][A-Z0-9_]*$/.test(trimmed)) return true;
+  if (/^(\{[^}]+\}|\{\{[^}]+\}\}|%[sd]|\$\d+)$/.test(trimmed)) return true;
+  if (/^[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]+$/.test(trimmed)) return true;
+  return false;
+}
+function containsCJK(text) {
+  return /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(text);
+}
+function containsCyrillic(text) {
+  return /[\u0400-\u04ff]/.test(text);
+}
+function containsArabic(text) {
+  return /[\u0600-\u06ff]/.test(text);
+}
+function detectScript(text) {
+  if (containsCJK(text)) return "cjk";
+  if (containsCyrillic(text)) return "cyrillic";
+  if (containsArabic(text)) return "arabic";
+  if (/[a-zA-Z]/.test(text)) return "latin";
+  return "unknown";
+}
+function extractPlaceholders(text) {
+  const patterns = [
+    /\{[^}]+\}/g,
+    // {name}
+    /\{\{[^}]+\}\}/g,
+    // {{name}}
+    /%[sd]/g,
+    // %s, %d
+    /\$\d+/g
+    // $1, $2
+  ];
+  const placeholders = [];
+  for (const pattern of patterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      placeholders.push(...matches);
+    }
+  }
+  return [...new Set(placeholders)];
+}
+
+// src/translator/validator.ts
+function validateJsonKeys(original, translated, path = "") {
+  const errors = [];
+  if (typeof original !== typeof translated) {
+    errors.push(`Type mismatch at ${path || "root"}: expected ${typeof original}, got ${typeof translated}`);
+    return { valid: false, errors };
+  }
+  if (original === null || translated === null) {
+    if (original !== translated) {
+      errors.push(`Null mismatch at ${path || "root"}`);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  if (Array.isArray(original)) {
+    if (!Array.isArray(translated)) {
+      errors.push(`Expected array at ${path || "root"}`);
+      return { valid: false, errors };
+    }
+    if (original.length !== translated.length) {
+      errors.push(
+        `Array length mismatch at ${path || "root"}: expected ${original.length}, got ${translated.length}`
+      );
+    }
+    const minLen = Math.min(original.length, translated.length);
+    for (let i = 0; i < minLen; i++) {
+      const result = validateJsonKeys(
+        original[i],
+        translated[i],
+        `${path}[${i}]`
+      );
+      errors.push(...result.errors);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  if (typeof original === "object") {
+    if (typeof translated !== "object" || Array.isArray(translated)) {
+      errors.push(`Expected object at ${path || "root"}`);
+      return { valid: false, errors };
+    }
+    const origKeys = Object.keys(original);
+    const transKeys = Object.keys(translated);
+    for (const key of origKeys) {
+      if (!transKeys.includes(key)) {
+        errors.push(`Missing key: ${path ? `${path}.${key}` : key}`);
+      }
+    }
+    for (const key of transKeys) {
+      if (!origKeys.includes(key)) {
+        errors.push(
+          `Unexpected key: ${path ? `${path}.${key}` : key} (key was translated?)`
+        );
+      }
+    }
+    for (const key of origKeys) {
+      if (transKeys.includes(key)) {
+        const result = validateJsonKeys(
+          original[key],
+          translated[key],
+          path ? `${path}.${key}` : key
+        );
+        errors.push(...result.errors);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validatePlaceholders(original, translated, path = "") {
+  const errors = [];
+  if (typeof original === "string" && typeof translated === "string") {
+    const origPlaceholders = extractPlaceholders(original);
+    const transPlaceholders = extractPlaceholders(translated);
+    for (const placeholder of origPlaceholders) {
+      if (!transPlaceholders.includes(placeholder)) {
+        errors.push(
+          `Missing placeholder "${placeholder}" at ${path || "root"}`
+        );
+      }
+    }
+    for (const placeholder of transPlaceholders) {
+      if (!origPlaceholders.includes(placeholder)) {
+        errors.push(
+          `Extra placeholder "${placeholder}" at ${path || "root"}`
+        );
+      }
+    }
+  } else if (Array.isArray(original) && Array.isArray(translated)) {
+    const minLen = Math.min(original.length, translated.length);
+    for (let i = 0; i < minLen; i++) {
+      const result = validatePlaceholders(
+        original[i],
+        translated[i],
+        `${path}[${i}]`
+      );
+      errors.push(...result.errors);
+    }
+  } else if (typeof original === "object" && original !== null && typeof translated === "object" && translated !== null) {
+    for (const key of Object.keys(original)) {
+      if (key in translated) {
+        const result = validatePlaceholders(
+          original[key],
+          translated[key],
+          path ? `${path}.${key}` : key
+        );
+        errors.push(...result.errors);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateTranslation(original, translated) {
+  const keyResult = validateJsonKeys(original, translated);
+  const placeholderResult = validatePlaceholders(original, translated);
+  return {
+    valid: keyResult.valid && placeholderResult.valid,
+    errors: [...keyResult.errors, ...placeholderResult.errors]
+  };
+}
+
+// src/utils/json.ts
+function extractJson(text) {
+  let jsonStr = text.trim();
+  if (jsonStr.startsWith("```json")) {
+    jsonStr = jsonStr.slice(7);
+  } else if (jsonStr.startsWith("```")) {
+    jsonStr = jsonStr.slice(3);
+  }
+  if (jsonStr.endsWith("```")) {
+    jsonStr = jsonStr.slice(0, -3);
+  }
+  jsonStr = jsonStr.trim();
+  const jsonStart = jsonStr.search(/[\[{]/);
+  const jsonEndBracket = jsonStr.lastIndexOf("]");
+  const jsonEndBrace = jsonStr.lastIndexOf("}");
+  const jsonEnd = Math.max(jsonEndBracket, jsonEndBrace);
+  if (jsonStart !== -1 && jsonEnd !== -1) {
+    jsonStr = jsonStr.slice(jsonStart, jsonEnd + 1);
+  }
+  try {
+    return JSON.parse(jsonStr);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse JSON from LLM response: ${error instanceof Error ? error.message : "Unknown error"}
+
+Response:
+${text}`
+    );
+  }
+}
+
+// src/providers/base.ts
+var BaseLLMProvider = class {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = {
+      model: config.model ?? "gpt-4o-mini",
+      temperature: config.temperature ?? 0.1,
+      maxTokens: config.maxTokens ?? 4096,
+      ...config
+    };
+  }
+  /**
+   * Send single chat message
+   */
+  async chat(prompt, options) {
+    const messages = [];
+    if (options?.system) {
+      messages.push({ role: "system", content: options.system });
+    }
+    messages.push({ role: "user", content: prompt });
+    return this.chatMessages(messages, options);
+  }
+  /**
+   * Get JSON response
+   */
+  async json(prompt, options) {
+    const systemPrompt = `${options?.system ?? ""}
+
+Respond with valid JSON only. No markdown, no explanations.`.trim();
+    const response = await this.chat(prompt, {
+      ...options,
+      system: systemPrompt,
+      temperature: options?.temperature ?? 0
+    });
+    return extractJson(response.content);
+  }
+  /**
+   * Get JSON response with schema hint
+   */
+  async jsonSchema(prompt, schema, options) {
+    const systemPrompt = `${options?.system ?? ""}
+
+Respond with valid JSON matching this schema:
+${schema}
+
+No markdown, no explanations.`.trim();
+    const response = await this.chat(prompt, {
+      ...options,
+      system: systemPrompt,
+      temperature: options?.temperature ?? 0
+    });
+    return extractJson(response.content);
+  }
+};
+
+// src/providers/openai.ts
+var OpenAIProvider = class extends BaseLLMProvider {
+  constructor(config) {
+    super({
+      model: config.model ?? "gpt-4o-mini",
+      ...config
+    });
+    __publicField(this, "provider", "openai");
+    __publicField(this, "client");
+    if (!config.apiKey) {
+      throw new Error("OpenAI API key is required");
+    }
+    this.client = new OpenAI__default.default({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+  }
+  async chatMessages(messages, options) {
+    const model = options?.model ?? this.config.model;
+    const temperature = options?.temperature ?? this.config.temperature;
+    const maxTokens = options?.maxTokens ?? this.config.maxTokens;
+    const allMessages = options?.system ? [{ role: "system", content: options.system }, ...messages] : messages;
+    const response = await this.client.chat.completions.create({
+      model,
+      messages: allMessages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      temperature,
+      max_tokens: maxTokens
+    });
+    const choice = response.choices[0];
+    return {
+      content: choice.message.content ?? "",
+      model: response.model,
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0,
+      finishReason: choice.finish_reason ?? void 0
+    };
+  }
+};
+var AnthropicProvider = class extends BaseLLMProvider {
+  constructor(config) {
+    super({
+      model: config.model ?? "claude-3-5-haiku-latest",
+      ...config
+    });
+    __publicField(this, "provider", "anthropic");
+    __publicField(this, "client");
+    if (!config.apiKey) {
+      throw new Error("Anthropic API key is required");
+    }
+    this.client = new OpenAI__default.default({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl ?? "https://api.anthropic.com/v1",
+      defaultHeaders: {
+        "anthropic-version": "2023-06-01",
+        "x-api-key": config.apiKey
+      }
+    });
+  }
+  async chatMessages(messages, options) {
+    const model = options?.model ?? this.config.model;
+    const temperature = options?.temperature ?? this.config.temperature;
+    const maxTokens = options?.maxTokens ?? this.config.maxTokens;
+    const systemMessage = options?.system ? options.system : messages.find((m) => m.role === "system")?.content;
+    const userMessages = messages.filter((m) => m.role !== "system");
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.config.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        system: systemMessage,
+        messages: userMessages.map((m) => ({
+          role: m.role,
+          content: m.content
+        }))
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.content?.[0]?.text ?? "",
+      model: data.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.input_tokens,
+        completionTokens: data.usage.output_tokens,
+        totalTokens: data.usage.input_tokens + data.usage.output_tokens
+      } : void 0,
+      finishReason: data.stop_reason ?? void 0
+    };
+  }
+};
+var SDKROUTER_BASE_URL = "https://llm.sdkrouter.com/v1";
+function buildModelAlias(tier, options) {
+  const parts = [tier];
+  if (options) {
+    if (options.vision) parts.push("vision");
+    if (options.tools) parts.push("tools");
+    if (options.agents) parts.push("agents");
+    if (options.json) parts.push("json");
+    if (options.streaming) parts.push("streaming");
+    if (options.long) parts.push("long");
+    if (options.image) parts.push("image");
+    if (options.code) parts.push("code");
+    if (options.reasoning) parts.push("reasoning");
+    if (options.creative) parts.push("creative");
+    if (options.chat) parts.push("chat");
+    if (options.analysis) parts.push("analysis");
+  }
+  return "@" + parts.join("+");
+}
+var Model = {
+  /** Cheapest available model */
+  cheap: (options) => buildModelAlias("cheap", options),
+  /** Budget-friendly with decent quality */
+  budget: (options) => buildModelAlias("budget", options),
+  /** Standard tier */
+  standard: (options) => buildModelAlias("standard", options),
+  /** Best quality/price ratio (recommended) */
+  balanced: (options) => buildModelAlias("balanced", options),
+  /** Highest quality model */
+  smart: (options) => buildModelAlias("smart", options),
+  /** Lowest latency model */
+  fast: (options) => buildModelAlias("fast", options),
+  /** Top-tier premium model */
+  premium: (options) => buildModelAlias("premium", options),
+  /**
+   * Build alias from raw strings (escape hatch)
+   *
+   * @example Model.alias('cheap', 'vision', 'code') // '@cheap+vision+code'
+   */
+  alias: (tier, ...modifiers) => "@" + [tier, ...modifiers].join("+")
+};
+var ModelPresets = {
+  /** Translation: cheap + json mode */
+  translation: Model.cheap({ json: true }),
+  /** Code generation: balanced + code */
+  code: Model.balanced({ code: true }),
+  /** Code with tools: balanced + code + tools */
+  codeWithTools: Model.balanced({ code: true, tools: true }),
+  /** Vision: balanced + vision */
+  vision: Model.balanced({ vision: true }),
+  /** Reasoning: smart + reasoning */
+  reasoning: Model.smart({ reasoning: true }),
+  /** Creative writing: balanced + creative */
+  creative: Model.balanced({ creative: true }),
+  /** Fast chat: fast + chat */
+  fastChat: Model.fast({ chat: true }),
+  /** Analysis: balanced + analysis */
+  analysis: Model.balanced({ analysis: true }),
+  /** Agents: smart + agents + tools */
+  agents: Model.smart({ agents: true, tools: true })
+};
+var SDKRouterProvider = class extends BaseLLMProvider {
+  constructor(config) {
+    const model = config.model ?? (config.tier ? buildModelAlias(config.tier, config.modelOptions) : "@balanced");
+    super({
+      model,
+      ...config
+    });
+    __publicField(this, "provider", "sdkrouter");
+    __publicField(this, "client");
+    if (!config.apiKey) {
+      throw new Error("SDKRouter API key is required (SDKROUTER_API_KEY)");
+    }
+    this.client = new OpenAI__default.default({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl ?? SDKROUTER_BASE_URL
+    });
+  }
+  async chatMessages(messages, options) {
+    const model = options?.model ?? this.config.model;
+    const temperature = options?.temperature ?? this.config.temperature;
+    const maxTokens = options?.maxTokens ?? this.config.maxTokens;
+    const allMessages = options?.system ? [{ role: "system", content: options.system }, ...messages] : messages;
+    const response = await this.client.chat.completions.create({
+      model,
+      messages: allMessages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      temperature,
+      max_tokens: maxTokens
+    });
+    const choice = response.choices[0];
+    return {
+      content: choice.message.content ?? "",
+      model: response.model,
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0,
+      finishReason: choice.finish_reason ?? void 0
+    };
+  }
+};
+
+// src/utils/env.ts
+function getApiKey(provider) {
+  if (provider === "sdkrouter") {
+    return process.env.SDKROUTER_API_KEY;
+  }
+  if (provider === "openai") {
+    return process.env.OPENAI_API_KEY;
+  }
+  if (provider === "anthropic") {
+    return process.env.ANTHROPIC_API_KEY;
+  }
+  return process.env.SDKROUTER_API_KEY || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY;
+}
+function detectProvider() {
+  const explicit = process.env.LLM_PROVIDER?.toLowerCase();
+  if (explicit === "sdkrouter" || explicit === "openai" || explicit === "anthropic") {
+    return explicit;
+  }
+  if (process.env.SDKROUTER_API_KEY) {
+    return "sdkrouter";
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return "openai";
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return "anthropic";
+  }
+  return void 0;
+}
+function getDefaultModel(provider) {
+  if (provider === "sdkrouter") {
+    return process.env.SDKROUTER_MODEL || "@balanced";
+  }
+  if (provider === "openai") {
+    return process.env.OPENAI_MODEL || "gpt-4o-mini";
+  }
+  if (provider === "anthropic") {
+    return process.env.ANTHROPIC_MODEL || "claude-3-5-haiku-latest";
+  }
+  return "@balanced";
+}
+
+// src/client.ts
+var LLMError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LLMError";
+  }
+};
+function createLLMClient(config) {
+  const provider = config?.provider ?? detectProvider();
+  if (!provider) {
+    throw new LLMError(
+      "No LLM provider configured. Set SDKROUTER_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY environment variable."
+    );
+  }
+  const apiKey = config?.apiKey ?? getApiKey(provider);
+  if (!apiKey) {
+    const envVar = provider === "sdkrouter" ? "SDKROUTER_API_KEY" : provider === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY";
+    throw new LLMError(
+      `No API key found for ${provider}. Set ${envVar} environment variable.`
+    );
+  }
+  const model = config?.model ?? getDefaultModel(provider);
+  const fullConfig = {
+    ...config,
+    provider,
+    apiKey,
+    model
+  };
+  if (provider === "sdkrouter") {
+    return new SDKRouterProvider(fullConfig);
+  }
+  if (provider === "openai") {
+    return new OpenAIProvider(fullConfig);
+  }
+  if (provider === "anthropic") {
+    return new AnthropicProvider(fullConfig);
+  }
+  throw new LLMError(`Unknown provider: ${provider}`);
+}
+function createSDKRouterClient(config) {
+  return createLLMClient({ ...config, provider: "sdkrouter" });
+}
+function createOpenAIClient(config) {
+  return createLLMClient({ ...config, provider: "openai" });
+}
+function createAnthropicClient(config) {
+  return createLLMClient({ ...config, provider: "anthropic" });
+}
+function isLLMConfigured() {
+  return detectProvider() !== void 0;
+}
+function getConfiguredProvider() {
+  return detectProvider();
+}
+
+// src/translator/types.ts
+var LANGUAGE_NAMES = {
+  en: "English",
+  ru: "Russian",
+  ko: "Korean",
+  ja: "Japanese",
+  zh: "Chinese",
+  de: "German",
+  fr: "French",
+  es: "Spanish",
+  it: "Italian",
+  pt: "Portuguese",
+  "pt-BR": "Brazilian Portuguese",
+  ar: "Arabic",
+  nl: "Dutch",
+  tr: "Turkish",
+  pl: "Polish",
+  sv: "Swedish",
+  no: "Norwegian",
+  da: "Danish",
+  uk: "Ukrainian",
+  hi: "Hindi"
+};
+
+// src/translator/prompts.ts
+function getLanguageName(code) {
+  return LANGUAGE_NAMES[code] ?? code;
+}
+function buildJsonTranslationPrompt(json, sourceLanguage, targetLanguage) {
+  const sourceName = getLanguageName(sourceLanguage);
+  const targetName = getLanguageName(targetLanguage);
+  return `Translate all string VALUES in this JSON from ${sourceName} to ${targetName}.
+
+Rules:
+- Translate ALL string values to ${targetName}
+- Keep JSON keys unchanged (English)
+- Skip: URLs, emails, numbers, "SKIP"
+- Keep placeholders: {name}, {{var}}, %s
+
+${json}
+
+Return ONLY the JSON with all values translated to ${targetName}:`;
+}
+var TranslationCache = class {
+  constructor(maxMemorySize = 1e3, storage) {
+    this.maxMemorySize = maxMemorySize;
+    this.storage = storage;
+    __publicField(this, "memoryCache", /* @__PURE__ */ new Map());
+    __publicField(this, "cacheOrder", []);
+    __publicField(this, "hits", 0);
+    __publicField(this, "misses", 0);
+  }
+  /**
+   * Generate hash for text
+   */
+  getTextHash(text) {
+    return crypto__default.default.createHash("md5").update(text).digest("hex");
+  }
+  /**
+   * Get storage key for language pair
+   */
+  getStorageKey(sourceLang, targetLang) {
+    return `translator:${sourceLang}-${targetLang}`;
+  }
+  /**
+   * Load from persistent storage
+   */
+  loadFromStorage(sourceLang, targetLang) {
+    if (!this.storage) return {};
+    try {
+      const key = this.getStorageKey(sourceLang, targetLang);
+      const data = this.storage.getItem(key);
+      return data ? JSON.parse(data) : {};
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Save to persistent storage
+   */
+  saveToStorage(sourceLang, targetLang, cache) {
+    if (!this.storage) return;
+    try {
+      const key = this.getStorageKey(sourceLang, targetLang);
+      this.storage.setItem(key, JSON.stringify(cache));
+    } catch {
+    }
+  }
+  /**
+   * Evict oldest entries if memory is full
+   */
+  evictIfNeeded() {
+    while (this.memoryCache.size >= this.maxMemorySize && this.cacheOrder.length > 0) {
+      const oldestKey = this.cacheOrder.shift();
+      this.memoryCache.delete(oldestKey);
+    }
+  }
+  /**
+   * Get translation from cache
+   */
+  get(text, sourceLang, targetLang) {
+    const textHash = this.getTextHash(text);
+    const cacheKey = `${sourceLang}-${targetLang}:${textHash}`;
+    if (this.memoryCache.has(cacheKey)) {
+      this.hits++;
+      return this.memoryCache.get(cacheKey);
+    }
+    const fileCache = this.loadFromStorage(sourceLang, targetLang);
+    if (textHash in fileCache) {
+      const translation = fileCache[textHash];
+      this.evictIfNeeded();
+      this.memoryCache.set(cacheKey, translation);
+      this.cacheOrder.push(cacheKey);
+      this.hits++;
+      return translation;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Store translation in cache
+   */
+  set(text, sourceLang, targetLang, translation) {
+    const textHash = this.getTextHash(text);
+    const cacheKey = `${sourceLang}-${targetLang}:${textHash}`;
+    this.evictIfNeeded();
+    this.memoryCache.set(cacheKey, translation);
+    if (!this.cacheOrder.includes(cacheKey)) {
+      this.cacheOrder.push(cacheKey);
+    }
+    const fileCache = this.loadFromStorage(sourceLang, targetLang);
+    fileCache[textHash] = translation;
+    this.saveToStorage(sourceLang, targetLang, fileCache);
+  }
+  /**
+   * Get multiple translations at once
+   */
+  getMany(texts, sourceLang, targetLang) {
+    const cached = /* @__PURE__ */ new Map();
+    const uncached = [];
+    for (const text of texts) {
+      const translation = this.get(text, sourceLang, targetLang);
+      if (translation !== void 0) {
+        cached.set(text, translation);
+      } else {
+        uncached.push(text);
+      }
+    }
+    return { cached, uncached };
+  }
+  /**
+   * Store multiple translations at once
+   */
+  setMany(translations, sourceLang, targetLang) {
+    for (const [text, translation] of translations) {
+      this.set(text, sourceLang, targetLang, translation);
+    }
+  }
+  /**
+   * Clear cache
+   */
+  clear(sourceLang, targetLang) {
+    if (sourceLang && targetLang) {
+      const prefix = `${sourceLang}-${targetLang}:`;
+      for (const key of [...this.memoryCache.keys()]) {
+        if (key.startsWith(prefix)) {
+          this.memoryCache.delete(key);
+          const idx = this.cacheOrder.indexOf(key);
+          if (idx !== -1) this.cacheOrder.splice(idx, 1);
+        }
+      }
+      if (this.storage) {
+        this.storage.removeItem(this.getStorageKey(sourceLang, targetLang));
+      }
+    } else {
+      this.memoryCache.clear();
+      this.cacheOrder = [];
+      this.hits = 0;
+      this.misses = 0;
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const languagePairs = [];
+    const pairCounts = /* @__PURE__ */ new Map();
+    for (const key of this.memoryCache.keys()) {
+      const pair = key.split(":")[0];
+      pairCounts.set(pair, (pairCounts.get(pair) || 0) + 1);
+    }
+    for (const [pair, count] of pairCounts) {
+      languagePairs.push({ pair, translations: count });
+    }
+    return {
+      memorySize: this.memoryCache.size,
+      hits: this.hits,
+      misses: this.misses,
+      languagePairs
+    };
+  }
+};
+function createCache(maxMemorySize, storage) {
+  return new TranslationCache(maxMemorySize, storage);
+}
+
+// src/translator/json-translator.ts
+var DEFAULT_TRANSLATION_MODEL = "openai/gpt-4o-mini";
+var JsonTranslator = class {
+  constructor(client, cache, defaultModel) {
+    this.client = client;
+    __publicField(this, "cache");
+    __publicField(this, "defaultModel");
+    this.cache = cache ?? createCache();
+    this.defaultModel = defaultModel ?? DEFAULT_TRANSLATION_MODEL;
+  }
+  /**
+   * Detect language from text
+   */
+  detectLanguage(text) {
+    const script = detectScript(text);
+    switch (script) {
+      case "cjk":
+        return "zh";
+      case "cyrillic":
+        return "ru";
+      case "arabic":
+        return "ar";
+      default:
+        return "en";
+    }
+  }
+  /**
+   * Check if text needs translation
+   */
+  needsTranslation(text, sourceLang, targetLang) {
+    if (!text || !text.trim()) return false;
+    if (isTechnicalContent(text)) return false;
+    if (sourceLang === targetLang) return false;
+    return true;
+  }
+  /**
+   * Translate single text
+   */
+  async translateText(text, targetLanguage, options) {
+    if (!text || !text.trim()) return text;
+    const sourceLang = options?.sourceLanguage ?? "auto";
+    const actualSource = sourceLang === "auto" ? this.detectLanguage(text) : sourceLang;
+    if (!this.needsTranslation(text, actualSource, targetLanguage)) {
+      return text;
+    }
+    const cached = this.cache.get(text, actualSource, targetLanguage);
+    if (cached) return cached;
+    const response = await this.client.chat(
+      `Translate this text to ${targetLanguage}. Return ONLY the translation:
+
+${text}`,
+      {
+        ...options,
+        model: options?.model ?? this.defaultModel,
+        temperature: 0
+      }
+    );
+    const translated = response.content.trim();
+    this.cache.set(text, actualSource, targetLanguage, translated);
+    return translated;
+  }
+  /**
+   * Translate JSON object with smart text-level caching
+   *
+   * @example
+   * ```ts
+   * const translator = new JsonTranslator(llm)
+   * const result = await translator.translate(
+   *   { title: 'Hello', items: ['World', 'Earth'] },
+   *   'ru'
+   * )
+   * // { data: { title: 'Привет', items: ['Мир', 'Земля'] }, valid: true, ... }
+   * ```
+   */
+  async translate(data, targetLanguage, options) {
+    const sourceLang = options?.sourceLanguage ?? "auto";
+    const translatableTexts = this.extractTranslatableTexts(data, sourceLang, targetLanguage);
+    if (translatableTexts.size === 0) {
+      return {
+        data,
+        valid: true,
+        errors: [],
+        retries: 0,
+        sourceLanguage: sourceLang,
+        targetLanguage
+      };
+    }
+    let actualSource = sourceLang;
+    if (sourceLang === "auto") {
+      const firstText = [...translatableTexts][0];
+      actualSource = this.detectLanguage(firstText);
+    }
+    const { cached, uncached } = this.cache.getMany(
+      [...translatableTexts],
+      actualSource,
+      targetLanguage
+    );
+    if (uncached.length === 0) {
+      return {
+        data: this.applyTranslations(data, cached),
+        valid: true,
+        errors: [],
+        retries: 0,
+        sourceLanguage: actualSource,
+        targetLanguage
+      };
+    }
+    const partialJson = this.createPartialJson(data, new Set(uncached));
+    const jsonStr = JSON.stringify(partialJson, null, 2);
+    try {
+      const prompt = buildJsonTranslationPrompt(jsonStr, actualSource, targetLanguage);
+      const response = await this.client.chat(prompt, {
+        ...options,
+        model: options?.model ?? this.defaultModel,
+        temperature: 0
+      });
+      const translatedPartial = extractJson(response.content);
+      const newTranslations = this.extractTranslationsByComparison(
+        partialJson,
+        translatedPartial,
+        uncached
+      );
+      this.cache.setMany(newTranslations, actualSource, targetLanguage);
+      const allTranslations = new Map([...cached, ...newTranslations]);
+      return {
+        data: this.applyTranslations(data, allTranslations),
+        valid: true,
+        errors: [],
+        retries: 0,
+        sourceLanguage: actualSource,
+        targetLanguage
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error("Translation failed:", errorMsg);
+      return {
+        data: cached.size > 0 ? this.applyTranslations(data, cached) : data,
+        valid: false,
+        errors: [errorMsg],
+        retries: 0,
+        sourceLanguage: actualSource,
+        targetLanguage
+      };
+    }
+  }
+  /**
+   * Translate to multiple languages in parallel
+   */
+  async translateToMany(data, targetLanguages, options) {
+    const results = /* @__PURE__ */ new Map();
+    const promises = targetLanguages.map(async (lang) => {
+      const result = await this.translate(data, lang, options);
+      return { lang, result };
+    });
+    const settled = await Promise.all(promises);
+    for (const { lang, result } of settled) {
+      results.set(lang, result);
+    }
+    return results;
+  }
+  /**
+   * Extract all translatable texts from object
+   */
+  extractTranslatableTexts(obj, sourceLang, targetLang) {
+    const texts = /* @__PURE__ */ new Set();
+    const extract = (item) => {
+      if (typeof item === "string") {
+        if (this.needsTranslation(item, sourceLang, targetLang)) {
+          texts.add(item);
+        }
+      } else if (Array.isArray(item)) {
+        for (const i of item) extract(i);
+      } else if (item !== null && typeof item === "object") {
+        for (const v of Object.values(item)) extract(v);
+      }
+    };
+    extract(obj);
+    return texts;
+  }
+  /**
+   * Apply translations to object
+   */
+  applyTranslations(obj, translations) {
+    const apply = (item) => {
+      if (typeof item === "string") {
+        return translations.get(item) ?? item;
+      } else if (Array.isArray(item)) {
+        return item.map(apply);
+      } else if (item !== null && typeof item === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(item)) {
+          result[k] = apply(v);
+        }
+        return result;
+      }
+      return item;
+    };
+    return apply(obj);
+  }
+  /**
+   * Create partial JSON with only texts that need translation
+   */
+  createPartialJson(data, textsToInclude) {
+    const filter = (obj) => {
+      if (typeof obj === "string") {
+        return textsToInclude.has(obj) ? obj : "SKIP";
+      } else if (Array.isArray(obj)) {
+        return obj.map(filter).filter((i) => this.hasTranslatable(i, textsToInclude));
+      } else if (obj !== null && typeof obj === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+          const filtered = filter(v);
+          if (this.hasTranslatable(filtered, textsToInclude)) {
+            result[k] = filtered;
+          }
+        }
+        return result;
+      }
+      return obj;
+    };
+    return filter(data);
+  }
+  /**
+   * Check if object contains translatable text
+   */
+  hasTranslatable(obj, textsSet) {
+    if (typeof obj === "string") return textsSet.has(obj);
+    if (Array.isArray(obj)) return obj.some((i) => this.hasTranslatable(i, textsSet));
+    if (obj !== null && typeof obj === "object") {
+      return Object.values(obj).some((v) => this.hasTranslatable(v, textsSet));
+    }
+    return false;
+  }
+  /**
+   * Extract translations by comparing original and translated JSON
+   */
+  extractTranslationsByComparison(original, translated, uncachedTexts) {
+    const translations = /* @__PURE__ */ new Map();
+    const uncachedSet = new Set(uncachedTexts);
+    const compare = (orig, trans) => {
+      if (typeof orig === "string" && typeof trans === "string") {
+        if (uncachedSet.has(orig) && trans !== "SKIP" && trans.trim()) {
+          translations.set(orig, trans);
+        }
+      } else if (Array.isArray(orig) && Array.isArray(trans)) {
+        for (let i = 0; i < Math.min(orig.length, trans.length); i++) {
+          compare(orig[i], trans[i]);
+        }
+      } else if (orig !== null && typeof orig === "object" && trans !== null && typeof trans === "object") {
+        for (const key of Object.keys(orig)) {
+          if (key in trans) {
+            compare(
+              orig[key],
+              trans[key]
+            );
+          }
+        }
+      }
+    };
+    compare(original, translated);
+    return translations;
+  }
+  /**
+   * Get translation statistics
+   */
+  getStats() {
+    return this.cache.getStats();
+  }
+  /**
+   * Clear translation cache
+   */
+  clearCache(sourceLang, targetLang) {
+    this.cache.clear(sourceLang, targetLang);
+  }
+};
+function createTranslator(client, configOrCache) {
+  if (configOrCache instanceof TranslationCache) {
+    return new JsonTranslator(client, configOrCache);
+  }
+  return new JsonTranslator(client, configOrCache?.cache, configOrCache?.model);
+}
+
+// src/utils/schema.ts
+function generateSchemaFromExample(example) {
+  if (example === null) {
+    return { type: "null" };
+  }
+  if (Array.isArray(example)) {
+    const itemSchema = example.length > 0 ? generateSchemaFromExample(example[0]) : { type: "string" };
+    return { type: "array", items: itemSchema };
+  }
+  if (typeof example === "object") {
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(example)) {
+      properties[key] = generateSchemaFromExample(value);
+      required.push(key);
+    }
+    return { type: "object", properties, required };
+  }
+  return { type: typeof example };
+}
+function schemaToPromptString(schema) {
+  return JSON.stringify(schema, null, 2);
+}
+async function getStructuredOutput(client, prompt, schema, options) {
+  const response = await client.chat(prompt, {
+    ...options,
+    temperature: 0,
+    system: options?.system ?? "Return ONLY valid JSON matching the requested structure."
+  });
+  try {
+    const parsed = extractJson(response.content);
+    const result = schema.safeParse(parsed);
+    if (result.success) {
+      return { data: result.data, response };
+    }
+    return {
+      error: "Schema validation failed",
+      raw: parsed
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : "Failed to parse JSON",
+      raw: response.content
+    };
+  }
+}
+async function getStructuredOutputWithRetry(client, prompt, schema, options) {
+  const maxRetries = options?.maxRetries ?? 2;
+  let retries = 0;
+  let lastError = "";
+  let lastRaw;
+  while (retries <= maxRetries) {
+    const result = await getStructuredOutput(client, prompt, schema, options);
+    if ("data" in result) {
+      return { data: result.data, retries };
+    }
+    lastError = result.error;
+    lastRaw = result.raw;
+    retries++;
+    if (retries <= maxRetries) {
+      console.warn(`Structured output validation failed (attempt ${retries}/${maxRetries + 1})`);
+    }
+  }
+  return { error: lastError, raw: lastRaw, retries };
+}
+
+exports.JsonTranslator = JsonTranslator;
+exports.LANGUAGE_NAMES = LANGUAGE_NAMES;
+exports.LLMError = LLMError;
+exports.Model = Model;
+exports.ModelPresets = ModelPresets;
+exports.SDKROUTER_BASE_URL = SDKROUTER_BASE_URL;
+exports.TranslationCache = TranslationCache;
+exports.buildModelAlias = buildModelAlias;
+exports.createAnthropicClient = createAnthropicClient;
+exports.createCache = createCache;
+exports.createLLMClient = createLLMClient;
+exports.createOpenAIClient = createOpenAIClient;
+exports.createSDKRouterClient = createSDKRouterClient;
+exports.createTranslator = createTranslator;
+exports.detectProvider = detectProvider;
+exports.detectScript = detectScript;
+exports.extractJson = extractJson;
+exports.extractPlaceholders = extractPlaceholders;
+exports.generateSchemaFromExample = generateSchemaFromExample;
+exports.getApiKey = getApiKey;
+exports.getConfiguredProvider = getConfiguredProvider;
+exports.getDefaultModel = getDefaultModel;
+exports.getStructuredOutput = getStructuredOutput;
+exports.getStructuredOutputWithRetry = getStructuredOutputWithRetry;
+exports.isLLMConfigured = isLLMConfigured;
+exports.isTechnicalContent = isTechnicalContent;
+exports.schemaToPromptString = schemaToPromptString;
+exports.validateJsonKeys = validateJsonKeys;
+exports.validateTranslation = validateTranslation;
+exports.validateTranslationKeys = validateJsonKeys;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map