agentic-api 2.0.314 → 2.0.585

package/dist/src/execute/shared.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyWritable = void 0;
+exports.sendFeedback = sendFeedback;
+exports.normalizeOptionsForResponses = normalizeOptionsForResponses;
+exports.normalizedFunctionCallFromResponse = normalizedFunctionCallFromResponse;
+exports.normalizeOutputFromResponses = normalizeOutputFromResponses;
+exports.convertMessagesToResponsesInput = convertMessagesToResponsesInput;
+//
+// Writable vide pour les tests
+exports.DummyWritable = {
+    write: () => { }
+};
+//
+// Envoi de feedback temps réel vers l'UX
+// Informe l'utilisateur de l'état de l'analyse : agent actif, description, usage, state
+function sendFeedback(params) {
+    const { agent, stdout, description, usage, state, verbose } = params;
+    const feedback = {
+        agent,
+        description,
+        usage,
+        state
+    };
+    // if(verbose) {
+    //   console.log('--- DBG sendFeedback:',agent, description || '--', state);
+    // }
+    //
+    // send agent state and description
+    stdout.write(`\n<step>${JSON.stringify(feedback)}</step>\n`);
+}
+/**
+ * Normalise les options pour l'API Responses
+ *
+ * Transforme les paramètres du format Chat Completions vers Responses API:
+ * - Tools: { type: "function", function: {...} } → { type: "function", name, description, parameters, strict }
+ * - Autres transformations futures si nécessaire
+ *
+ * @param options - Options à normaliser
+ * @returns Options normalisées pour Responses API
+ */
+function normalizeOptionsForResponses(options) {
+    const normalized = { ...options };
+    // Transformer les tools au format Responses API
+    if (normalized.tools && normalized.tools.length > 0) {
+        normalized.tools = normalized.tools.map((tool) => {
+            if (tool.type === 'function' && tool.function) {
+                // Format Chat Completions → Responses API
+                return {
+                    type: 'function',
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    parameters: tool.function.parameters,
+                    strict: tool.function.strict ?? true
+                };
+            }
+            // Déjà au bon format ou type différent
+            return tool;
+        });
+    }
+    return normalized;
+}
+/**
+ * Normalise un function call du format Responses vers Chat Completions
+ *
+ * Responses API: { type: "function_call", name, arguments, call_id }
+ * Chat Completions: { id, type: "function", function: { name, arguments } }
+ *
+ * Si déjà au format Chat Completions (avec .function), retourne tel quel
+ *
+ * @param functionCall - Function call au format Responses ou Chat Completions
+ * @returns Function call au format Chat Completions
+ */
+function normalizedFunctionCallFromResponse(functionCall) {
+    // Si déjà au format Chat Completions, retourner tel quel
+    if (functionCall.function) {
+        return functionCall;
+    }
+    // Transformer du format Responses vers Chat Completions
+    return {
+        id: functionCall.call_id,
+        type: "function",
+        function: {
+            name: functionCall.name,
+            arguments: functionCall.arguments
+        }
+    };
+}
+/**
+ * Normalise l'output de l'API Responses vers le format Chat Completions
+ *
+ * Transforme la structure Responses API vers le format attendu par le reste du code
+ *
+ * Format Responses API (result.output array):
+ * - { type: "reasoning", summary: [] }
+ * - { type: "message", content: [{ type: "output_text", text: "..." }] }
+ * - { type: "function_call", name, arguments, call_id }
+ *
+ * Format Chat Completions compatible:
+ * - { choices: [{ message: { content, tool_calls, reasoning_text } }], usage: {...}, id: "..." }
+ *
+ * @param result - Résultat de stream.finalResponse()
+ * @returns Résultat au format Chat Completions avec reasoning_text si présent
+ */
+function normalizeOutputFromResponses(result) {
+    let text = '';
+    let reasoningText = ''; // ✅ Capturer reasoning_text pour modèles reasoning (o-series, gpt-5)
+    const functionCalls = [];
+    // Parcourir les output items pour extraire text, reasoning et function_calls
+    if (result.output && Array.isArray(result.output)) {
+        for (const item of result.output) {
+            // Function calls sont directement dans output
+            if (item.type === 'function_call') {
+                functionCalls.push(item);
+            }
+            // ✅ Capturer reasoning (v5.22.0)
+            else if (item.type === 'reasoning' && item.summary) {
+                reasoningText = Array.isArray(item.summary) ? item.summary.join('\n') : String(item.summary);
+            }
+            // Messages contiennent le texte
+            else if (item.type === 'message' && item.content) {
+                for (const content of item.content) {
+                    if (content.type === 'output_text' && content.text) {
+                        text += content.text;
+                    }
+                }
+            }
+        }
+    }
+    // Transformer tous les function_calls vers le format Chat Completions
+    const toolCalls = functionCalls.map(normalizedFunctionCallFromResponse);
+    // Retourner au format Chat Completions avec reasoning_text optionnel
+    return {
+        choices: [{
+                message: {
+                    tool_calls: toolCalls,
+                    content: text,
+                    reasoning_text: reasoningText || undefined // ✅ Optionnel, seulement si présent
+                }
+            }],
+        usage: {
+            prompt_tokens: result.usage?.input_tokens || 0,
+            completion_tokens: result.usage?.output_tokens || 0,
+            total_tokens: (result.usage?.input_tokens || 0) + (result.usage?.output_tokens || 0)
+        },
+        id: result.id
+    };
+}
+/**
+ * Convertit les messages du stateGraph vers le format Responses API input
+ * Gère les messages normaux, tool_calls (Chat Completions), et function_call_output (Responses)
+ *
+ * Utilisée par:
+ * - readCompletionsStream (responses.ts) pour le follow-up après tool calls
+ * - executeAgentSet (responses.ts) pour préparer l'input initial
+ *
+ * @param messages Messages du stateGraph
+ * @returns Array d'items au format Responses API input
+ */
+function convertMessagesToResponsesInput(messages) {
+    return messages.flatMap((m) => {
+        // ✅ Messages function_call_output ont un format différent (pas de role)
+        if (m.type === 'function_call_output') {
+            return [{ type: m.type, call_id: m.call_id, output: m.output }];
+        }
+        // ✅ Messages avec tool_calls → convertir vers le format Responses API
+        // Documentation: "input_list += response.output" ajoute reasoning + function_calls
+        if (m.tool_calls && m.tool_calls.length > 0) {
+            const result = [];
+            // Ajouter le message assistant si content présent
+            if (m.content) {
+                result.push({ role: m.role, content: m.content });
+            }
+            // Convertir chaque tool_call (Chat Completions) en function_call (Responses)
+            for (const tc of m.tool_calls) {
+                result.push({
+                    type: "function_call",
+                    call_id: tc.id,
+                    name: tc.function.name,
+                    arguments: tc.function.arguments
+                });
+            }
+            return result;
+        }
+        // Messages normaux avec role
+        return [{ role: m.role, content: m.content }];
+    });
+}

package/dist/src/index.d.ts

@@ -6,7 +6,10 @@ 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';
@@ -18,3 +21,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,15 +18,33 @@ 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
 __exportStar(require("./types"), exports);
 // StateGraph - nouvelle architecture de gestion des discussions
 __exportStar(require("./stategraph"), exports);
-// Execute
+// 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
@@ -44,3 +62,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';