@djangocfg/llm 2.1.164

package/dist/sdkrouter-hlQlVd0v.d.cts

@@ -0,0 +1,171 @@
+import { a as LLMClient, b as LLMProvider, L as LLMConfig, f as LLMMessage, c as LLMRequestOptions, d as LLMResponse } from './types-D6lazgm1.cjs';
+
+/**
+ * Base LLM provider
+ */
+
+declare abstract class BaseLLMProvider implements LLMClient {
+    abstract provider: LLMProvider;
+    protected config: Required<Pick<LLMConfig, 'model' | 'temperature' | 'maxTokens'>> & LLMConfig;
+    constructor(config: LLMConfig);
+    /**
+     * Send chat messages (implemented by provider)
+     */
+    abstract chatMessages(messages: LLMMessage[], options?: LLMRequestOptions): Promise<LLMResponse>;
+    /**
+     * Send single chat message
+     */
+    chat(prompt: string, options?: LLMRequestOptions): Promise<LLMResponse>;
+    /**
+     * Get JSON response
+     */
+    json<T = unknown>(prompt: string, options?: LLMRequestOptions): Promise<T>;
+    /**
+     * Get JSON response with schema hint
+     */
+    jsonSchema<T = unknown>(prompt: string, schema: string, options?: LLMRequestOptions): Promise<T>;
+}
+
+/**
+ * SDKRouter provider
+ *
+ * Uses https://llm.sdkrouter.com - OpenAI-compatible LLM router
+ * with smart model aliases like @smart, @cheap, @balanced
+ */
+
+/** SDKRouter base URL */
+declare const SDKROUTER_BASE_URL = "https://llm.sdkrouter.com/v1";
+/**
+ * Model tier presets
+ *
+ * @example '@cheap', '@smart', '@balanced'
+ */
+type ModelTier = 'cheap' | 'budget' | 'standard' | 'balanced' | 'smart' | 'fast' | 'premium';
+/**
+ * Model capabilities (features)
+ *
+ * @example '@cheap+vision', '@smart+tools+json'
+ */
+type ModelCapability = 'vision' | 'tools' | 'agents' | 'json' | 'streaming' | 'long' | 'image';
+/**
+ * Model categories (use cases)
+ *
+ * @example '@balanced+code', '@smart+reasoning'
+ */
+type ModelCategory = 'code' | 'vision' | 'reasoning' | 'agents' | 'creative' | 'chat' | 'analysis';
+/**
+ * Model alias builder options
+ */
+interface ModelOptions {
+    vision?: boolean;
+    tools?: boolean;
+    agents?: boolean;
+    json?: boolean;
+    streaming?: boolean;
+    long?: boolean;
+    image?: boolean;
+    code?: boolean;
+    reasoning?: boolean;
+    creative?: boolean;
+    chat?: boolean;
+    analysis?: boolean;
+}
+/**
+ * Build model alias string
+ *
+ * @example
+ * ```ts
+ * buildModelAlias('smart')                    // '@smart'
+ * buildModelAlias('cheap', { vision: true })  // '@cheap+vision'
+ * buildModelAlias('balanced', { code: true, tools: true }) // '@balanced+code+tools'
+ * ```
+ */
+declare function buildModelAlias(tier: ModelTier, options?: ModelOptions): string;
+/**
+ * Model alias builder with IDE autocomplete
+ *
+ * @example
+ * ```ts
+ * import { Model } from '@djangocfg/llm'
+ *
+ * Model.smart()                        // '@smart'
+ * Model.cheap({ vision: true })        // '@cheap+vision'
+ * Model.balanced({ code: true })       // '@balanced+code'
+ * Model.fast({ tools: true, json: true }) // '@fast+tools+json'
+ * ```
+ */
+declare const Model: {
+    /** Cheapest available model */
+    readonly cheap: (options?: ModelOptions) => string;
+    /** Budget-friendly with decent quality */
+    readonly budget: (options?: ModelOptions) => string;
+    /** Standard tier */
+    readonly standard: (options?: ModelOptions) => string;
+    /** Best quality/price ratio (recommended) */
+    readonly balanced: (options?: ModelOptions) => string;
+    /** Highest quality model */
+    readonly smart: (options?: ModelOptions) => string;
+    /** Lowest latency model */
+    readonly fast: (options?: ModelOptions) => string;
+    /** Top-tier premium model */
+    readonly premium: (options?: ModelOptions) => string;
+    /**
+     * Build alias from raw strings (escape hatch)
+     *
+     * @example Model.alias('cheap', 'vision', 'code') // '@cheap+vision+code'
+     */
+    readonly alias: (tier: string, ...modifiers: string[]) => string;
+};
+/**
+ * Pre-built model aliases for common use cases
+ */
+declare const ModelPresets: {
+    /** Translation: cheap + json mode */
+    readonly translation: string;
+    /** Code generation: balanced + code */
+    readonly code: string;
+    /** Code with tools: balanced + code + tools */
+    readonly codeWithTools: string;
+    /** Vision: balanced + vision */
+    readonly vision: string;
+    /** Reasoning: smart + reasoning */
+    readonly reasoning: string;
+    /** Creative writing: balanced + creative */
+    readonly creative: string;
+    /** Fast chat: fast + chat */
+    readonly fastChat: string;
+    /** Analysis: balanced + analysis */
+    readonly analysis: string;
+    /** Agents: smart + agents + tools */
+    readonly agents: string;
+};
+/**
+ * SDKRouter provider config
+ */
+interface SDKRouterConfig extends LLMConfig {
+    /** Model tier (shortcut for building alias) */
+    tier?: ModelTier;
+    /** Model options for alias building */
+    modelOptions?: ModelOptions;
+}
+/**
+ * SDKRouter LLM provider
+ *
+ * Uses OpenAI-compatible API at https://llm.sdkrouter.com
+ *
+ * @example
+ * ```ts
+ * const llm = new SDKRouterProvider({
+ *   apiKey: process.env.SDKROUTER_API_KEY,
+ *   model: Model.balanced({ code: true })
+ * })
+ * ```
+ */
+declare class SDKRouterProvider extends BaseLLMProvider {
+    provider: LLMProvider;
+    private client;
+    constructor(config: SDKRouterConfig);
+    chatMessages(messages: LLMMessage[], options?: LLMRequestOptions): Promise<LLMResponse>;
+}
+
+export { BaseLLMProvider as B, Model as M, SDKROUTER_BASE_URL as S, ModelPresets as a, buildModelAlias as b, type ModelTier as c, type ModelCapability as d, type ModelCategory as e, type ModelOptions as f, SDKRouterProvider as g, type SDKRouterConfig as h };

package/dist/text-utils-DoYqMIr6.d.ts

@@ -0,0 +1,289 @@
+import { c as LLMRequestOptions, a as LLMClient } from './types-D6lazgm1.js';
+
+/**
+ * Translation Cache Manager
+ *
+ * Two-level caching: memory + localStorage/file
+ * Organized by language pairs for efficient lookup
+ */
+interface CacheStats$1 {
+    memorySize: number;
+    hits: number;
+    misses: number;
+    languagePairs: Array<{
+        pair: string;
+        translations: number;
+    }>;
+}
+/**
+ * Translation cache with memory + persistent storage
+ */
+declare class TranslationCache {
+    private maxMemorySize;
+    private storage?;
+    private memoryCache;
+    private cacheOrder;
+    private hits;
+    private misses;
+    constructor(maxMemorySize?: number, storage?: Storage);
+    /**
+     * Generate hash for text
+     */
+    private getTextHash;
+    /**
+     * Get storage key for language pair
+     */
+    private getStorageKey;
+    /**
+     * Load from persistent storage
+     */
+    private loadFromStorage;
+    /**
+     * Save to persistent storage
+     */
+    private saveToStorage;
+    /**
+     * Evict oldest entries if memory is full
+     */
+    private evictIfNeeded;
+    /**
+     * Get translation from cache
+     */
+    get(text: string, sourceLang: string, targetLang: string): string | undefined;
+    /**
+     * Store translation in cache
+     */
+    set(text: string, sourceLang: string, targetLang: string, translation: string): void;
+    /**
+     * Get multiple translations at once
+     */
+    getMany(texts: string[], sourceLang: string, targetLang: string): {
+        cached: Map<string, string>;
+        uncached: string[];
+    };
+    /**
+     * Store multiple translations at once
+     */
+    setMany(translations: Map<string, string>, sourceLang: string, targetLang: string): void;
+    /**
+     * Clear cache
+     */
+    clear(sourceLang?: string, targetLang?: string): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats$1;
+}
+/**
+ * Create translation cache
+ */
+declare function createCache(maxMemorySize?: number, storage?: Storage): TranslationCache;
+
+/**
+ * Translator types
+ */
+
+/**
+ * Language code
+ */
+type LanguageCode = 'en' | 'ru' | 'ko' | 'ja' | 'zh' | 'de' | 'fr' | 'es' | 'it' | 'pt' | 'pt-BR' | 'ar' | 'nl' | 'tr' | 'pl' | 'sv' | 'no' | 'da' | 'uk' | 'hi' | string;
+/**
+ * Language names map
+ */
+declare const LANGUAGE_NAMES: Record<string, string>;
+/**
+ * Translation options
+ */
+interface TranslateOptions extends LLMRequestOptions {
+    /** Source language (default: 'en') */
+    sourceLanguage?: LanguageCode;
+    /** Max retries on validation failure */
+    maxRetries?: number;
+    /** Preserve placeholders like {name}, {{var}} */
+    preservePlaceholders?: boolean;
+}
+/**
+ * Translation result
+ */
+interface TranslateResult<T> {
+    /** Translated data */
+    data: T;
+    /** Whether translation is valid (keys preserved) */
+    valid: boolean;
+    /** Validation errors if any */
+    errors: string[];
+    /** Number of retries used */
+    retries: number;
+    /** Source language */
+    sourceLanguage: string;
+    /** Target language */
+    targetLanguage: string;
+}
+/**
+ * Batch translation item
+ */
+interface BatchTranslateItem<T> {
+    /** Data to translate */
+    data: T;
+    /** Target language */
+    targetLanguage: LanguageCode;
+    /** Options override */
+    options?: TranslateOptions;
+}
+/**
+ * Cache stats
+ */
+interface CacheStats {
+    memorySize: number;
+    hits: number;
+    misses: number;
+    languagePairs: Array<{
+        pair: string;
+        translations: number;
+    }>;
+}
+
+/**
+ * JSON Translator class with smart caching
+ */
+declare class JsonTranslator {
+    private client;
+    private cache;
+    private defaultModel;
+    constructor(client: LLMClient, cache?: TranslationCache, defaultModel?: string);
+    /**
+     * Detect language from text
+     */
+    detectLanguage(text: string): LanguageCode;
+    /**
+     * Check if text needs translation
+     */
+    needsTranslation(text: string, sourceLang: string, targetLang: string): boolean;
+    /**
+     * Translate single text
+     */
+    translateText(text: string, targetLanguage: LanguageCode, options?: TranslateOptions): Promise<string>;
+    /**
+     * 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, ... }
+     * ```
+     */
+    translate<T extends Record<string, unknown>>(data: T, targetLanguage: LanguageCode, options?: TranslateOptions): Promise<TranslateResult<T>>;
+    /**
+     * Translate to multiple languages in parallel
+     */
+    translateToMany<T extends Record<string, unknown>>(data: T, targetLanguages: LanguageCode[], options?: TranslateOptions): Promise<Map<LanguageCode, TranslateResult<T>>>;
+    /**
+     * Extract all translatable texts from object
+     */
+    private extractTranslatableTexts;
+    /**
+     * Apply translations to object
+     */
+    private applyTranslations;
+    /**
+     * Create partial JSON with only texts that need translation
+     */
+    private createPartialJson;
+    /**
+     * Check if object contains translatable text
+     */
+    private hasTranslatable;
+    /**
+     * Extract translations by comparing original and translated JSON
+     */
+    private extractTranslationsByComparison;
+    /**
+     * Get translation statistics
+     */
+    getStats(): CacheStats$1;
+    /**
+     * Clear translation cache
+     */
+    clearCache(sourceLang?: string, targetLang?: string): void;
+}
+/**
+ * Translator options
+ */
+interface TranslatorConfig {
+    cache?: TranslationCache;
+    /** Model for translation (default: openai/gpt-4o-mini) */
+    model?: string;
+}
+/**
+ * Create JSON translator
+ */
+declare function createTranslator(client: LLMClient, configOrCache?: TranslationCache | TranslatorConfig): JsonTranslator;
+
+/**
+ * Translation validation
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validate that JSON keys are not translated
+ */
+declare function validateJsonKeys(original: unknown, translated: unknown, path?: string): ValidationResult;
+/**
+ * Validate that placeholders are preserved
+ */
+declare function validatePlaceholders$1(original: unknown, translated: unknown, path?: string): ValidationResult;
+/**
+ * Full validation of translation
+ */
+declare function validateTranslation(original: unknown, translated: unknown): ValidationResult;
+
+/**
+ * Text utilities for translation
+ */
+/**
+ * Check if text is technical content that shouldn't be translated
+ */
+declare function isTechnicalContent(text: string): boolean;
+/**
+ * Check if text contains CJK characters (Chinese, Japanese, Korean)
+ */
+declare function containsCJK(text: string): boolean;
+/**
+ * Check if text contains Cyrillic characters
+ */
+declare function containsCyrillic(text: string): boolean;
+/**
+ * Check if text contains Arabic characters
+ */
+declare function containsArabic(text: string): boolean;
+/**
+ * Detect script/language from text
+ */
+declare function detectScript(text: string): 'cjk' | 'cyrillic' | 'arabic' | 'latin' | 'unknown';
+/**
+ * Extract placeholders from text
+ */
+declare function extractPlaceholders(text: string): string[];
+/**
+ * Check if all placeholders are preserved in translation
+ */
+declare function validatePlaceholders(original: string, translated: string): {
+    valid: boolean;
+    missing: string[];
+    extra: string[];
+};
+/**
+ * Get values that need translation from JSON
+ */
+declare function extractTranslatableValues(obj: unknown, path?: string): Array<{
+    path: string;
+    value: string;
+}>;
+
+export { type BatchTranslateItem as B, type CacheStats as C, JsonTranslator as J, LANGUAGE_NAMES as L, TranslationCache as T, type ValidationResult as V, createCache as a, validateJsonKeys as b, createTranslator as c, detectScript as d, extractPlaceholders as e, type TranslateOptions as f, type TranslateResult as g, type LanguageCode as h, isTechnicalContent as i, validatePlaceholders$1 as j, extractTranslatableValues as k, containsCJK as l, containsCyrillic as m, containsArabic as n, validatePlaceholders as o, validateTranslation as v };