agentic-api 2.0.491 → 2.0.592

package/dist/src/agents/reducer.core.js

@@ -5,13 +5,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapLLM = void 0;
 const execute_1 = require("../execute");
-const utils_1 = require("../utils");
 /**
  * MapLLM - Orchestrateur principal pour le reduce hiérarchique
  */
 class MapLLM {
-    constructor(loader) {
+    constructor(loader, options) {
         this.loader = loader;
+        // Default options
+        this.options = {
+            finalReduce: options?.finalReduce ?? true,
+            reduceThresholdBytes: options?.reduceThresholdBytes ?? 0
+        };
         //
         // ✅ Si pas d'agentConfig fourni, essayer d'extraire depuis le loader
         if (this.hasAgents(loader)) {
@@ -53,11 +57,7 @@ class MapLLM {
         let position = 0;
         let totalChunkSize = 0;
         let totalReduce = 0;
-        const model = (0, execute_1.modelConfig)(result.model);
-        const openai = (0, utils_1.openaiInstance)();
-        const llm = Object.assign({}, model);
-        llm.stream = false;
-        delete llm.stream_options;
+        const modelName = result.model || 'LOW-fast';
         //
         // maxIterations is set by the callback
         while (!result.maxIterations) {
@@ -118,35 +118,23 @@ class MapLLM {
                 }
                 else {
                     //
-                    // ══════════════════════════════════════
-                    // MODE DOCUMENT : openai.chat direct
-                    // ══════════════════════════════════════
-                    const messages = isFirstChunk ? [
-                        { role: "system", content: config.digestPrompt },
-                        { role: "user", content: chunk.content }
-                    ] : [
-                        { role: "system", content: config.digestPrompt },
-                        { role: "assistant", content: accContent },
-                        { role: "user", content: chunk.content }
+                    // ══════════════════════════════════════════════════════════
+                    // MODE DOCUMENT : executeQuery() avec API Responses unifiée
+                    // ══════════════════════════════════════════════════════════
+                    const messages = isFirstChunk ? [] : [
+                        { role: "assistant", content: accContent }
                     ];
-                    llm.messages = messages;
-                    //
-                    // Configure structured output if format is specified
-                    if (result.format) {
-                        llm.response_format = {
-                            type: "json_schema",
-                            json_schema: {
-                                name: result.format.name,
-                                schema: result.format.schema,
-                                strict: result.format.strict ?? true
-                            }
-                        };
-                    }
-                    const chat = await openai.chat.completions.create(llm);
-                    const digestMessage = chat.choices[0]?.message;
-                    //
-                    // Parse JSON if structured output is enabled
-                    digestContent = digestMessage.content || '';
+                    const execResult = await (0, execute_1.executeQuery)({
+                        query: chunk.content,
+                        model: modelName,
+                        instructions: config.digestPrompt,
+                        messages,
+                        schema: result.format ? result.format.schema : undefined,
+                        verbose: verbose,
+                        stdout: init.stdout || execute_1.DummyWritable
+                    });
+                    // executeQuery returns content - parse if structured output is enabled
+                    digestContent = execResult.content;
                     if (result.format && digestContent) {
                         try {
                             digestContent = JSON.parse(digestContent);
@@ -169,31 +157,31 @@ class MapLLM {
                     }
                     break;
                 }
-                // Décision de réduction basée sur callback
-                if (!result.continue) {
+                // Auto-reduce if accumulator exceeds threshold (if configured)
+                const accSize = typeof result.acc === 'string' ? result.acc.length : JSON.stringify(result.acc).length;
+                const shouldAutoReduce = this.options.reduceThresholdBytes > 0 && accSize > this.options.reduceThresholdBytes;
+                // Décision de réduction basée sur callback ou auto-threshold
+                if (!result.continue && !shouldAutoReduce) {
                     continue;
                 }
-                const accForReduce = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
-                llm.messages = [
-                    { role: "system", content: config.reducePrompt },
-                    { role: "user", content: accForReduce }
-                ];
-                // Configure structured output if format is specified
-                if (result.format) {
-                    llm.response_format = {
-                        type: "json_schema",
-                        json_schema: {
-                            name: result.format.name,
-                            schema: result.format.schema,
-                            strict: result.format.strict ?? true
-                        }
-                    };
+                if (verbose && shouldAutoReduce) {
+                    console.log(`🔄 Auto-reduce triggered: acc size ${accSize} > threshold ${this.options.reduceThresholdBytes}`);
                 }
-                const reduce = await openai.chat.completions.create(llm);
-                const reduceMessage = reduce.choices[0]?.message;
+                const accForReduce = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
+                //
+                // Intermediate reduce avec executeQuery
+                const reduceResult = await (0, execute_1.executeQuery)({
+                    query: accForReduce,
+                    model: modelName,
+                    instructions: config.reducePrompt,
+                    messages: [],
+                    schema: result.format ? result.format.schema : undefined,
+                    verbose: verbose,
+                    stdout: init.stdout || execute_1.DummyWritable
+                });
                 //
                 // should not happen
-                if (!reduceMessage.content) {
+                if (!reduceResult.content) {
                     continue;
                 }
                 // 3. Reduce with system - Update result.acc (replace)
@@ -201,15 +189,15 @@ class MapLLM {
                 // Parse JSON if structured output is enabled
                 if (result.format) {
                     try {
-                        result.acc = JSON.parse(reduceMessage.content);
+                        result.acc = JSON.parse(reduceResult.content);
                     }
                     catch (e) {
-                        console.warn('Failed to parse reduce result as JSON:', reduceMessage.content);
-                        result.acc = reduceMessage.content;
+                        console.warn('Failed to parse reduce result as JSON:', reduceResult.content);
+                        result.acc = reduceResult.content;
                     }
                 }
                 else {
-                    result.acc = reduceMessage.content;
+                    result.acc = reduceResult.content;
                 }
                 if (verbose) {
                     console.log(`✅ Reduce ${result.metadata?.iterations} processed (${chunk.content.length} chars)`);
@@ -224,38 +212,40 @@ class MapLLM {
                 throw new Error(`Failed to process chunk ${result.metadata?.iterations}: ${error}`);
             }
         }
-        // Final reduce
-        const finalAccContent = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
-        const messages = [
-            { role: "system", content: config.reducePrompt },
-            { role: "user", content: finalAccContent }
-        ];
-        llm.messages = messages;
-        // Configure structured output if format is specified
-        if (result.format) {
-            llm.response_format = {
-                type: "json_schema",
-                json_schema: {
-                    name: result.format.name,
-                    schema: result.format.schema,
-                    strict: result.format.strict ?? true
+        // Final reduce (optional, controlled by options.finalReduce)
+        if (this.options.finalReduce) {
+            const finalAccContent = typeof result.acc === 'string' ? result.acc : JSON.stringify(result.acc);
+            //
+            // Final reduce avec executeQuery
+            const finalResult = await (0, execute_1.executeQuery)({
+                query: finalAccContent,
+                model: modelName,
+                instructions: config.reducePrompt,
+                messages: [],
+                schema: result.format ? result.format.schema : undefined,
+                verbose: verbose,
+                stdout: init.stdout || execute_1.DummyWritable
+            });
+            const finalContent = finalResult.content || '';
+            // Parse JSON if structured output is enabled
+            if (result.format && finalContent) {
+                try {
+                    result.acc = JSON.parse(finalContent);
+                }
+                catch (e) {
+                    console.warn('Failed to parse final result as JSON:', finalContent);
+                    result.acc = finalContent;
                 }
-            };
-        }
-        const reduce = await openai.chat.completions.create(llm);
-        const finalContent = reduce.choices[0]?.message.content || '';
-        // Parse JSON if structured output is enabled
-        if (result.format && finalContent) {
-            try {
-                result.acc = JSON.parse(finalContent);
             }
-            catch (e) {
-                console.warn('Failed to parse final result as JSON:', finalContent);
+            else {
                 result.acc = finalContent;
             }
+            if (verbose) {
+                console.log('🎯 Final reduce completed');
+            }
         }
-        else {
-            result.acc = finalContent;
+        else if (verbose) {
+            console.log('⏭️ Final reduce skipped (finalReduce=false)');
         }
         const endTime = Date.now();
         const processingTimeMs = endTime - startTime;

package/dist/src/agents/reducer.d.ts

@@ -1,3 +1,4 @@
 export * from './reducer.core';
 export * from './reducer.loaders';
 export * from './reducer.types';
+export * from './reducer.factory';

package/dist/src/agents/reducer.factory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Factory to create a ReducerFn compatible with JobRunner using MapLLM
+ */
+import type { StructuredOutputFormat } from './reducer.types';
+import type { ReducerFn } from './job.runner';
+/**
+ * Options for createMapLLMReducer factory
+ */
+export interface CreateMapLLMReducerOptions {
+    /** Prompt for digesting task + result into facts */
+    digestPrompt: string;
+    /** Prompt for reducing/fusing with previous memory */
+    reducePrompt: string;
+    /** Custom JSON schema for ReducedJobMemory (optional, uses default if not provided) */
+    format?: StructuredOutputFormat;
+    /** Model to use (default: 'LOW') */
+    model?: string;
+    /** Whether to execute final reduce pass (default: true) */
+    finalReduce?: boolean;
+    /** Threshold in bytes to trigger auto intermediate reduce (optional) */
+    reduceThresholdBytes?: number;
+    /** Enable verbose logging (default: false) */
+    verbose?: boolean;
+}
+/**
+ * Creates a ReducerFn compatible with JobRunner that uses MapLLM internally.
+ *
+ * This factory bridges JobRunner and MapLLM, allowing LLM-powered reduction
+ * with structured outputs while keeping both modules independent.
+ *
+ * @example
+ * ```typescript
+ * const reducer = createMapLLMReducer({
+ *   digestPrompt: "Analyze this task result and extract key facts...",
+ *   reducePrompt: "Merge with previous memory to produce updated canonical memory...",
+ *   model: 'LOW'
+ * });
+ *
+ * const runner = new JobRunner({
+ *   planner: myPlanner,
+ *   executor: myExecutor,
+ *   reducer: reducer  // ← ReducerFn compatible
+ * });
+ * ```
+ */
+export declare function createMapLLMReducer(options: CreateMapLLMReducerOptions): ReducerFn;

package/dist/src/agents/reducer.factory.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Factory to create a ReducerFn compatible with JobRunner using MapLLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMapLLMReducer = createMapLLMReducer;
+const reducer_core_1 = require("./reducer.core");
+const reducer_loaders_1 = require("./reducer.loaders");
+/**
+ * Default JSON schema for ReducedJobMemory
+ * Note: For strict mode, all properties must be in required array and
+ * all nested objects need additionalProperties: false
+ */
+const DEFAULT_MEMORY_SCHEMA = {
+    name: 'ReducedJobMemory',
+    schema: {
+        type: 'object',
+        properties: {
+            memory: {
+                type: 'string',
+                description: 'Short canonical memory summarizing progress and key facts'
+            },
+            index: {
+                type: 'object',
+                description: 'Stable references: artifact IDs, data tables, error traces',
+                properties: {
+                    artifacts: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of artifact references'
+                    },
+                    taskIds: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of completed task IDs'
+                    },
+                    errors: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of error messages'
+                    }
+                },
+                required: ['artifacts', 'taskIds', 'errors'],
+                additionalProperties: false
+            },
+            statusLine: {
+                type: 'string',
+                description: 'UI progress line'
+            }
+        },
+        required: ['memory', 'index', 'statusLine'],
+        additionalProperties: false
+    },
+    strict: true
+};
+/**
+ * Creates a ReducerFn compatible with JobRunner that uses MapLLM internally.
+ *
+ * This factory bridges JobRunner and MapLLM, allowing LLM-powered reduction
+ * with structured outputs while keeping both modules independent.
+ *
+ * @example
+ * ```typescript
+ * const reducer = createMapLLMReducer({
+ *   digestPrompt: "Analyze this task result and extract key facts...",
+ *   reducePrompt: "Merge with previous memory to produce updated canonical memory...",
+ *   model: 'LOW'
+ * });
+ *
+ * const runner = new JobRunner({
+ *   planner: myPlanner,
+ *   executor: myExecutor,
+ *   reducer: reducer  // ← ReducerFn compatible
+ * });
+ * ```
+ */
+function createMapLLMReducer(options) {
+    const { digestPrompt, reducePrompt, format = DEFAULT_MEMORY_SCHEMA, model = 'LOW', finalReduce = true, reduceThresholdBytes, verbose = false } = options;
+    return async (previous, task, result) => {
+        // Serialize context for reduction
+        const context = JSON.stringify({
+            previousMemory: previous,
+            task: {
+                id: task.id,
+                title: task.title,
+                type: task.type
+            },
+            result: {
+                taskId: result.taskId,
+                ok: result.ok,
+                summary: result.summary,
+                error: result.error,
+                artifacts: result.artifacts,
+                // Include data if small enough, otherwise just note its presence
+                data: result.data && JSON.stringify(result.data).length < 2000
+                    ? result.data
+                    : (result.data ? '[data truncated]' : undefined)
+            }
+        }, null, 2);
+        // Create loader with single-chunk strategy (the context is already compact)
+        const loader = new reducer_loaders_1.StringNativeLoader(context, { type: 'paragraphs', size: 10 });
+        // Create MapLLM with options
+        const mapllmOptions = {
+            finalReduce,
+            reduceThresholdBytes
+        };
+        const mapper = new reducer_core_1.MapLLM(loader, mapllmOptions);
+        // Config for MapLLM
+        const config = {
+            digestPrompt,
+            reducePrompt
+        };
+        // Callback: accumulate structured output
+        const callback = (res, current) => {
+            // If current is already an object (structured output), use it directly
+            if (typeof current === 'object' && current !== null) {
+                res.acc = current;
+            }
+            else if (typeof current === 'string') {
+                // Try to parse as JSON
+                try {
+                    res.acc = JSON.parse(current);
+                }
+                catch {
+                    // Fallback: wrap in memory field
+                    res.acc = {
+                        memory: current,
+                        index: res.acc?.index || {}
+                    };
+                }
+            }
+            return res;
+        };
+        // Init with previous memory or empty
+        const init = {
+            acc: previous || { memory: '', index: {} },
+            config,
+            format,
+            model,
+            verbose
+        };
+        // Execute MapLLM reduce
+        const out = await mapper.reduce(callback, init);
+        // Validate and return
+        const result_acc = out.acc;
+        // Ensure required fields exist
+        const reducedMemory = {
+            memory: typeof result_acc.memory === 'string' ? result_acc.memory : JSON.stringify(result_acc.memory || ''),
+            index: typeof result_acc.index === 'object' ? result_acc.index : {},
+            statusLine: result_acc.statusLine
+        };
+        return reducedMemory;
+    };
+}

package/dist/src/agents/reducer.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./reducer.core"), exports);
 __exportStar(require("./reducer.loaders"), exports);
 __exportStar(require("./reducer.types"), exports);
+__exportStar(require("./reducer.factory"), exports);

package/dist/src/agents/simulator.d.ts

@@ -1,10 +1,35 @@
-import { SimulatorConfig, SimulationOptions, SimulationResult } from './simulator.types';
+import { SimulatorConfig, SimulationOptions, SimulationResult, TestScenario, TestCaseInput } from './simulator.types';
 export declare class AgentSimulator {
     private config;
     private executor;
     private lastExecution?;
     constructor(config: SimulatorConfig);
     /**
+     * Exécuter un cas de test avec scénario et paramètres séparés
+     *
+     * @param scenario - Contexte stable (goals, persona, result)
+     * @param testCase - Paramètres du test (query, maxExchanges, model, expectedTools)
+     * @returns SimulationResult
+     *
+     * @example
+     * ```typescript
+     * const scenario = {
+     *   goals: 'Obtenir le nombre secret 1942',
+     *   persona: PERSONA_PATIENT,
+     *   result: '{"success": boolean, "error": string}'
+     * };
+     *
+     * const result = await simulator.testCase(scenario, {
+     *   query: 'À quel nombre penses-tu?',
+     *   maxExchanges: 3,  // défaut: 1 (oneshot)
+     *   expectedTools: { 'transferAgents': { equal: 1 } }  // défaut: {}
+     * });
+     * ```
+     */
+    testCase(scenario: TestScenario, testCase: TestCaseInput): Promise<SimulationResult>;
+    /**
+     * @deprecated Utiliser testCase(scenario, case) à la place
+     *
      * Exécuter la simulation complète
      *
      * Architecture :

package/dist/src/agents/simulator.dashboard.d.ts

@@ -0,0 +1,140 @@
+import { TestScenario, TestCaseInput, SimulatorConfig } from './simulator.types';
+import { AgentMessage } from '../stategraph';
+/**
+ * Test case combining scenario and case input
+ * Format du fichier JSON d'entrée
+ */
+export interface DashboardTestCase {
+    id?: string;
+    name?: string;
+    scenario: TestScenario;
+    case: TestCaseInput;
+}
+/**
+ * Format du fichier JSON d'entrée
+ */
+export interface DashboardInput {
+    name?: string;
+    description?: string;
+    config?: Partial<SimulatorConfig>;
+    tests: DashboardTestCase[];
+}
+/**
+ * Status d'exécution d'un test
+ */
+export type TestStatus = 'pending' | 'running' | 'completed' | 'failed' | 'error';
+/**
+ * Ligne JSONL pour un résultat de test
+ */
+export interface DashboardOutputLine {
+    type: 'start' | 'result' | 'end' | 'error';
+    timestamp: string;
+    sessionId?: string;
+    totalTests?: number;
+    testId?: string;
+    testIndex?: number;
+    name?: string;
+    description?: string;
+    query?: string;
+    status?: TestStatus;
+    success?: boolean;
+    message?: string;
+    error?: string;
+    exchangeCount?: number;
+    messages?: AgentMessage[];
+    duration?: number;
+    summary?: {
+        total: number;
+        passed: number;
+        failed: number;
+        errors: number;
+        totalDuration: number;
+    };
+}
+/**
+ * Status de l'exécution pour le contrôleur backend
+ */
+export interface DashboardStatus {
+    isRunning: boolean;
+    sessionId: string | null;
+    currentTest: number;
+    totalTests: number;
+    passed: number;
+    failed: number;
+    errors: number;
+    startTime: Date | null;
+    lastUpdate: Date | null;
+}
+export declare class SimulatorDashboard {
+    private config;
+    private status;
+    private simulator;
+    private abortController;
+    private _currentOutputPath;
+    private _currentInputPath;
+    constructor(config: SimulatorConfig);
+    /**
+     * Chemin du fichier output actuel (ou du dernier run)
+     */
+    get currentOutputPath(): string | null;
+    /**
+     * Chemin du fichier input actuel (ou du dernier run)
+     */
+    get currentInputPath(): string | null;
+    private createInitialStatus;
+    /**
+     * Obtenir le status actuel (pour le contrôleur backend)
+     */
+    getStatus(): DashboardStatus;
+    /**
+     * Vérifier si une exécution est en cours
+     */
+    isRunning(): boolean;
+    /**
+     * Annuler l'exécution en cours
+     */
+    abort(): void;
+    /**
+     * Charger un fichier JSON d'entrée
+     */
+    loadInputFile(filePath: string): Promise<DashboardInput>;
+    /**
+     * Générer le chemin du fichier output basé sur le fichier input
+     * Exemple: tests/my-tests.json → tests/results.my-tests.jsonl
+     */
+    createOutputPath(inputPath: string): string;
+    /**
+     * Charger les résultats JSONL existants (en cours ou terminés)
+     * Supporte le streaming partiel (fichier en cours d'écriture)
+     *
+     * @param inputPath - Chemin du fichier JSON d'entrée (génère automatiquement le output path)
+     * @returns Les lignes parsées ou null si le fichier n'existe pas
+     */
+    loadResults(inputPath?: string): Promise<DashboardOutputLine[] | null>;
+    /**
+     * Obtenir le résumé des résultats (dernière ligne type='end')
+     * @param inputPath - Chemin du fichier JSON d'entrée
+     */
+    getResultsSummary(inputPath?: string): Promise<DashboardOutputLine['summary'] | null>;
+    /**
+     * Vérifier si les résultats sont complets (contient une ligne 'end')
+     * @param inputPath - Chemin du fichier JSON d'entrée
+     */
+    isResultsComplete(inputPath?: string): Promise<boolean>;
+    /**
+     * Exécuter les tests et écrire les résultats en JSONL
+     *
+     * @param input - Données d'entrée (ou chemin vers fichier JSON)
+     * @param outputPath - Chemin du fichier JSONL de sortie
+     * @param onLine - Callback optionnel pour chaque ligne JSONL (streaming)
+     */
+    run(input: DashboardInput | string, outputPath?: string, onLine?: (line: DashboardOutputLine) => void): Promise<DashboardOutputLine[]>;
+    /**
+     * Exécuter avec callback de streaming (pour SSE/WebSocket)
+     */
+    runWithStream(input: DashboardInput | string, onLine: (line: DashboardOutputLine) => void): Promise<DashboardOutputLine[]>;
+    /**
+     * Créer un fichier JSON d'exemple pour les tests
+     */
+    static createExampleInput(): DashboardInput;
+}