agentic-api 2.0.491 → 2.0.585

package/dist/src/llm/index.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * LLM Provider Instances
+ *
+ * Fournit une instance OpenAI configurable par provider:
+ * - llmInstance(): utilise LLM_PROVIDER depuis .env
+ * - llmInstance({provider: 'openai'}): force OpenAI
+ * - llmInstance({provider: 'xai'}): force xAI
+ *
+ * Configuration via .env:
+ * - LLM_PROVIDER: openai | xai (défaut: openai)
+ * - OPENAI_API_KEY: clé API OpenAI
+ * - XAI_API_KEY: clé API xAI
+ * - LLM_API_KEY: fallback pour les deux providers
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultProvider = exports.detectProvider = exports.PROVIDER_MAP = void 0;
+exports.llmInstance = llmInstance;
+exports.openaiInstance = openaiInstance;
+exports.resetInstances = resetInstances;
+const openai_1 = __importDefault(require("openai"));
+const config_1 = require("./config");
+function getInstancesMap() {
+    if (!globalThis._llmInstances_) {
+        globalThis._llmInstances_ = new Map();
+    }
+    return globalThis._llmInstances_;
+}
+/**
+ * Instance LLM configurable par provider
+ *
+ * @param config - Configuration optionnelle
+ * @param config.provider - Provider à utiliser ('openai' | 'xai')
+ * @param config.key - Clé API (optionnel, utilise env par défaut)
+ * @param config.baseUrl - Base URL (optionnel, utilise config provider par défaut)
+ *
+ * @example
+ * // Utilise le provider par défaut (.env LLM_PROVIDER)
+ * const openai = llmInstance();
+ *
+ * // Force OpenAI (pour embeddings, whisper)
+ * const openai = llmInstance({provider: 'openai'});
+ *
+ * // Force xAI
+ * const openai = llmInstance({provider: 'xai'});
+ */
+function llmInstance(config) {
+    const provider = config?.provider || (0, config_1.getDefaultProvider)();
+    const providerConfig = config_1.PROVIDER_MAP[provider];
+    if (!providerConfig) {
+        throw new Error(`Unknown provider: ${provider}. Valid providers: ${Object.keys(config_1.PROVIDER_MAP).join(', ')}`);
+    }
+    //
+    // Clé de cache: provider + éventuelles customisations
+    const cacheKey = config?.key || config?.baseUrl
+        ? `${provider}-${config?.key || ''}-${config?.baseUrl || ''}`
+        : provider;
+    const instances = getInstancesMap();
+    //
+    // Retourner l'instance existante si disponible (cache)
+    if (instances.has(cacheKey)) {
+        return instances.get(cacheKey);
+    }
+    //
+    // Résoudre la clé API: custom > provider env > fallback env
+    const apiKey = config?.key
+        || process.env[providerConfig.keyEnv]
+        || (providerConfig.fallbackKeyEnv ? process.env[providerConfig.fallbackKeyEnv] : undefined);
+    if (!apiKey) {
+        throw new Error(`API key missing for provider "${provider}". ` +
+            `Set ${providerConfig.keyEnv} or ${providerConfig.fallbackKeyEnv || 'LLM_API_KEY'} in your environment.`);
+    }
+    //
+    // Résoudre la base URL: custom > provider config
+    const baseURL = config?.baseUrl || providerConfig.baseURL;
+    const instance = new openai_1.default({
+        apiKey,
+        baseURL,
+        timeout: 60000 * 15,
+    });
+    instances.set(cacheKey, instance);
+    return instance;
+}
+/**
+ * @deprecated Utiliser llmInstance() à la place
+ * Alias pour rétrocompatibilité
+ */
+function openaiInstance(envKey, baseUrl) {
+    //
+    // Si des paramètres legacy sont passés, les utiliser
+    if (envKey || baseUrl) {
+        const provider = baseUrl?.includes('x.ai') ? 'xai' : 'openai';
+        return llmInstance({
+            provider,
+            key: envKey ? (process.env[envKey] || envKey) : undefined,
+            baseUrl
+        });
+    }
+    return llmInstance();
+}
+/**
+ * Reset toutes les instances (utile pour les tests)
+ */
+function resetInstances() {
+    globalThis._llmInstances_ = undefined;
+}
+//
+// Re-export config
+var config_2 = require("./config");
+Object.defineProperty(exports, "PROVIDER_MAP", { enumerable: true, get: function () { return config_2.PROVIDER_MAP; } });
+Object.defineProperty(exports, "detectProvider", { enumerable: true, get: function () { return config_2.detectProvider; } });
+Object.defineProperty(exports, "getDefaultProvider", { enumerable: true, get: function () { return config_2.getDefaultProvider; } });

package/dist/src/llm/openai.d.ts

@@ -0,0 +1,6 @@
+/**
+ * OpenAI Model Mappings
+ *
+ * Configuration des modèles pour le provider OpenAI
+ */
+export declare const LLMopenai: Record<string, any>;

package/dist/src/llm/openai.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * OpenAI Model Mappings
+ *
+ * Configuration des modèles pour le provider OpenAI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMopenai = void 0;
+exports.LLMopenai = {
+    // Vision capable models
+    "VISION": {
+        model: "gpt-5-mini",
+        temperature: 0.2,
+        stream: false
+    },
+    "VISION-fast": {
+        model: "gpt-5-mini",
+        temperature: 0.2,
+        stream: false
+    },
+    // Embedding models
+    // Note: memories-lite utilise ce modèle via agentic-server/src/config/memories.ts
+    // Usage: modelConfig('EMBEDDING-small', { provider: 'openai' }).model
+    "EMBEDDING-small": {
+        model: "text-embedding-3-small",
+        dimensions: 1536
+    },
+    "EMBEDDING-large": {
+        model: "text-embedding-3-large",
+        dimensions: 3072
+    },
+    // Audio models
+    "WHISPER": {
+        model: "whisper-1"
+    },
+    "TRANSCRIBE": {
+        model: "gpt-4o-mini-transcribe"
+    },
+    // Chat/Responses models
+    "LOW-fast": {
+        temperature: 1,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-5-nano",
+        reasoning_effort: "minimal",
+        verbosity: "low",
+        stream: true
+    },
+    "LOW": {
+        temperature: 1,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-5-nano",
+        reasoning_effort: "low",
+        verbosity: "low",
+        stream: true
+    },
+    "LOW-medium": {
+        temperature: 1,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-5-nano",
+        reasoning_effort: "medium",
+        verbosity: "low",
+        stream: true
+    },
+    "LOW-4fast": {
+        temperature: .2,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-4.1-nano",
+        stream: true
+    },
+    "MEDIUM-4.1-mini": {
+        temperature: .2,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-4.1-mini",
+        stream: true
+    },
+    "MEDIUM-4.1": {
+        temperature: .2,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-4.1",
+        stream: true
+    },
+    "MEDIUM-fast": {
+        temperature: 1,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-5-mini",
+        reasoning_effort: "minimal",
+        verbosity: "low",
+        stream: true
+    },
+    "MEDIUM": {
+        temperature: 1,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-5-mini",
+        reasoning_effort: "low",
+        verbosity: "low",
+        stream: true
+    },
+    "HIGH-fast": {
+        model: "gpt-5.2",
+        reasoning_effort: "none",
+        verbosity: "low",
+        temperature: 1,
+        stream: true
+    },
+    "HIGH": {
+        model: "gpt-5.2",
+        reasoning_effort: "low",
+        verbosity: "low",
+        stream: true
+    },
+    "HIGH-medium": {
+        model: "gpt-5.2",
+        reasoning_effort: "medium",
+        verbosity: "low",
+        stream: true
+    },
+    "SEARCH-fast": {
+        model: "gpt-5-nano",
+        tools: [
+            {
+                type: "web_search_preview",
+                user_location: {
+                    type: "approximate",
+                    country: "CH",
+                    city: "Geneva",
+                    region: "Geneva",
+                },
+            }
+        ],
+    },
+    "SEARCH": {
+        model: "gpt-5-mini",
+        reasoning: { effort: "low" },
+        tools: [
+            {
+                type: "web_search_preview",
+                user_location: {
+                    type: "approximate",
+                    country: "CH",
+                    city: "Geneva",
+                    region: "Geneva",
+                },
+            }
+        ],
+    },
+};

package/dist/src/llm/pricing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LLM Pricing
+ *
+ * Gère le pricing des modèles.
+ * Les mappings de modèles sont dans openai.ts et xai.ts
+ */
+import { CompletionUsage } from "openai/resources";
+import { Usage } from "../types";
+import { LLMProvider } from "./config";
+type ModelPricing = {
+    input: number;
+    cachedInput?: number;
+    output: number;
+};
+export declare const modelPricing: Record<string, ModelPricing>;
+export declare function calculateCost(model: string, usage?: CompletionUsage): number;
+export declare function accumulateCost(currentUsage: Usage, model: string, usage?: CompletionUsage): number;
+/**
+ * Retourne le mapping des modèles selon le provider
+ *
+ * @param provider - Provider ('openai' | 'xai') ou instance OpenAI (legacy)
+ * @param forceThinking - Force reasoning_effort à high
+ */
+export declare function LLM(provider?: LLMProvider | any, forceThinking?: boolean): Record<string, any>;
+export { LLMopenai } from './openai';
+export { LLMxai } from './xai';

package/dist/src/llm/pricing.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * LLM Pricing
+ *
+ * Gère le pricing des modèles.
+ * Les mappings de modèles sont dans openai.ts et xai.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMxai = exports.LLMopenai = exports.modelPricing = void 0;
+exports.calculateCost = calculateCost;
+exports.accumulateCost = accumulateCost;
+exports.LLM = LLM;
+const config_1 = require("./config");
+const openai_1 = require("./openai");
+const xai_1 = require("./xai");
+//
+// Pricing par modèle
+// - https://platform.openai.com/docs/pricing#latest-models
+// - https://x.ai/api (pour xAI)
+exports.modelPricing = {
+    // OpenAI GPT-4 family
+    "gpt-4.5-preview": { input: 0.000075, cachedInput: 0.0000325, output: 0.000125 },
+    "gpt-4.1": { input: 0.000002, cachedInput: 0.0000005, output: 0.000008 },
+    "gpt-4.1-mini": { input: 0.0000004, cachedInput: 0.0000001, output: 0.0000016 },
+    "gpt-4.1-nano": { input: 0.0000001, cachedInput: 0.000000025, output: 0.0000004 },
+    "gpt-4o": { input: 0.0000025, cachedInput: 0.00000125, output: 0.00001 },
+    "gpt-4o-audio-preview": { input: 0.0000025, output: 0.00001 },
+    "gpt-4o-realtime-preview": { input: 0.000005, cachedInput: 0.0000025, output: 0.00002 },
+    "gpt-4o-search-preview": { input: 0.000005, cachedInput: 0.0000025, output: 0.00002 },
+    "gpt-4o-mini": { input: 0.00000015, cachedInput: 0.000000075, output: 0.0000006 },
+    "gpt-4o-mini-audio-preview": { input: 0.00000015, output: 0.0000006 },
+    "gpt-4o-mini-realtime-preview": { input: 0.0000006, cachedInput: 0.0000003, output: 0.0000024 },
+    "gpt-4o-mini-search-preview": { input: 0.0000015, cachedInput: 0.00000075, output: 0.000006 },
+    "gpt-4o-mini-transcribe": { input: 0.0000015, output: 0.000006 },
+    // OpenAI GPT-5 family
+    "gpt-5": { input: 0.00000125, output: 0.00001 },
+    "gpt-5.1": { input: 0.00000125, output: 0.00001 },
+    "gpt-5.2": { input: 0.00000175, cachedInput: 0.000000175, output: 0.000014 },
+    "gpt-5-mini": { input: 0.00000025, output: 0.000002 },
+    "gpt-5-nano": { input: 0.00000005, output: 0.0000004 },
+    // OpenAI o-series
+    "o1": { input: 0.000015, cachedInput: 0.0000075, output: 0.00006 },
+    "o4-mini": { input: 0.0000011, cachedInput: 0.00000055, output: 0.0000044 },
+    "o3-mini": { input: 0.0000011, cachedInput: 0.00000055, output: 0.0000044 },
+    "o1-mini": { input: 0.0000011, cachedInput: 0.00000055, output: 0.0000044 },
+    // OpenAI Embeddings
+    "text-embedding-3-small": { input: 0.00000002, output: 0 },
+    "text-embedding-3-large": { input: 0.00000013, output: 0 },
+    // OpenAI Audio
+    "whisper-1": { input: 0.0001, output: 0 }, // per second
+    // xAI Grok 4 family (Décembre 2024)
+    // https://x.ai/api#pricing - Prix par token ($/1M tokens divisé par 1M)
+    "grok-4": { input: 0.000003, cachedInput: 0.000003, output: 0.000015 },
+    "grok-4-1-fast-reasoning": { input: 0.0000002, cachedInput: 0.0000002, output: 0.0000005 },
+    "grok-4-1-fast-non-reasoning": { input: 0.0000002, cachedInput: 0.0000002, output: 0.0000005 },
+    "grok-4-fast-reasoning": { input: 0.0000002, cachedInput: 0.0000002, output: 0.0000005 },
+    "grok-4-fast-non-reasoning": { input: 0.0000002, cachedInput: 0.0000002, output: 0.0000005 },
+    "grok-code-fast-1": { input: 0.0000002, output: 0.0000015 },
+};
+function calculateCost(model, usage) {
+    if (!usage) {
+        return 0;
+    }
+    if (!exports.modelPricing[model]) {
+        console.warn(`⚠️ Unknown model for pricing: ${model}`);
+        return 0;
+    }
+    const pricing = exports.modelPricing[model];
+    const cost = usage.prompt_tokens * pricing.input +
+        usage.completion_tokens * pricing.output;
+    return cost;
+}
+function accumulateCost(currentUsage, model, usage) {
+    if (!usage) {
+        return 0;
+    }
+    currentUsage.prompt += usage.prompt_tokens || 0;
+    currentUsage.completion += usage.completion_tokens || 0;
+    currentUsage.total += usage.total_tokens || 0;
+    const cost = calculateCost(model, usage);
+    currentUsage.cost += cost;
+    return currentUsage.cost;
+}
+//
+// Mapping provider → modèles
+const LLMmapping = {
+    openai: openai_1.LLMopenai,
+    xai: xai_1.LLMxai
+};
+/**
+ * Retourne le mapping des modèles selon le provider
+ *
+ * @param provider - Provider ('openai' | 'xai') ou instance OpenAI (legacy)
+ * @param forceThinking - Force reasoning_effort à high
+ */
+function LLM(provider, forceThinking) {
+    let resolvedProvider;
+    //
+    // Support legacy: instance OpenAI passée directement
+    if (provider && typeof provider === 'object' && provider.baseURL) {
+        resolvedProvider = provider.baseURL.includes('x.ai') ? 'xai' : 'openai';
+    }
+    else if (typeof provider === 'string') {
+        resolvedProvider = provider;
+    }
+    else {
+        resolvedProvider = (0, config_1.getDefaultProvider)();
+    }
+    const mapping = LLMmapping[resolvedProvider] || LLMmapping.openai;
+    //
+    // Clone pour éviter de muter l'original
+    const result = { ...mapping };
+    //
+    // Force reasoning_effort to high if thinking is enabled
+    if (forceThinking) {
+        Object.keys(result).forEach(key => {
+            if (result[key]?.reasoning_effort) {
+                result[key] = { ...result[key], reasoning_effort: "high" };
+            }
+        });
+    }
+    return result;
+}
+//
+// Re-export des mappings pour rétrocompatibilité
+var openai_2 = require("./openai");
+Object.defineProperty(exports, "LLMopenai", { enumerable: true, get: function () { return openai_2.LLMopenai; } });
+var xai_2 = require("./xai");
+Object.defineProperty(exports, "LLMxai", { enumerable: true, get: function () { return xai_2.LLMxai; } });

package/dist/src/llm/xai.d.ts

@@ -0,0 +1,17 @@
+/**
+ * xAI (Grok) Model Mappings
+ *
+ * Configuration des modèles pour le provider xAI
+ * Note: xAI ne supporte pas les embeddings ni Whisper nativement
+ *
+ * Modèles disponibles (Décembre 2024):
+ * - grok-4: Flagship model ($3.00/$15.00 per 1M tokens)
+ * - grok-4-1-fast-reasoning: Fast reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-4-1-fast-non-reasoning: Fast non-reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-4-fast-reasoning: Fast reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-4-fast-non-reasoning: Fast non-reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-code-fast-1: Agentic coding ($0.20/$1.50 per 1M tokens)
+ *
+ * Pricing: https://x.ai/api#pricing
+ */
+export declare const LLMxai: Record<string, any>;

package/dist/src/llm/xai.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * xAI (Grok) Model Mappings
+ *
+ * Configuration des modèles pour le provider xAI
+ * Note: xAI ne supporte pas les embeddings ni Whisper nativement
+ *
+ * Modèles disponibles (Décembre 2024):
+ * - grok-4: Flagship model ($3.00/$15.00 per 1M tokens)
+ * - grok-4-1-fast-reasoning: Fast reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-4-1-fast-non-reasoning: Fast non-reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-4-fast-reasoning: Fast reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-4-fast-non-reasoning: Fast non-reasoning ($0.20/$0.50 per 1M tokens)
+ * - grok-code-fast-1: Agentic coding ($0.20/$1.50 per 1M tokens)
+ *
+ * Pricing: https://x.ai/api#pricing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMxai = void 0;
+exports.LLMxai = {
+    // Vision capable models
+    "VISION": {
+        model: "grok-4",
+        temperature: 0.2,
+        stream: false
+    },
+    "VISION-fast": {
+        model: "grok-4-fast-reasoning",
+        temperature: 0.2,
+        stream: false
+    },
+    // Embedding models - xAI ne supporte pas les embeddings
+    // Si utilisé, une erreur sera levée par modelConfig
+    // "EMBEDDING-small": undefined,
+    // "EMBEDDING-large": undefined,
+    // Audio models - xAI ne supporte pas Whisper
+    // "WHISPER": undefined,
+    // "TRANSCRIBE": undefined,
+    // Chat/Responses models
+    "LOW-fast": {
+        temperature: 0.2,
+        model: "grok-code-fast-1",
+        stream: true
+    },
+    "LOW": {
+        temperature: 0.2,
+        model: "grok-4-fast-non-reasoning",
+        stream: true
+    },
+    "LOW-medium": {
+        temperature: 0.2,
+        model: "grok-4-fast-non-reasoning",
+        stream: true
+    },
+    "MEDIUM-fast": {
+        temperature: 0.2,
+        model: "grok-4-1-fast-reasoning",
+        stream: true
+    },
+    "MEDIUM": {
+        temperature: 0.2,
+        model: "grok-4-fast-reasoning",
+        stream: true
+    },
+    "HIGH-fast": {
+        model: "grok-4-1-fast-reasoning",
+        temperature: 0.2,
+        stream: true
+    },
+    "HIGH": {
+        model: "grok-4",
+        temperature: 0.2,
+        stream: true
+    },
+    "HIGH-medium": {
+        model: "grok-4",
+        temperature: 0.2,
+        stream: true
+    },
+    "SEARCH-fast": {
+        temperature: 0.2,
+        model: "grok-code-fast-1",
+        tools: [{ type: "web_search" }],
+    },
+    "SEARCH": {
+        temperature: 0.2,
+        model: "grok-4-fast-reasoning",
+        tools: [{ type: "web_search" }],
+    },
+};

package/dist/src/pricing.llm.d.ts

@@ -1,17 +1,5 @@
-import { CompletionUsage } from "openai/resources";
-import { Usage } from "./types";
-type ModelPricing = {
-    input: number;
-    cachedInput?: number;
-    output: number;
-};
-export declare const modelPricing: Record<string, ModelPricing>;
-export declare function calculateCost(model: string, usage?: CompletionUsage): number;
-export declare function accumulateCost(currentUsage: Usage, model: string, usage?: CompletionUsage): number;
-export declare function LLM(openai: any, forceThinking?: boolean): any;
-export declare const LLMxai: any;
 /**
- * Get model mapping for OpenAI
+ * @deprecated Ce fichier est conservé pour rétrocompatibilité.
+ * Utiliser les imports depuis './llm/pricing' directement.
  */
-export declare const LLMopenai: any;
-export {};
+export { modelPricing, calculateCost, accumulateCost, LLM, LLMxai, LLMopenai, } from './llm/pricing';