agentic-api 2.0.491 → 2.0.592

package/dist/src/execute/responses.js

@@ -36,8 +36,9 @@ exports.executeAgent = executeAgent;
 exports.executeQuery = executeQuery;
 const types_1 = require("../types");
 const utils_1 = require("../utils");
+const llm_1 = require("../llm");
 const stategraph_1 = require("../stategraph");
-const pricing_llm_1 = require("../pricing.llm");
+const pricing_1 = require("../llm/pricing");
 //
 // Import des utilitaires partagés et helpers optimisés
 const shared_1 = require("./shared");
@@ -95,7 +96,7 @@ async function createResponseStream(openai, options, stdout) {
  * - response.completed → finalisation
  */
 async function readCompletionsStream(params) {
-    const openai = (0, utils_1.openaiInstance)();
+    const openai = (0, llm_1.llmInstance)();
     const { stateGraph, discussion, agentConfig, agents, discussionRootAgent, stdout, final, context, verbose } = params;
     const model = (0, modelconfig_1.modelConfig)(agentConfig.model, {}, true).model; // forResponses=true
     const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
@@ -313,7 +314,7 @@ async function readCompletionsStream(params) {
  */
 async function executeAgentSet(agentSet, context, params) {
     const { query, verbose } = params;
-    const openai = (0, utils_1.openaiInstance)();
+    const openai = (0, llm_1.llmInstance)();
     const agents = (0, utils_1.injectTransferTools)(agentSet);
     const discussionRootAgent = params.home || agents[0].name;
     const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
@@ -434,7 +435,7 @@ async function executeAgentSet(agentSet, context, params) {
  */
 async function executeAgent(agentSet, params) {
     const { query, verbose, debug } = params;
-    const openai = (0, utils_1.openaiInstance)();
+    const openai = (0, llm_1.llmInstance)();
     const agent = agentSet.find(a => a.name === params.home);
     if (!agent) {
         throw new Error(`Agent ${params.home} not found`);
@@ -477,7 +478,7 @@ async function executeAgent(agentSet, params) {
         // normalizeOutputFromResponses retourne directement le format Chat Completions
         const final = await createResponseStream(openai, options, params.stdout);
         const model = (0, modelconfig_1.modelConfig)(agent.model, {}, true).model;
-        (0, pricing_llm_1.accumulateCost)(usage, model, final.usage);
+        (0, pricing_1.accumulateCost)(usage, model, final.usage);
         state = final.id;
         const content = final.choices[0]?.message.content || '';
         const toolCalls = final.choices[0]?.message.tool_calls || [];
@@ -531,7 +532,7 @@ async function executeQuery(params) {
     if (!modelName) {
         throw new Error('executeQuery requires "model" parameter');
     }
-    const openai = (0, utils_1.openaiInstance)();
+    const openai = (0, llm_1.llmInstance)();
     const model = (0, modelconfig_1.modelConfig)(modelName, {}, true); // forResponses=true
     // Responses API: response_format → text.format
     // Fusionner avec text.verbosity qui peut venir de modelConfig
@@ -571,7 +572,7 @@ async function executeQuery(params) {
         // Responses API: utiliser responses.stream() avec .on() handlers et .finalResponse()
         // normalizeOutputFromResponses retourne directement le format Chat Completions
         const final = await createResponseStream(openai, options, params.stdout);
-        (0, pricing_llm_1.accumulateCost)(usage, model.model, final.usage);
+        (0, pricing_1.accumulateCost)(usage, model.model, final.usage);
         state = final.id || '';
         const content = final.choices[0]?.message.content || '';
         if (verbose) {

package/dist/src/index.d.ts

@@ -6,11 +6,15 @@ export * from './utils';
 export * from './types';
 export * from './stategraph';
 export * from './execute';
-export * from './pricing.llm';
+export { llmInstance, resetInstances, openaiInstance, PROVIDER_MAP, detectProvider, getDefaultProvider } from './llm';
+export type { LLMProvider, LLMConfig, ProviderConfig } from './llm';
+export { modelPricing, calculateCost, accumulateCost, LLM, LLMxai, LLMopenai } from './llm/pricing';
+export { modelConfig } from './execute/modelconfig';
 export * from './scrapper';
 export * from './agents/reducer';
 export * from './agents/semantic';
 export * from './agents/system';
+export * from './agents/job.runner';
 export * from './rag';
 export * from './usecase';
 export * from './rules';
@@ -18,3 +22,4 @@ export * from './agents/simulator';
 export * from './agents/simulator.types';
 export * from './agents/simulator.prompts';
 export * from './agents/simulator.utils';
+export * from './agents/simulator.dashboard';

package/dist/src/index.js

@@ -18,6 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelConfig = exports.LLMopenai = exports.LLMxai = exports.LLM = exports.accumulateCost = exports.calculateCost = exports.modelPricing = exports.getDefaultProvider = exports.detectProvider = exports.PROVIDER_MAP = exports.openaiInstance = exports.resetInstances = exports.llmInstance = void 0;
 // Export des utilitaires
 __exportStar(require("./utils"), exports);
 // Types
@@ -26,13 +27,31 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./stategraph"), exports);
 // Execute (avec feature toggle legacy/responses)
 __exportStar(require("./execute"), exports);
-__exportStar(require("./pricing.llm"), exports);
+// LLM - providers et pricing
+var llm_1 = require("./llm");
+Object.defineProperty(exports, "llmInstance", { enumerable: true, get: function () { return llm_1.llmInstance; } });
+Object.defineProperty(exports, "resetInstances", { enumerable: true, get: function () { return llm_1.resetInstances; } });
+Object.defineProperty(exports, "openaiInstance", { enumerable: true, get: function () { return llm_1.openaiInstance; } });
+Object.defineProperty(exports, "PROVIDER_MAP", { enumerable: true, get: function () { return llm_1.PROVIDER_MAP; } });
+Object.defineProperty(exports, "detectProvider", { enumerable: true, get: function () { return llm_1.detectProvider; } });
+Object.defineProperty(exports, "getDefaultProvider", { enumerable: true, get: function () { return llm_1.getDefaultProvider; } });
+var pricing_1 = require("./llm/pricing");
+Object.defineProperty(exports, "modelPricing", { enumerable: true, get: function () { return pricing_1.modelPricing; } });
+Object.defineProperty(exports, "calculateCost", { enumerable: true, get: function () { return pricing_1.calculateCost; } });
+Object.defineProperty(exports, "accumulateCost", { enumerable: true, get: function () { return pricing_1.accumulateCost; } });
+Object.defineProperty(exports, "LLM", { enumerable: true, get: function () { return pricing_1.LLM; } });
+Object.defineProperty(exports, "LLMxai", { enumerable: true, get: function () { return pricing_1.LLMxai; } });
+Object.defineProperty(exports, "LLMopenai", { enumerable: true, get: function () { return pricing_1.LLMopenai; } });
+// Model config (central pour tous les mappings: responses, embeddings, vision, whisper)
+var modelconfig_1 = require("./execute/modelconfig");
+Object.defineProperty(exports, "modelConfig", { enumerable: true, get: function () { return modelconfig_1.modelConfig; } });
 // Scrapper
 __exportStar(require("./scrapper"), exports);
 // Agents
 __exportStar(require("./agents/reducer"), exports);
 __exportStar(require("./agents/semantic"), exports);
 __exportStar(require("./agents/system"), exports);
+__exportStar(require("./agents/job.runner"), exports);
 // RAG Library
 __exportStar(require("./rag"), exports);
 // Usecase
@@ -44,3 +63,4 @@ __exportStar(require("./agents/simulator"), exports);
 __exportStar(require("./agents/simulator.types"), exports);
 __exportStar(require("./agents/simulator.prompts"), exports);
 __exportStar(require("./agents/simulator.utils"), exports);
+__exportStar(require("./agents/simulator.dashboard"), exports);

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

@@ -0,0 +1,25 @@
+/**
+ * Configuration des providers LLM
+ *
+ * Définit les baseURL, clés API et configurations par provider.
+ */
+export type LLMProvider = 'openai' | 'xai';
+export interface LLMConfig {
+    provider?: LLMProvider;
+    key?: string;
+    baseUrl?: string;
+}
+export interface ProviderConfig {
+    baseURL: string;
+    keyEnv: string;
+    fallbackKeyEnv?: string;
+}
+export declare const PROVIDER_MAP: Record<LLMProvider, ProviderConfig>;
+/**
+ * Détecte le provider à partir d'une baseURL
+ */
+export declare function detectProvider(baseURL?: string): LLMProvider;
+/**
+ * Retourne le provider par défaut depuis les variables d'environnement
+ */
+export declare function getDefaultProvider(): LLMProvider;

package/dist/src/llm/config.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Configuration des providers LLM
+ *
+ * Définit les baseURL, clés API et configurations par provider.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_MAP = void 0;
+exports.detectProvider = detectProvider;
+exports.getDefaultProvider = getDefaultProvider;
+exports.PROVIDER_MAP = {
+    openai: {
+        baseURL: 'https://api.openai.com/v1',
+        keyEnv: 'OPENAI_API_KEY',
+        fallbackKeyEnv: 'LLM_API_KEY'
+    },
+    xai: {
+        baseURL: 'https://api.x.ai/v1',
+        keyEnv: 'XAI_API_KEY',
+        fallbackKeyEnv: 'LLM_API_KEY'
+    }
+};
+/**
+ * Détecte le provider à partir d'une baseURL
+ */
+function detectProvider(baseURL) {
+    if (!baseURL)
+        return process.env.LLM_PROVIDER || 'openai';
+    if (baseURL.includes('x.ai'))
+        return 'xai';
+    return 'openai';
+}
+/**
+ * Retourne le provider par défaut depuis les variables d'environnement
+ */
+function getDefaultProvider() {
+    return process.env.LLM_PROVIDER || 'openai';
+}

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

@@ -0,0 +1,48 @@
+/**
+ * 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
+ */
+import OpenAI from 'openai';
+import { LLMConfig } from './config';
+declare global {
+    var _llmInstances_: Map<string, OpenAI> | undefined;
+}
+/**
+ * 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'});
+ */
+export declare function llmInstance(config?: LLMConfig): OpenAI;
+/**
+ * @deprecated Utiliser llmInstance() à la place
+ * Alias pour rétrocompatibilité
+ */
+export declare function openaiInstance(envKey?: string, baseUrl?: string): OpenAI;
+/**
+ * Reset toutes les instances (utile pour les tests)
+ */
+export declare function resetInstances(): void;
+export { PROVIDER_MAP, LLMProvider, LLMConfig, detectProvider, getDefaultProvider, ProviderConfig } from './config';

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; } });