agentic-api 2.0.31 → 2.0.491

package/dist/src/execute.js

@@ -1,564 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.modelConfig = modelConfig;
-exports.sendFeedback = sendFeedback;
-exports.readCompletionsStream = readCompletionsStream;
-exports.executeAgentSet = executeAgentSet;
-exports.executeAgent = executeAgent;
-const princing_openai_1 = require("./princing.openai");
-const types_1 = require("./types");
-const utils_1 = require("./utils");
-const stategraph_1 = require("./stategraph");
-function modelConfig(model, custom) {
-    const defaultOptions = Object.assign({
-        stream_options: { "include_usage": true },
-    }, custom || {});
-    const mapping = {
-        "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: "medium",
-            verbosity: "low",
-            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
-        },
-        "LOW-4.1": {
-            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": {
-            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",
-            reasoning_effort: "minimal",
-            verbosity: "low",
-            temperature: 1,
-            stream: true
-        },
-        "HIGH-low": {
-            model: "gpt-5",
-            reasoning_effort: "low",
-            verbosity: "low",
-            stream: true
-        },
-        "HIGH-medium": {
-            model: "gpt-5",
-            reasoning_effort: "medium",
-            verbosity: "low",
-            stream: true
-        },
-        "SEARCH": {
-            temperature: 0.2,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-4o-mini-search-preview",
-            web_search_options: {
-                user_location: {
-                    type: "approximate",
-                    approximate: {
-                        country: "CH",
-                        city: "Geneva",
-                        region: "Geneva",
-                    },
-                },
-            },
-        },
-    };
-    const options = Object.assign(mapping[model], defaultOptions);
-    return options;
-}
-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`);
-}
-async function readCompletionsStream(params) {
-    const openai = (0, utils_1.openaiInstance)();
-    //
-    // set default context here
-    const { stateGraph, discussion, agentConfig, agents, agentName, stdout, final, session, verbose } = params;
-    const model = agentConfig.model.model;
-    const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
-    const content = final.choices[0]?.message.content;
-    let thinking = false;
-    let localResult = (0, types_1.enrichExecutionResult)({
-        runId: `${agentName}-${Date.now()}`,
-        startQuery: '',
-        actions: [],
-        lastMessage: '',
-        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
-        moreThinkin: false,
-    });
-    // Accumulate cost in the discussion usage
-    (0, princing_openai_1.accumulateCost)(discussion.usage, model, final.usage);
-    stateGraph.updateTokens(agentName, {
-        prompt: final.usage?.prompt_tokens || 0,
-        completion: final.usage?.completion_tokens || 0,
-        total: final.usage?.total_tokens || 0,
-        cost: 0 // Cost already accumulated directly in discussion.usage
-    });
-    // Store state (implementation can be added later if needed)
-    // discussion.state = final.id;
-    if (content) {
-        if (verbose)
-            console.log("✅ Agent (1): 🌶️🌶️🌶️  save content:", content?.length);
-        stateGraph.push(agentName, { role: "assistant", content });
-    }
-    // Si le modèle décide d'appeler une fonction (par exemple "transferAgents")
-    for (const functionCall of accumulatedFunctionCall) {
-        const args = JSON.parse(functionCall?.function?.arguments || '{}');
-        if (args.justification) {
-            sendFeedback({
-                agent: agentConfig.name,
-                stdout,
-                description: args.justification,
-                usage: discussion.usage,
-                state: '', // State will be set later if needed,
-                verbose
-            });
-        }
-        // Créer une référence mutable pour handleTransferCall
-        const currentAgentRef = { name: agentConfig.name };
-        const functionCallResult = await (0, utils_1.handleTransferCall)(discussion, currentAgentRef, agents, functionCall, session);
-        // result can be 
-        // {content, usage}  {did_transfer}
-        thinking = functionCallResult.thinking;
-        if (functionCallResult.usage) {
-            stateGraph.updateTokens(agentName, {
-                prompt: functionCallResult.usage.prompt || 0,
-                completion: functionCallResult.usage.completion || 0,
-                total: functionCallResult.usage.total || 0,
-                cost: functionCallResult.usage.cost || 0
-            });
-        }
-        if (functionCallResult.did_transfer) {
-            // record transfer action
-            localResult.actions.push({
-                action: 'transfert',
-                content: functionCallResult.destination_agent || currentAgentRef.name,
-                feedback: functionCallResult.feedback,
-            });
-            if (verbose)
-                console.log("✅ Agent transfer response:", functionCallResult.source_agent, ' call function ', functionCall.function.name, '::to', functionCallResult.destination_agent, ' transfer done ✅');
-            // Mise à jour du message système avec les nouvelles instructions du nouvel agent courant
-            const transferredAgent = agents.find(a => a.name === currentAgentRef.name) || agentConfig;
-            const instructions = transferredAgent.instructions;
-            const enrichedInstructions = await params.enrichWithMemory?.("system", transferredAgent, session);
-            stateGraph.set(agentName, instructions + '\n' + enrichedInstructions);
-            // Ajout de la réponse de l'appel de fonction dans le contexte conversationnel
-            const message = functionCallResult.content ?? `Le transfert vers l'agent "${transferredAgent.name}" a été effectué, Tu dois répondre immédiatement à la question.`;
-            stateGraph.push(agentName, {
-                role: "assistant",
-                content: message,
-                name: functionCallResult.name
-            });
-            // Immediately surface the tool confirmation to the user output
-            // feedback or message?
-            if (message) {
-                stdout.write(message + "\n");
-            }
-        }
-        //
-        // other function call have a result
-        else if (functionCallResult.content) {
-            // record tool action
-            localResult.actions.push({
-                action: functionCall?.function?.name,
-                content: functionCallResult.content || '',
-                feedback: functionCallResult.feedback,
-            });
-            // console.log("✅ Agent tool response:",agentConfig.name,'::',functionCall.function.name, ' with content',functionCallResult.content);
-            stateGraph.push(agentName, {
-                role: "assistant",
-                content: functionCallResult.content,
-                name: functionCallResult.name
-            });
-        }
-        //
-        // send user feedback 
-        if (functionCallResult.feedback) {
-            sendFeedback({
-                agent: agentConfig.name,
-                stdout,
-                description: functionCallResult.feedback,
-                usage: discussion.usage,
-                state: '', // State tracking can be added later if needed
-                verbose
-            });
-        }
-        // Réactualisation de la liste des outils pour le nouvel agent courant
-        const currentAgent = agents.find(a => a.name === currentAgentRef.name) || agentConfig;
-        const tools = currentAgent?.tools || [];
-        const followUpOptions = Object.assign({}, currentAgent?.model);
-        followUpOptions.messages = discussion.messages;
-        //
-        // always force HIGH model for follow up
-        followUpOptions.model = currentAgent.model.model;
-        if (tools.length > 0) {
-            followUpOptions.tools = tools;
-            followUpOptions.tool_choice = "auto";
-        }
-        // if(!functionCallResult.did_transfer) {
-        //   followUpOptions.tool_choice = "none";
-        // }
-        // Poursuite de la conversation avec le contexte mis à jour
-        const followUpStream = await openai.beta.chat.completions.stream(followUpOptions);
-        for await (const chunk of followUpStream) {
-            //process.stdout.write(chunk.choices[0]?.delta?.content || "");
-            const delta = chunk.choices[0]?.delta;
-            if (delta?.content) {
-                stdout.write(delta?.content);
-            }
-        }
-        const final = await followUpStream.finalChatCompletion();
-        // console.log("✅ DEBUG followUpOptions (OUT content):",final.choices[0]?.message.content);
-        // console.log("✅ DEBUG followUpOptions (OUT tool_calls):",final.choices[0]?.message.tool_calls);
-        //
-        // when called a function, agent must continue the conversation
-        // if(verbose) console.log("✅ Agent ( followUp - OUT):",currentAgent.name, 'with tool_calls ',!!(final.choices[0]?.message.tool_calls),' and content:' ,!!(final.choices[0]?.message.content));
-        if (final.choices[0]?.message.tool_calls) {
-            const partial = await readCompletionsStream({
-                stateGraph,
-                discussion,
-                agentConfig: currentAgent,
-                agents,
-                agentName,
-                stdout,
-                final,
-                session,
-                verbose,
-                enrichWithMemory: params.enrichWithMemory
-            });
-            localResult = (0, types_1.executionResultMerge)(localResult, partial);
-            return localResult;
-        }
-        // Accumulate final cost
-        stateGraph.updateTokens(agentName, {
-            prompt: final.usage?.prompt_tokens || 0,
-            completion: final.usage?.completion_tokens || 0,
-            total: final.usage?.total_tokens || 0,
-            cost: 0 // Cost calculation handled internally
-        });
-        //
-        // send the cost
-        sendFeedback({
-            agent: currentAgent.name,
-            stdout,
-            description: '',
-            usage: discussion.usage,
-            state: final.id || '',
-            verbose
-        });
-        const content = final.choices[0]?.message.content;
-        //
-        // capture new memory with the last message
-        await params.enrichWithMemory?.("assistant", currentAgent, session);
-        // if(verbose) console.log("✅ Agent (OUT):",currentAgent.name, 'with content length',!!content);
-        if (content) {
-            stateGraph.push(agentName, { role: "assistant", content });
-        }
-        if (content?.includes('<continue>')) {
-            localResult.moreThinkin = true;
-            return localResult;
-        }
-        return localResult;
-    }
-    return localResult;
-}
-/**
- * Executes a set of agents to process a user query
- *
- * This function initializes the agent memory, processes the user query through the appropriate
- * agent, and handles any agent transfers or tool calls that occur during execution.
- *
- * @param {AgentConfig[]} agentSet - Array of agent configurations
- * @param {AgenticContext} session - {memory, user, ...}  - Session object to store/read conversation state
- * @param {ExecuteAgentSetParams} params - Execution parameters
- * @returns {Promise<void>}
- */
-async function executeAgentSet(agentSet, context, params) {
-    const { query, verbose } = params;
-    const openai = (0, utils_1.openaiInstance)();
-    const agents = (0, utils_1.injectTransferTools)(agentSet);
-    const home = params.home || agents[0].name;
-    // 🎯 Récupération du StateGraph depuis le context (qui contient session, user, credential, etc.)
-    const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
-    // 📍 Agent spécialisé (persistant) vs Agent contextuel (temporaire)
-    const specializedAgent = home;
-    const discussion = stateGraph.createOrRestore(specializedAgent);
-    let currentAgent = (0, stategraph_1.getSpecializedAgent)(discussion) || specializedAgent;
-    // Référence mutable pour handleTransferCall
-    const currentAgentRef = { name: currentAgent };
-    // Trouver la config de l'agent courant
-    const currentAgentConfig = agents.find(a => a.name === currentAgent);
-    discussion.description = currentAgentConfig?.publicDescription;
-    if (!currentAgentConfig) {
-        throw new Error(`Agent ${currentAgent} not found`);
-    }
-    if (!currentAgentConfig.instructions) {
-        throw new Error(`Agent ${currentAgent} has no instructions`);
-    }
-    // 🔧 Setup system message si pas encore fait
-    let enrichedQuery = query;
-    if (!discussion.messages.length) {
-        discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
-        //
-        // add the initial agent to his memory as System
-        // Handle two-shot prompting: if instructions is an array, use the first part as a system message
-        const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
-        const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
-        stateGraph.set(specializedAgent, instructions);
-    }
-    else {
-        // enrich the user query with memory as User
-        enrichedQuery = (await params.enrichWithMemory?.("user", currentAgentConfig, context)) || query;
-    }
-    // Append the user's query to the session-specific messages
-    // input: `${getMemoryString(relevantMemories)}\n${input}`,
-    stateGraph.push(specializedAgent, { role: "user", content: enrichedQuery });
-    // Les outils (définition des fonctions) disponibles par l'agent courant
-    const tools = currentAgentConfig.tools;
-    // console.log('--- DBG toolLogic (1)',currentAgentConfig, currentAgentConfig?.toolLogic);
-    if (verbose) {
-        console.log('--- DBG current agent', currentAgentConfig.name, 'memory len:', discussion.messages.length);
-    }
-    // let shots = 1;
-    let result = (0, types_1.enrichExecutionResult)({
-        runId: `${specializedAgent}-${Date.now()}`,
-        startQuery: query,
-        actions: [],
-        lastMessage: '',
-        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
-        moreThinkin: false,
-    });
-    do {
-        const options = Object.assign({}, currentAgentConfig?.model);
-        options.messages = discussion.messages;
-        if (tools.length > 0) {
-            options.tools = tools;
-            options.tool_choice = "auto";
-        }
-        const stream = await openai.beta.chat.completions.stream(options);
-        // const intialinfo = [
-        //   "Analyse",
-        //   "Analyse en cours…",
-        //   "Hummm"
-        // ];
-        // const randomIndex = Math.floor(Math.random() * intialinfo.length);
-        // //
-        // // initial feedback
-        // sendFeedback({
-        //   agent:memory.currentAgent.name,
-        //   stdout:params.stdout,
-        //   description:intialinfo[randomIndex],
-        //   usage:memory.usage,
-        //   state:memory.state!
-        // })    
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (delta?.content) {
-                params.stdout.write(delta?.content);
-            }
-        }
-        const final = await stream.finalChatCompletion();
-        const partial = await readCompletionsStream({
-            stateGraph,
-            discussion,
-            agentConfig: currentAgentConfig,
-            agents,
-            agentName: specializedAgent,
-            stdout: params.stdout,
-            session: context,
-            final,
-            verbose,
-            enrichWithMemory: params.enrichWithMemory,
-        });
-        result = (0, types_1.executionResultMerge)(result, partial);
-        // Handle two-shot prompting: if instructions is an array, send the second part as a user message
-        // This allows for more complex agent behavior by providing additional context or instructions
-        // after the initial response, similar to chain-of-thought prompting
-        // if(Array.isArray(currentAgent.instructions && shots < currentAgent.instructions.length)){
-        //   const instructions = currentAgent.instructions[shots];
-        //   memory.messages.push({ role: "user", content: instructions });
-        //   thinking = true;
-        //   shots++;
-        // }
-        if (result.moreThinkin)
-            console.log("🌶️🌶️🌶️ restart thinking:");
-    } while (result.moreThinkin);
-    // 💾 Auto-save du StateGraph à la fin (context contient session, user, credential, etc.)
-    (0, stategraph_1.sessionStateGraphSet)(context, stateGraph);
-    // finalize result (usage accumulated via discussion.usage once here)
-    result.lastMessage = discussion.messages?.[discussion.messages.length - 1]?.content || '';
-    // Ensure usage reflects the aggregated discussion usage (prompt/completion/total)
-    if (discussion?.usage) {
-        result.usage = {
-            prompt: discussion.usage.prompt || 0,
-            completion: discussion.usage.completion || 0,
-            total: discussion.usage.total || 0,
-            cost: discussion.usage.cost || 0,
-        };
-    }
-    result = (0, types_1.enrichExecutionResult)(result);
-    return result;
-}
-async function executeAgent(agentSet, params) {
-    const { query, verbose } = params;
-    const openai = (0, utils_1.openaiInstance)();
-    const agent = agentSet.find(a => a.name === params.home);
-    if (!agent) {
-        throw new Error(`Agent ${params.home} not found`);
-    }
-    if (!agent.instructions) {
-        throw new Error(`Agent ${agent.name} has no instructions`);
-    }
-    // Simple message array without memory manager - but preserve conversation
-    const messages = [
-        { role: "system", content: agent.instructions },
-        { role: "user", content: query }
-    ];
-    let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
-    let state = '';
-    let maxIterations = 10; // Prevent infinite loops
-    let iterations = 0;
-    if (verbose) {
-        console.log('--- DBG executeAgent (simple):', agent.name);
-        console.log('--- DBG query:', `${query?.substring(0, 100)}...`);
-    }
-    // Execute the agent with tool call handling loop
-    while (iterations < maxIterations) {
-        iterations++;
-        const options = Object.assign({}, agent.model);
-        options.messages = messages;
-        const tools = agent.tools || [];
-        if (tools.length > 0) {
-            options.tools = tools;
-            options.tool_choice = "auto";
-        }
-        if (verbose) {
-            console.log('--- DBG executeAgent (simple):', agent.name, 'iterations:', iterations, '\n', messages.length, '\n---', messages[messages.length - 1]?.content);
-        }
-        const stream = await openai.beta.chat.completions.stream(options);
-        // Stream the response
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (delta?.content) {
-                params.stdout.write(delta?.content);
-            }
-        }
-        const final = await stream.finalChatCompletion();
-        // Update usage and state
-        const model = agent.model?.model;
-        (0, princing_openai_1.accumulateCost)(usage, model, final.usage);
-        state = final.id;
-        // Add assistant response to messages
-        const content = final.choices[0]?.message.content;
-        if (content) {
-            messages.push({ role: "assistant", content });
-        }
-        // Handle tool calls if any
-        const toolCalls = final.choices[0]?.message.tool_calls;
-        let hasToolCalls = false;
-        if (toolCalls && toolCalls.length > 0) {
-            hasToolCalls = true;
-            // First, update the assistant message with tool_calls
-            const lastAssistant = messages[messages.length - 1];
-            if (lastAssistant && lastAssistant.role === 'assistant') {
-                lastAssistant.tool_calls = toolCalls;
-            }
-            else {
-                // If no assistant message, add one with tool calls
-                messages.push({
-                    role: "assistant",
-                    content: content || null,
-                    tool_calls: toolCalls
-                });
-            }
-            // Then execute tools and add tool responses
-            for (const toolCall of toolCalls) {
-                const args = JSON.parse(toolCall.function.arguments || '{}');
-                // Execute tool if it exists in agent's toolLogic
-                if (agent.toolLogic && agent.toolLogic[toolCall.function.name]) {
-                    try {
-                        const result = await agent.toolLogic[toolCall.function.name](args, { state });
-                        messages.push({
-                            role: "tool",
-                            tool_call_id: toolCall.id,
-                            content: typeof result === 'string' ? result : JSON.stringify(result)
-                        });
-                    }
-                    catch (error) {
-                        messages.push({
-                            role: "tool",
-                            tool_call_id: toolCall.id,
-                            content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
-                        });
-                    }
-                }
-            }
-        }
-        // If no tool calls, we're done
-        if (!hasToolCalls) {
-            break;
-        }
-    }
-    return {
-        usage,
-        content: messages[messages.length - 1]?.content || '',
-        messages,
-        state
-    };
-}

package/dist/src/princing.openai.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.modelPricing = void 0;
-exports.calculateCost = calculateCost;
-exports.accumulateCost = accumulateCost;
-//
-// get/update pricing from openai
-// - https://platform.openai.com/docs/pricing#latest-models
-exports.modelPricing = {
-    "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-5 family
-    "gpt-5": { input: 0.00000125, output: 0.00001 },
-    "gpt-5-mini": { input: 0.00000025, output: 0.000002 },
-    "gpt-5-nano": { input: 0.00000005, output: 0.0000004 },
-    "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 },
-};
-function calculateCost(model, usage) {
-    if (!usage) {
-        return 0;
-    }
-    if (!exports.modelPricing[model]) {
-        throw new Error("Unknown model");
-    }
-    const pricing = exports.modelPricing[model];
-    const cost = usage.prompt_tokens * pricing.input +
-        // usage.completion_tokens * (pricing.cachedInput || 0) +
-        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;
-}

package/dist/src/rag/tools.d.ts

@@ -1,76 +0,0 @@
-import OpenAI from 'openai';
-import { RAGConfig } from './types';
-/**
- * Crée les outils RAG pour un agent
- */
-declare const createTools: (openai: OpenAI, config: RAGConfig) => {
-    toolsReferencesContent: {
-        type: "function";
-        function: {
-            name: string;
-            description: string;
-            parameters: {
-                type: string;
-                properties: {
-                    service: {
-                        type: string;
-                        description: string;
-                    };
-                    source: {
-                        type: string;
-                        description: string;
-                    };
-                };
-                required: never[];
-                additionalProperties: boolean;
-            };
-        };
-    };
-    toolsKnowledge: {
-        type: "function";
-        function: {
-            name: string;
-            description: string;
-            parameters: {
-                type: string;
-                properties: {
-                    question: {
-                        type: string;
-                        description: string;
-                    };
-                    justification: {
-                        type: string;
-                        description: string;
-                    };
-                    action_suivante: {
-                        type: string;
-                        description: string;
-                    };
-                };
-                required: string[];
-                additionalProperties: boolean;
-            };
-        };
-    };
-    lookupReferencesContent: ({ service, source }: {
-        service?: string;
-        source?: string;
-    }) => Promise<{
-        content: string;
-    }>;
-    lookupKnowledge: (args: any, debug?: boolean) => Promise<{
-        content: string;
-        documents?: undefined;
-        scores?: undefined;
-    } | {
-        documents: {
-            id: number;
-            ref: string;
-            score: number;
-            content: string;
-        }[];
-        scores: number[];
-        content?: undefined;
-    }>;
-};
-export { createTools };