agentic-api 2.0.31 → 2.0.491

package/dist/src/execute/legacy.js

@@ -0,0 +1,460 @@
+"use strict";
+/**
+ * Legacy Implementation - Chat Completions API (beta.chat.completions)
+ *
+ * ⚠️ Cette implémentation utilise openai.beta.chat.completions.stream (ancienne API)
+ * Pour les nouveaux projets, Responses API (responses.ts) est recommandée.
+ *
+ * Code optimisé depuis execute.ts original avec les améliorations suivantes:
+ * - OPTIM: Helpers centralisés (accumulateUsageTokens, stepsToActions)
+ * - BUG FIX: executionResultMerge fusionne actions correctement (corrigé dans types.ts)
+ * - BUG FIX: moreThinkin supprimé (obsolète, reasoning_effort fait le job)
+ * - BUG FIX: Suppression de la boucle do...while(moreThinkin)
+ * - BUG FIX: Suppression de la ligne reasoning_effort dupliquée (ligne 425 originale)
+ *
+ * TODO [Optimisation future]: Remplacer la boucle for séquentielle par batchProcessToolCalls
+ * pour exploiter pleinement parallel_tool_calls et réduire la latence
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCompletionsStream = readCompletionsStream;
+exports.executeAgentSet = executeAgentSet;
+exports.executeAgent = executeAgent;
+exports.executeQuery = executeQuery;
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const stategraph_1 = require("../stategraph");
+const pricing_llm_1 = require("../pricing.llm");
+//
+// Import des utilitaires partagés et helpers optimisés
+const shared_1 = require("./shared");
+const modelconfig_1 = require("./modelconfig");
+const helpers_1 = require("./helpers");
+async function readCompletionsStream(params) {
+    const openai = (0, utils_1.openaiInstance)();
+    const { stateGraph, discussion, agentConfig, agents, discussionRootAgent, stdout, final, context, verbose } = params;
+    const model = (0, modelconfig_1.modelConfig)(agentConfig.model).model;
+    const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
+    const content = final.choices[0]?.message.content;
+    let localResult = (0, types_1.enrichExecutionResult)({
+        runId: `${discussionRootAgent}-${Date.now()}`,
+        startQuery: '',
+        actions: [],
+        lastMessage: '',
+        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+    });
+    //
+    // OPTIM: Utiliser helper centralisé pour l'accumulation
+    (0, helpers_1.accumulateUsageTokens)(stateGraph, discussion, discussionRootAgent, model, final.usage);
+    if (content) {
+        if (verbose)
+            console.log("✅ Agent (1): save content:", content?.length);
+        stateGraph.push(discussionRootAgent, { 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) {
+            (0, shared_1.sendFeedback)({
+                agent: agentConfig.name,
+                stdout,
+                description: args.justification,
+                usage: discussion.usage,
+                state: '',
+                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, context);
+        if (functionCallResult.usage) {
+            stateGraph.updateTokens(discussionRootAgent, {
+                prompt: functionCallResult.usage.prompt || 0,
+                completion: functionCallResult.usage.completion || 0,
+                total: functionCallResult.usage.total || 0,
+                cost: functionCallResult.usage.cost || 0
+            });
+        }
+        if (functionCallResult.did_transfer) {
+            if (verbose)
+                console.log("✅ Agent transfer response:", functionCallResult.source_agent, '::to', functionCallResult.destination_agent, '::with', functionCallResult.content, ' 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, context)) || '';
+            // ✅ Set préserve le trail existant via updateSystemMessage()
+            stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
+            stateGraph.push(discussionRootAgent, {
+                role: "assistant",
+                content: functionCallResult.content,
+                name: functionCallResult.name
+            });
+        }
+        else {
+            // other function call have a result
+            stateGraph.push(discussionRootAgent, {
+                role: "assistant",
+                content: functionCallResult.content,
+                name: functionCallResult.name
+            });
+        }
+        //
+        // send user feedback (if not already sent via addStep for transfer)
+        if (functionCallResult.feedback && !functionCallResult.did_transfer) {
+            (0, shared_1.sendFeedback)({
+                agent: agentConfig.name,
+                stdout,
+                description: functionCallResult.feedback,
+                usage: discussion.usage,
+                state: '',
+                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({}, (0, modelconfig_1.modelConfig)(currentAgent.model));
+        followUpOptions.messages = discussion.messages;
+        if (tools.length > 0) {
+            followUpOptions.tools = tools;
+            followUpOptions.tool_choice = "auto";
+        }
+        //
+        // Legacy: utiliser beta.chat.completions.stream (ancienne API)
+        // NOTE: Cette API est en beta, Responses API est recommandée pour les nouveaux projets
+        const followUpStream = await openai.beta.chat.completions.stream(followUpOptions);
+        for await (const chunk of followUpStream) {
+            const delta = chunk.choices[0]?.delta;
+            if (delta?.content) {
+                stdout.write(delta?.content);
+            }
+        }
+        const followUpFinal = await followUpStream.finalChatCompletion();
+        //
+        // ✅ addStep APRÈS la réponse de l'agent (pour avoir le trail complet au prochain tour)
+        if (functionCallResult.name) {
+            stateGraph.addStep(discussionRootAgent, {
+                tool: functionCallResult.name,
+                context: functionCallResult.context || '',
+                reason: args.justification || '',
+                id: functionCallResult.id
+            });
+        }
+        //
+        // when called a function, agent must continue the conversation
+        if (followUpFinal.choices[0]?.message.tool_calls) {
+            const partial = await readCompletionsStream({
+                stateGraph,
+                discussion,
+                agentConfig: currentAgent,
+                agents,
+                discussionRootAgent,
+                stdout,
+                final: followUpFinal,
+                context,
+                verbose,
+                enrichWithMemory: params.enrichWithMemory
+            });
+            localResult = (0, types_1.executionResultMerge)(localResult, partial);
+            // ✅ OPTIM: Utiliser helper centralisé
+            localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
+            return localResult;
+        }
+        //
+        // OPTIM: Utiliser helper centralisé pour l'accumulation
+        (0, helpers_1.accumulateUsageTokens)(stateGraph, discussion, discussionRootAgent, model, followUpFinal.usage);
+        //
+        // send the cost
+        (0, shared_1.sendFeedback)({
+            agent: currentAgent.name,
+            stdout,
+            description: '',
+            usage: discussion.usage,
+            state: followUpFinal.id || '',
+            verbose
+        });
+        const followUpContent = followUpFinal.choices[0]?.message.content;
+        //
+        // capture new memory with the last message
+        await params.enrichWithMemory?.("assistant", currentAgent, context);
+        if (followUpContent) {
+            stateGraph.push(discussionRootAgent, { role: "assistant", content: followUpContent });
+        }
+    }
+    //
+    // ✅ OPTIM: Utiliser helper centralisé
+    localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
+    return localResult;
+}
+/**
+ * Executes a set of agents to process a user query
+ *
+ * OPTIMIZED: Sans boucle do...while(moreThinkin), reasoning_effort fait le job
+ */
+async function executeAgentSet(agentSet, context, params) {
+    const { query, verbose } = params;
+    const openai = (0, utils_1.openaiInstance)();
+    const agents = (0, utils_1.injectTransferTools)(agentSet);
+    // 🔑 CLÉ DE DISCUSSION: Agent racine qui sert de point d'entrée
+    const discussionRootAgent = params.home || agents[0].name;
+    // 🎯 Récupération du StateGraph depuis le context
+    const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
+    // 📍 Créer ou restaurer la discussion pour cet agent racine
+    const discussion = stateGraph.createOrRestore(discussionRootAgent);
+    // 🔄 Agent courant: peut différer de l'agent racine après des transferts
+    let currentAgent = (0, stategraph_1.getSpecializedAgent)(discussion) || discussionRootAgent;
+    // 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 };
+        const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
+        const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
+        stateGraph.set(discussionRootAgent, instructions);
+    }
+    else {
+        enrichedQuery = (await params.enrichWithMemory?.("user", currentAgentConfig, context)) || query;
+    }
+    stateGraph.push(discussionRootAgent, { role: "user", content: enrichedQuery });
+    const tools = currentAgentConfig.tools;
+    if (verbose) {
+        console.log('--- DBG current agent', currentAgentConfig.name, `deep-thinking:${params.thinking}`, 'memory len:', discussion.messages.length);
+    }
+    let result = (0, types_1.enrichExecutionResult)({
+        runId: `${discussionRootAgent}-${Date.now()}`,
+        startQuery: query,
+        actions: [],
+        lastMessage: '',
+        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+    });
+    //
+    // ✅ BUG FIX: Plus de boucle do...while(moreThinkin) - reasoning_effort fait le job
+    const intialinfo = ["Analyse", "Analyse en cours…", "Réflexion"];
+    const randomIndex = Math.floor(Math.random() * intialinfo.length);
+    (0, shared_1.sendFeedback)({
+        agent: currentAgentConfig.name,
+        stdout: params.stdout,
+        description: intialinfo[randomIndex],
+        usage: result.usage,
+        state: discussion.id
+    });
+    //
+    // ✅ BUG FIX: modelConfig gère reasoning_effort, pas de duplication (ligne 425 originale supprimée)
+    const model = (0, modelconfig_1.modelConfig)(currentAgentConfig.model, { thinking: params.thinking });
+    const options = Object.assign({}, model);
+    options.messages = discussion.messages;
+    if (tools.length > 0) {
+        options.tools = tools;
+        options.tool_choice = "auto";
+        options.parallel_tool_calls = true;
+    }
+    const stream = await openai.beta.chat.completions.stream(options);
+    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,
+        discussionRootAgent,
+        stdout: params.stdout,
+        context,
+        final,
+        verbose,
+        enrichWithMemory: params.enrichWithMemory,
+    });
+    result = (0, types_1.executionResultMerge)(result, partial);
+    //
+    // ✅ OPTIM: Utiliser helper centralisé
+    result.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
+    // 💾 Auto-save du StateGraph à la fin
+    (0, stategraph_1.sessionStateGraphSet)(context, stateGraph);
+    // finalize result
+    result.lastMessage = discussion.messages?.[discussion.messages.length - 1]?.content || '';
+    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, debug } = 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`);
+    }
+    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;
+    let iterations = 0;
+    if (verbose) {
+        console.log('--- DBG executeAgent:', agent.name);
+        console.log('--- DBG query:', `${query?.substring(0, 100)}...`);
+    }
+    if (debug) {
+        console.log('--- DBG executeAgent-system:', agent.instructions);
+        console.log('--- DBG executeAgent-user:', query);
+    }
+    while (iterations < maxIterations) {
+        iterations++;
+        const options = Object.assign({}, (0, modelconfig_1.modelConfig)(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:', agent.name, 'iterations:', iterations, '\n', messages.length, '\n---', messages[messages.length - 1]?.content);
+        }
+        const stream = await openai.beta.chat.completions.stream(options);
+        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 model = (0, modelconfig_1.modelConfig)(agent.model).model;
+        (0, pricing_llm_1.accumulateCost)(usage, model, final.usage);
+        state = final.id;
+        const content = final.choices[0]?.message.content;
+        if (content) {
+            messages.push({ role: "assistant", content });
+        }
+        const toolCalls = final.choices[0]?.message.tool_calls;
+        let hasToolCalls = false;
+        if (toolCalls && toolCalls.length > 0) {
+            hasToolCalls = true;
+            const lastAssistant = messages[messages.length - 1];
+            if (lastAssistant && lastAssistant.role === 'assistant') {
+                lastAssistant.tool_calls = toolCalls;
+            }
+            else {
+                messages.push({
+                    role: "assistant",
+                    content: content || null,
+                    tool_calls: toolCalls
+                });
+            }
+            for (const toolCall of toolCalls) {
+                const args = JSON.parse(toolCall.function.arguments || '{}');
+                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 (!hasToolCalls) {
+            break;
+        }
+    }
+    return {
+        usage,
+        content: messages[messages.length - 1]?.content || '',
+        messages,
+        state
+    };
+}
+/**
+ * Executes a simple query without agent orchestration or tool handling
+ */
+async function executeQuery(params) {
+    const { query, verbose, model: modelName, instructions } = params;
+    if (!modelName) {
+        throw new Error('executeQuery requires "model" parameter');
+    }
+    const openai = (0, utils_1.openaiInstance)();
+    const model = (0, modelconfig_1.modelConfig)(modelName);
+    const more = {};
+    if (params.json) {
+        more.response_format = { type: "json_object" };
+    }
+    if (params.schema) {
+        more.response_format = { type: "json_object", schema: params.schema };
+    }
+    if (verbose) {
+        console.log('--- DBG query:', modelName, `${query?.substring(0, 100)}...`);
+    }
+    const messages = params.messages || [];
+    // Ajouter le système prompt si fourni
+    if (instructions) {
+        messages.unshift({ role: "system", content: instructions });
+    }
+    messages.push({ role: "user", content: query });
+    let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+    let state = '';
+    try {
+        const options = Object.assign({}, model, more);
+        options.messages = messages;
+        if (verbose) {
+            console.log('--- DBG executeQuery options:', JSON.stringify(options, null, 2));
+        }
+        const stream = await openai.beta.chat.completions.stream(options);
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (delta?.content && params.stdout) {
+                params.stdout.write(delta?.content);
+            }
+        }
+        const final = await stream.finalChatCompletion();
+        (0, pricing_llm_1.accumulateCost)(usage, model.model, final.usage);
+        state = final.id || '';
+        const content = final.choices[0]?.message.content || '';
+        if (verbose) {
+            console.log('--- DBG executeQuery completed, usage:', usage);
+        }
+        return {
+            usage,
+            content,
+            messages: [
+                ...messages,
+                { role: "assistant", content }
+            ],
+            state
+        };
+    }
+    catch (error) {
+        console.error('❌ executeQuery failed:', error);
+        throw error;
+    }
+}

package/dist/src/execute/modelconfig.d.ts

@@ -0,0 +1,19 @@
+import { AgentModel } from '../types';
+/**
+ * Configuration des modèles pour Chat Completions (legacy) et Responses API
+ *
+ * Gère la configuration des modèles avec migration automatique des paramètres
+ * selon le provider (OpenAI, xAI) et l'API utilisée (legacy ou Responses)
+ *
+ * @param model - Alias du modèle (LOW-fast, MEDIUM-fast, HIGH-fast, HIGH-medium, etc.)
+ * @param custom - Options custom
+ * @param custom.thinking - Si true, active reasoning_effort élevé (via LLM mapping)
+ * @param forResponses - Si true, retourne format Responses API avec mappings:
+ *   - reasoning_effort → reasoning: { effort }
+ *   - verbosity → text.verbosity
+ * @returns Configuration du modèle
+ *
+ * NOTE: Pour GPT-5, temperature est toujours fixée à 1
+ * NOTE: reasoning_effort est géré automatiquement par LLM() selon le provider
+ */
+export declare function modelConfig(model: string, custom?: any, forResponses?: boolean): AgentModel;

package/dist/src/execute/modelconfig.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelConfig = modelConfig;
+const utils_1 = require("../utils");
+const pricing_llm_1 = require("../pricing.llm");
+/**
+ * Configuration des modèles pour Chat Completions (legacy) et Responses API
+ *
+ * Gère la configuration des modèles avec migration automatique des paramètres
+ * selon le provider (OpenAI, xAI) et l'API utilisée (legacy ou Responses)
+ *
+ * @param model - Alias du modèle (LOW-fast, MEDIUM-fast, HIGH-fast, HIGH-medium, etc.)
+ * @param custom - Options custom
+ * @param custom.thinking - Si true, active reasoning_effort élevé (via LLM mapping)
+ * @param forResponses - Si true, retourne format Responses API avec mappings:
+ *   - reasoning_effort → reasoning: { effort }
+ *   - verbosity → text.verbosity
+ * @returns Configuration du modèle
+ *
+ * NOTE: Pour GPT-5, temperature est toujours fixée à 1
+ * NOTE: reasoning_effort est géré automatiquement par LLM() selon le provider
+ */
+function modelConfig(model, custom, forResponses = false) {
+    const thinking = custom?.thinking || false;
+    delete custom?.thinking;
+    const defaultOptions = Object.assign({
+        stream_options: { "include_usage": true },
+    }, custom || {});
+    //
+    // Get mapping based on provider (OpenAI vs xAI)
+    // LLM() applique automatiquement reasoning_effort si thinking=true
+    const mapping = (0, pricing_llm_1.LLM)((0, utils_1.openaiInstance)(), thinking);
+    const options = Object.assign({}, mapping[model], defaultOptions);
+    //
+    // Pour Responses API : mapper vers la nouvelle structure et filtrer les paramètres incompatibles
+    // Chat Completions utilise reasoning_effort (string) et verbosity (string)
+    // Responses API utilise reasoning: { effort: string } et text.verbosity (string)
+    if (forResponses) {
+        // Mapper reasoning_effort → reasoning: { effort }
+        if (options.reasoning_effort) {
+            options.reasoning = { effort: options.reasoning_effort };
+            delete options.reasoning_effort;
+        }
+        // Mapper verbosity → text.verbosity
+        if (options.verbosity) {
+            options.text = { verbosity: options.verbosity };
+            delete options.verbosity;
+        }
+        // Supprimer les paramètres non supportés par Responses API
+        const unsupportedParams = ['frequency_penalty', 'presence_penalty', 'stream_options', 'web_search_options'];
+        unsupportedParams.forEach(param => {
+            delete options[param];
+        });
+    }
+    return options;
+}

package/dist/src/execute/responses.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Responses API Implementation
+ *
+ * Migration de Chat Completions vers Responses API pour:
+ * - Meilleur support des modèles reasoning (o-series, gpt-5)
+ * - Tool calls préservés pendant le raisonnement via reasoning: { effort }
+ * - Events SSE typés (response.output_text.delta, response.function_call.*)
+ * - Plus de boucle moreThinkin (obsolète) : reasoning géré nativement
+ *
+ * Différences clés vs legacy:
+ * - `input` remplace `messages` (même format array, juste renommage du paramètre)
+ * - `reasoning: { effort: 'low' | 'medium' | 'high' }` remplace `reasoning_effort`
+ * - Events SSE structurés vs delta progressifs
+ * - `response.usage` vs `final.usage`
+ * - Tools/function calling: format identique, `parallel_tool_calls` supporté
+ *
+ * Optimisations appliquées (vs code original):
+ * - OPTIM: Helpers centralisés (accumulateUsageTokens, stepsToActions)
+ * - BUG FIX: executionResultMerge fusionne actions correctement (corrigé dans types.ts)
+ * - BUG FIX: moreThinkin supprimé (obsolète)
+ * - BUG FIX: reasoning_effort géré par modelConfig uniquement
+ *
+ * TODO [Phase 2]: Migration vers openai-agents-js
+ * https://openai.github.io/openai-agents-js/
+ * - Remplacer handleTransferCall par handoff natif du SDK
+ * - Utiliser swarm.run() pour orchestration multi-agents
+ * - Mapper downstreamAgents vers router policies
+ * - Intégration optionnelle avec Vercel AI SDK (multi-providers)
+ * - stateGraph restera compatible (AgentMessage générique, agnostic de l'API)
+ */
+import { AgentConfig, AgenticContext, ExecuteAgentResult, ExecutionResult } from "../types";
+import { ReadCompletionsStreamOptions, ExecuteAgentSetParams } from "./shared";
+/**
+ * RESPONSES API: Traite le stream de responses avec tool calls
+ *
+ * Utilise les events SSE typés de Responses API:
+ * - response.output_text.delta → texte
+ * - response.function_call.* → tool calls
+ * - response.completed → finalisation
+ */
+export declare function readCompletionsStream(params: ReadCompletionsStreamOptions): Promise<ExecutionResult>;
+/**
+ * Executes a set of agents to process a user query
+ *
+ * RESPONSES API VERSION
+ */
+export declare function executeAgentSet(agentSet: AgentConfig[], context: AgenticContext, params: ExecuteAgentSetParams): Promise<ExecutionResult>;
+/**
+ * Execute agent - Responses API version
+ */
+export declare function executeAgent(agentSet: AgentConfig[], params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;
+/**
+ * Execute query - Responses API version
+ */
+export declare function executeQuery(params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;