@backtest-kit/ollama 0.1.4 → 0.2.0

package/build/index.mjs

@@ -1,16 +1,19 @@
-import { json, event, validateToolArguments, RoundRobin, addCompletion, addOutline, validate, overrideOutline } from 'agent-swarm-kit';
+import { json, event, validateToolArguments, RoundRobin, addCompletion, addOutline, validate as validate$1, overrideOutline } from 'agent-swarm-kit';
 import { scoped } from 'di-scoped';
 import { createActivator } from 'di-kit';
+import { Markdown, getContext, getMode } from 'backtest-kit';
+import path, { join } from 'path';
 import MarkdownIt from 'markdown-it';
 import sanitizeHtml from 'sanitize-html';
 import { lint } from 'markdownlint/promise';
 import { applyFixes } from 'markdownlint';
-import { ToolRegistry, memoize, singleshot, randomString, fetchApi, str, timeout } from 'functools-kit';
+import { ToolRegistry, memoize, singleshot, Subject, trycatch, errorData, getErrorMessage, iterateDocuments, distinctDocuments, resolveDocuments, randomString, fetchApi, str, timeout } from 'functools-kit';
+import { createRequire } from 'module';
+import fs, { mkdir, writeFile } from 'fs/promises';
 import OpenAI from 'openai';
 import { AIMessage, SystemMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import { ChatXAI } from '@langchain/xai';
 import { jsonrepair } from 'jsonrepair';
-import fs from 'fs/promises';
 import { InferenceClient } from '@huggingface/inference';
 import { ChatOpenAI } from '@langchain/openai';
 import { get, set } from 'lodash-es';
@@ -251,6 +254,19 @@ const publicServices$1 = {
     /** Outline public service for simplified structured completions */
     outlinePublicService: Symbol('outlinePublicService'),
 };
+const promptServices$1 = {
+    signalPromptService: Symbol('signalPromptService'),
+};
+const markdownServices$1 = {
+    outlineMarkdownService: Symbol('outlineMarkdownService'),
+};
+const optimizerServices$1 = {
+    optimizerTemplateService: Symbol('optimizerTemplateService'),
+    optimizerSchemaService: Symbol('optimizerSchemaService'),
+    optimizerValidationService: Symbol('optimizerValidationService'),
+    optimizerConnectionService: Symbol('optimizerConnectionService'),
+    optimizerGlobalService: Symbol('optimizerGlobalService'),
+};
 /**
  * Service type identifier registry for dependency injection.
  *
@@ -269,10 +285,169 @@ const publicServices$1 = {
 const TYPES = {
     ...commonServices$1,
     ...baseServices$1,
+    ...promptServices$1,
+    ...markdownServices$1,
+    ...optimizerServices$1,
     ...privateServices$1,
     ...publicServices$1,
 };
 
+/**
+ * Warning threshold for message size in kilobytes.
+ * Messages exceeding this size trigger console warnings.
+ */
+const WARN_KB = 30;
+/**
+ * Internal function for dumping signal data to markdown files.
+ * Creates a directory structure with system prompts, user messages, and LLM output.
+ *
+ * @param signalId - Unique identifier for the result
+ * @param history - Array of message models from LLM conversation
+ * @param signal - Signal DTO with trade parameters
+ * @param outputDir - Output directory path (default: "./dump/strategy")
+ * @returns Promise that resolves when all files are written
+ */
+const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/outline") => {
+    // Extract system messages and system reminders from existing data
+    const systemMessages = history.filter((m) => m.role === "system");
+    const userMessages = history.filter((m) => m.role === "user");
+    const subfolderPath = path.join(outputDir, String(signalId));
+    // Generate system prompt markdown
+    {
+        let summary = "# Outline Result Summary\n";
+        {
+            summary += "\n";
+            summary += `**ResultId**: ${String(signalId)}\n`;
+            summary += "\n";
+        }
+        if (signal) {
+            summary += "## Output Data\n\n";
+            summary += "```json\n";
+            summary += JSON.stringify(signal, null, 2);
+            summary += "\n```\n\n";
+        }
+        // Add system messages to summary
+        if (systemMessages.length > 0) {
+            summary += "## System Messages\n\n";
+            systemMessages.forEach((msg, idx) => {
+                summary += `### System Message ${idx + 1}\n\n`;
+                summary += msg.content;
+                summary += "\n";
+            });
+        }
+        await Markdown.writeData("outline", summary, {
+            path: subfolderPath,
+            file: "00_system_prompt.md",
+            symbol: "",
+            signalId: String(signalId),
+            strategyName: "",
+            exchangeName: "",
+            frameName: ""
+        });
+    }
+    // Generate user messages
+    {
+        await Promise.all(Array.from(userMessages.entries()).map(async ([idx, message]) => {
+            const messageNum = String(idx + 1).padStart(2, "0");
+            const contentFileName = `${messageNum}_user_message.md`;
+            {
+                const messageSizeBytes = Buffer.byteLength(message.content, "utf8");
+                const messageSizeKb = Math.floor(messageSizeBytes / 1024);
+                if (messageSizeKb > WARN_KB) {
+                    console.warn(`User message ${idx + 1} is ${messageSizeBytes} bytes (${messageSizeKb}kb), which exceeds warning limit`);
+                }
+            }
+            let content = `# User Input ${idx + 1}\n\n`;
+            content += `**ResultId**: ${String(signalId)}\n\n`;
+            content += message.content;
+            content += "\n";
+            await Markdown.writeData("outline", content, {
+                path: subfolderPath,
+                file: contentFileName,
+                signalId: String(signalId),
+                symbol: "",
+                strategyName: "",
+                exchangeName: "",
+                frameName: ""
+            });
+        }));
+    }
+    // Generate LLM output
+    {
+        const messageNum = String(userMessages.length + 1).padStart(2, "0");
+        const contentFileName = `${messageNum}_llm_output.md`;
+        let content = "# Full Outline Result\n\n";
+        content += `**ResultId**: ${String(signalId)}\n\n`;
+        if (signal) {
+            content += "## Output Data\n\n";
+            content += "```json\n";
+            content += JSON.stringify(signal, null, 2);
+            content += "\n```\n";
+        }
+        await Markdown.writeData("outline", content, {
+            path: subfolderPath,
+            file: contentFileName,
+            symbol: "",
+            signalId: String(signalId),
+            strategyName: "",
+            exchangeName: "",
+            frameName: ""
+        });
+    }
+};
+/**
+ * Service for generating markdown documentation from LLM outline results.
+ * Used by AI Strategy Optimizer to save debug logs and conversation history.
+ *
+ * Creates directory structure:
+ * - ./dump/strategy/{signalId}/00_system_prompt.md - System messages and output data
+ * - ./dump/strategy/{signalId}/01_user_message.md - First user input
+ * - ./dump/strategy/{signalId}/02_user_message.md - Second user input
+ * - ./dump/strategy/{signalId}/XX_llm_output.md - Final LLM output
+ */
+class OutlineMarkdownService {
+    constructor() {
+        /** Logger service injected via DI */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Dumps signal data and conversation history to markdown files.
+         * Skips if directory already exists to avoid overwriting previous results.
+         *
+         * Generated files:
+         * - 00_system_prompt.md - System messages and output summary
+         * - XX_user_message.md - Each user message in separate file (numbered)
+         * - XX_llm_output.md - Final LLM output with signal data
+         *
+         * @param signalId - Unique identifier for the result (used as directory name)
+         * @param history - Array of message models from LLM conversation
+         * @param signal - Signal DTO with trade parameters (priceOpen, TP, SL, etc.)
+         * @param outputDir - Output directory path (default: "./dump/strategy")
+         * @returns Promise that resolves when all files are written
+         *
+         * @example
+         * ```typescript
+         * await outlineService.dumpSignal(
+         *   "strategy-1",
+         *   conversationHistory,
+         *   { position: "long", priceTakeProfit: 51000, priceStopLoss: 49000, minuteEstimatedTime: 60 }
+         * );
+         * // Creates: ./dump/strategy/strategy-1/00_system_prompt.md
+         * //          ./dump/strategy/strategy-1/01_user_message.md
+         * //          ./dump/strategy/strategy-1/02_llm_output.md
+         * ```
+         */
+        this.dumpSignal = async (signalId, history, signal, outputDir = "./dump/strategy") => {
+            this.loggerService.log("outlineMarkdownService dumpSignal", {
+                signalId,
+                history,
+                signal,
+                outputDir,
+            });
+            return await DUMP_SIGNAL_FN(signalId, history, signal, outputDir);
+        };
+    }
+}
+
 /**
  * Enumeration of supported JSON schema outlines.
  *
@@ -590,6 +765,111 @@ class RunnerPrivateService {
     }
 }
 
+const require = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when signal.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches signal prompt configuration.
+ * Attempts to load from config/prompt/signal.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN = singleshot(() => {
+    try {
+        const modulePath = require.resolve(path.join(process.cwd(), `./config/prompt/signal.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as signal.prompt.cjs`);
+        return require(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for signal.prompt.cjs`, error);
+        return DEFAULT_PROMPT;
+    }
+});
+/**
+ * Service for managing signal prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in signal.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/signal.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered signal analysis and strategy recommendations.
+ */
+class SignalPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("signalPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("signalPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
 /**
  * Public-facing service for structured AI outline completions.
  *
@@ -717,98 +997,1456 @@ class OutlinePublicService {
  * }, context);
  * ```
  */
-class RunnerPublicService {
+class RunnerPublicService {
+    constructor() {
+        /** Private service handling AI provider operations */
+        this.runnerPrivateService = inject(TYPES.runnerPrivateService);
+        /** Logger service for operation tracking */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Executes a standard AI completion within the specified context.
+         *
+         * @param params - Completion parameters including messages and options
+         * @param context - Execution context with inference provider, model, and API key
+         * @returns Promise resolving to AI response message
+         *
+         * @example
+         * ```typescript
+         * const result = await runnerPublicService.getCompletion({
+         *   messages: [
+         *     { role: "system", content: "You are a trading analyst" },
+         *     { role: "user", content: "Analyze BTC/USDT" }
+         *   ]
+         * }, {
+         *   inference: InferenceName.ClaudeInference,
+         *   model: "claude-3-5-sonnet-20240620",
+         *   apiKey: "sk-ant-..."
+         * });
+         * ```
+         */
+        this.getCompletion = async (params, context) => {
+            this.loggerService.log("runnerPublicService getCompletion");
+            return await ContextService.runInContext(async () => {
+                return await this.runnerPrivateService.getCompletion(params);
+            }, context);
+        };
+        /**
+         * Executes a streaming AI completion within the specified context.
+         *
+         * Similar to getCompletion but enables streaming mode where supported by the provider.
+         * The response is accumulated and returned as a complete message once streaming finishes.
+         *
+         * @param params - Completion parameters including messages and options
+         * @param context - Execution context with inference provider, model, and API key
+         * @returns Promise resolving to accumulated AI response message
+         *
+         * @example
+         * ```typescript
+         * const result = await runnerPublicService.getStreamCompletion({
+         *   messages: [
+         *     { role: "user", content: "Generate trading signal for ETH/USDT" }
+         *   ]
+         * }, {
+         *   inference: InferenceName.GPT5Inference,
+         *   model: "gpt-5o-mini",
+         *   apiKey: "sk-..."
+         * });
+         * ```
+         */
+        this.getStreamCompletion = async (params, context) => {
+            this.loggerService.log("runnerPublicService getStreamCompletion");
+            return await ContextService.runInContext(async () => {
+                return await this.runnerPrivateService.getStreamCompletion(params);
+            }, context);
+        };
+        /**
+         * Executes a structured outline completion within the specified context.
+         *
+         * Uses structured output (JSON schema validation) to ensure the AI response
+         * conforms to a predefined format. Ideal for extracting structured data
+         * from AI responses (e.g., trading signals with specific fields).
+         *
+         * @param params - Outline completion parameters including messages and schema
+         * @param context - Execution context with inference provider, model, and API key
+         * @returns Promise resolving to structured AI response
+         *
+         * @example
+         * ```typescript
+         * const signal = await runnerPublicService.getOutlineCompletion({
+         *   messages: [
+         *     { role: "user", content: "Decide position for BTC/USDT" }
+         *   ]
+         * }, {
+         *   inference: InferenceName.DeepseekInference,
+         *   model: "deepseek-chat",
+         *   apiKey: "sk-..."
+         * });
+         * // Returns: { position: "long", price_open: 50000, ... }
+         * ```
+         */
+        this.getOutlineCompletion = async (params, context) => {
+            this.loggerService.log("runnerPublicService getOutlineCompletion");
+            return await ContextService.runInContext(async () => {
+                return await this.runnerPrivateService.getOutlineCompletion(params);
+            }, context);
+        };
+    }
+}
+
+/**
+ * Default template service for generating optimizer code snippets.
+ * Implements all IOptimizerTemplate methods with Ollama LLM integration.
+ *
+ * Features:
+ * - Multi-timeframe analysis (1m, 5m, 15m, 1h)
+ * - JSON structured output for signals
+ * - Debug logging to ./dump/strategy
+ * - CCXT exchange integration
+ * - Walker-based strategy comparison
+ *
+ * Can be partially overridden in optimizer schema configuration.
+ */
+class OptimizerTemplateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Generates the top banner with imports and constants.
+         *
+         * @param symbol - Trading pair symbol
+         * @returns Shebang, imports, and WARN_KB constant
+         */
+        this.getTopBanner = async (symbol) => {
+            this.loggerService.log("optimizerTemplateService getTopBanner", {
+                symbol,
+            });
+            return [
+                "#!/usr/bin/env node",
+                "",
+                `import { Ollama } from "ollama";`,
+                `import ccxt from "ccxt";`,
+                `import {`,
+                `    addExchangeSchema,`,
+                `    addStrategySchema,`,
+                `    addFrameSchema,`,
+                `    addWalkerSchema,`,
+                `    Walker,`,
+                `    Backtest,`,
+                `    getCandles,`,
+                `    listenSignalBacktest,`,
+                `    listenWalkerComplete,`,
+                `    listenDoneBacktest,`,
+                `    listenBacktestProgress,`,
+                `    listenWalkerProgress,`,
+                `    listenError,`,
+                `    Markdown,`,
+                `} from "backtest-kit";`,
+                `import { promises as fs } from "fs";`,
+                `import { v4 as uuid } from "uuid";`,
+                `import path from "path";`,
+                ``,
+                `const WARN_KB = 100;`,
+                ``,
+                `Markdown.enable()`,
+            ].join("\n");
+        };
+        /**
+         * Generates default user message for LLM conversation.
+         * Simple prompt to read and acknowledge data.
+         *
+         * @param symbol - Trading pair symbol
+         * @param data - Fetched data array
+         * @param name - Source name
+         * @returns User message with JSON data
+         */
+        this.getUserMessage = async (symbol, data, name) => {
+            this.loggerService.log("optimizerTemplateService getUserMessage", {
+                symbol,
+                data,
+                name,
+            });
+            return ["Прочитай данные и скажи ОК", "", JSON.stringify(data)].join("\n");
+        };
+        /**
+         * Generates default assistant message for LLM conversation.
+         * Simple acknowledgment response.
+         *
+         * @param symbol - Trading pair symbol
+         * @param data - Fetched data array
+         * @param name - Source name
+         * @returns Assistant acknowledgment message
+         */
+        this.getAssistantMessage = async (symbol, data, name) => {
+            this.loggerService.log("optimizerTemplateService getAssistantMessage", {
+                symbol,
+                data,
+                name,
+            });
+            return "ОК";
+        };
+        /**
+         * Generates Walker configuration code.
+         * Compares multiple strategies on test frame.
+         *
+         * @param walkerName - Unique walker identifier
+         * @param exchangeName - Exchange to use for backtesting
+         * @param frameName - Test frame name
+         * @param strategies - Array of strategy names to compare
+         * @returns Generated addWalker() call
+         */
+        this.getWalkerTemplate = async (walkerName, exchangeName, frameName, strategies) => {
+            this.loggerService.log("optimizerTemplateService getWalkerTemplate", {
+                walkerName,
+                exchangeName,
+                frameName,
+                strategies,
+            });
+            // Escape special characters to prevent code injection
+            const escapedWalkerName = String(walkerName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedExchangeName = String(exchangeName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedFrameName = String(frameName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedStrategies = strategies.map((s) => String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"'));
+            return [
+                `addWalkerSchema({`,
+                `    walkerName: "${escapedWalkerName}",`,
+                `    exchangeName: "${escapedExchangeName}",`,
+                `    frameName: "${escapedFrameName}",`,
+                `    strategies: [${escapedStrategies.map((s) => `"${s}"`).join(", ")}],`,
+                `});`
+            ].join("\n");
+        };
+        /**
+         * Generates Strategy configuration with LLM integration.
+         * Includes multi-timeframe analysis and signal generation.
+         *
+         * @param strategyName - Unique strategy identifier
+         * @param interval - Signal throttling interval (e.g., "5m")
+         * @param prompt - Strategy logic from getPrompt()
+         * @returns Generated addStrategy() call with getSignal() function
+         */
+        this.getStrategyTemplate = async (strategyName, interval, prompt) => {
+            this.loggerService.log("optimizerTemplateService getStrategyTemplate", {
+                strategyName,
+                interval,
+                prompt,
+            });
+            // Convert prompt to plain text first
+            const plainPrompt = await toPlainString(prompt);
+            // Escape special characters to prevent code injection
+            const escapedStrategyName = String(strategyName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedInterval = String(interval)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedPrompt = String(plainPrompt)
+                .replace(/\\/g, '\\\\')
+                .replace(/`/g, '\\`')
+                .replace(/\$/g, '\\$');
+            return [
+                `addStrategySchema({`,
+                `    strategyName: "${escapedStrategyName}",`,
+                `    interval: "${escapedInterval}",`,
+                `    getSignal: async (symbol) => {`,
+                `        const messages = [];`,
+                ``,
+                `        // Загружаем данные всех таймфреймов`,
+                `        const microTermCandles = await getCandles(symbol, "1m", 30);`,
+                `        const mainTermCandles = await getCandles(symbol, "5m", 24);`,
+                `        const shortTermCandles = await getCandles(symbol, "15m", 24);`,
+                `        const mediumTermCandles = await getCandles(symbol, "1h", 24);`,
+                ``,
+                `        function formatCandles(candles, timeframe) {`,
+                `            return candles.map((c) =>`,
+                `                \`\${new Date(c.timestamp).toISOString()}[\${timeframe}]: O:\${c.open} H:\${c.high} L:\${c.low} C:\${c.close} V:\${c.volume}\``,
+                `            ).join("\\n");`,
+                `        }`,
+                ``,
+                `        // Сообщение 1: Среднесрочный тренд`,
+                `        messages.push(`,
+                `            {`,
+                `                role: "user",`,
+                `                content: [`,
+                `                    \`\${symbol}\`,`,
+                `                    "Проанализируй свечи 1h:",`,
+                `                    "",`,
+                `                    formatCandles(mediumTermCandles, "1h")`,
+                `                ].join("\\n"),`,
+                `            },`,
+                `            {`,
+                `                role: "assistant",`,
+                `                content: "Тренд 1h проанализирован",`,
+                `            }`,
+                `        );`,
+                ``,
+                `        // Сообщение 2: Краткосрочный тренд`,
+                `        messages.push(`,
+                `            {`,
+                `                role: "user",`,
+                `                content: [`,
+                `                    "Проанализируй свечи 15m:",`,
+                `                    "",`,
+                `                    formatCandles(shortTermCandles, "15m")`,
+                `                ].join("\\n"),`,
+                `            },`,
+                `            {`,
+                `                role: "assistant",`,
+                `                content: "Тренд 15m проанализирован",`,
+                `            }`,
+                `        );`,
+                ``,
+                `        // Сообщение 3: Основной таймфрейм`,
+                `        messages.push(`,
+                `            {`,
+                `                role: "user",`,
+                `                content: [`,
+                `                    "Проанализируй свечи 5m:",`,
+                `                    "",`,
+                `                    formatCandles(mainTermCandles, "5m")`,
+                `                ].join("\\n")`,
+                `            },`,
+                `            {`,
+                `                role: "assistant",`,
+                `                content: "Таймфрейм 5m проанализирован",`,
+                `            }`,
+                `        );`,
+                ``,
+                `        // Сообщение 4: Микро-структура`,
+                `        messages.push(`,
+                `            {`,
+                `                role: "user",`,
+                `                content: [`,
+                `                    "Проанализируй свечи 1m:",`,
+                `                    "",`,
+                `                    formatCandles(microTermCandles, "1m")`,
+                `                ].join("\\n")`,
+                `            },`,
+                `            {`,
+                `                role: "assistant",`,
+                `                content: "Микроструктура 1m проанализирована",`,
+                `            }`,
+                `        );`,
+                ``,
+                `        // Сообщение 5: Запрос сигнала`,
+                `        messages.push(`,
+                `            {`,
+                `                role: "user",`,
+                `                content: [`,
+                `                    "Проанализируй все таймфреймы и сгенерируй торговый сигнал согласно этой стратегии. Открывай позицию ТОЛЬКО при четком сигнале.",`,
+                `                    "",`,
+                `                    \`${escapedPrompt}\`,`,
+                `                    "",`,
+                `                    "Если сигналы противоречивы или тренд слабый то position: wait"`,
+                `                ].join("\\n"),`,
+                `            }`,
+                `        );`,
+                ``,
+                `        const resultId = uuid();`,
+                ``,
+                `        const result = await json(messages);`,
+                ``,
+                `        await dumpJson(resultId, messages, result);`,
+                ``,
+                `        result.id = resultId;`,
+                ``,
+                `        return result;`,
+                `    },`,
+                `});`
+            ].join("\n");
+        };
+        /**
+         * Generates Exchange configuration code.
+         * Uses CCXT Binance with standard formatters.
+         *
+         * @param symbol - Trading pair symbol (unused, for consistency)
+         * @param exchangeName - Unique exchange identifier
+         * @returns Generated addExchange() call with CCXT integration
+         */
+        this.getExchangeTemplate = async (symbol, exchangeName) => {
+            this.loggerService.log("optimizerTemplateService getExchangeTemplate", {
+                exchangeName,
+                symbol,
+            });
+            // Escape special characters to prevent code injection
+            const escapedExchangeName = String(exchangeName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            return [
+                `addExchangeSchema({`,
+                `    exchangeName: "${escapedExchangeName}",`,
+                `    getCandles: async (symbol, interval, since, limit) => {`,
+                `        const exchange = new ccxt.binance();`,
+                `        const ohlcv = await exchange.fetchOHLCV(symbol, interval, since.getTime(), limit);`,
+                `        return ohlcv.map(([timestamp, open, high, low, close, volume]) => ({`,
+                `            timestamp, open, high, low, close, volume`,
+                `        }));`,
+                `    },`,
+                `    formatPrice: async (symbol, price) => price.toFixed(2),`,
+                `    formatQuantity: async (symbol, quantity) => quantity.toFixed(8),`,
+                `});`
+            ].join("\n");
+        };
+        /**
+         * Generates Frame (timeframe) configuration code.
+         *
+         * @param symbol - Trading pair symbol (unused, for consistency)
+         * @param frameName - Unique frame identifier
+         * @param interval - Candle interval (e.g., "1m")
+         * @param startDate - Frame start date
+         * @param endDate - Frame end date
+         * @returns Generated addFrame() call
+         */
+        this.getFrameTemplate = async (symbol, frameName, interval, startDate, endDate) => {
+            this.loggerService.log("optimizerTemplateService getFrameTemplate", {
+                symbol,
+                frameName,
+                interval,
+                startDate,
+                endDate,
+            });
+            // Escape special characters to prevent code injection
+            const escapedFrameName = String(frameName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedInterval = String(interval)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            return [
+                `addFrameSchema({`,
+                `    frameName: "${escapedFrameName}",`,
+                `    interval: "${escapedInterval}",`,
+                `    startDate: new Date("${startDate.toISOString()}"),`,
+                `    endDate: new Date("${endDate.toISOString()}"),`,
+                `});`
+            ].join("\n");
+        };
+        /**
+         * Generates launcher code to run Walker with event listeners.
+         * Includes progress tracking and completion handlers.
+         *
+         * @param symbol - Trading pair symbol
+         * @param walkerName - Walker name to launch
+         * @returns Generated Walker.background() call with listeners
+         */
+        this.getLauncherTemplate = async (symbol, walkerName) => {
+            this.loggerService.log("optimizerTemplateService getLauncherTemplate", {
+                symbol,
+                walkerName,
+            });
+            // Escape special characters to prevent code injection
+            const escapedSymbol = String(symbol)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            const escapedWalkerName = String(walkerName)
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            return [
+                `Walker.background("${escapedSymbol}", {`,
+                `    walkerName: "${escapedWalkerName}"`,
+                `});`,
+                ``,
+                `listenSignalBacktest((event) => {`,
+                `    console.log(event);`,
+                `});`,
+                ``,
+                `listenBacktestProgress((event) => {`,
+                `    console.log(\`Progress: \${(event.progress * 100).toFixed(2)}%\`);`,
+                `    console.log(\`Processed: \${event.processedFrames} / \${event.totalFrames}\`);`,
+                `});`,
+                ``,
+                `listenWalkerProgress((event) => {`,
+                `    console.log(\`Progress: \${(event.progress * 100).toFixed(2)}%\`);`,
+                `    console.log(\`\${event.processedStrategies} / \${event.totalStrategies} strategies\`);`,
+                `    console.log(\`Walker: \${event.walkerName}, Symbol: \${event.symbol}\`);`,
+                `});`,
+                ``,
+                `listenWalkerComplete((results) => {`,
+                `    console.log("Walker completed:", results.bestStrategy);`,
+                `    Walker.dump(results.symbol, { walkerName: results.walkerName });`,
+                `});`,
+                ``,
+                `listenDoneBacktest((event) => {`,
+                `    console.log("Backtest completed:", event.symbol);`,
+                `    Backtest.dump(event.symbol, {`,
+                `        strategyName: event.strategyName,`,
+                `        exchangeName: event.exchangeName,`,
+                `        frameName: event.frameName`,
+                `    });`,
+                `});`,
+                ``,
+                `listenError((error) => {`,
+                `    console.error("Error occurred:", error);`,
+                `});`
+            ].join("\n");
+        };
+        /**
+         * Generates dumpJson() helper function for debug output.
+         * Saves LLM conversations and results to ./dump/strategy/{resultId}/
+         *
+         * @param symbol - Trading pair symbol (unused, for consistency)
+         * @returns Generated async dumpJson() function
+         */
+        this.getJsonDumpTemplate = async (symbol) => {
+            this.loggerService.log("optimizerTemplateService getJsonDumpTemplate", {
+                symbol,
+            });
+            return [
+                `async function dumpJson(resultId, history, result, outputDir = "./dump/strategy") {`,
+                `    // Extract system messages and system reminders from existing data`,
+                `    const systemMessages = history.filter((m) => m.role === "system");`,
+                `    const userMessages = history.filter((m) => m.role === "user");`,
+                `    const subfolderPath = path.join(outputDir, resultId);`,
+                ``,
+                `    try {`,
+                `        await fs.access(subfolderPath);`,
+                `        return;`,
+                `    } catch {`,
+                `        await fs.mkdir(subfolderPath, { recursive: true });`,
+                `    }`,
+                ``,
+                `    {`,
+                `        let summary = "# Outline Result Summary\\n\\n";`,
+                ``,
+                `        {`,
+                `            summary += \`**ResultId**: \${resultId}\\n\\n\`;`,
+                `        }`,
+                ``,
+                `        if (result) {`,
+                `            summary += "## Output Data\\n\\n";`,
+                `            summary += "\`\`\`json\\n";`,
+                `            summary += JSON.stringify(result, null, 2);`,
+                `            summary += "\\n\`\`\`\\n\\n";`,
+                `        }`,
+                ``,
+                `        // Add system messages to summary`,
+                `        if (systemMessages.length > 0) {`,
+                `            summary += "## System Messages\\n\\n";`,
+                `            systemMessages.forEach((msg, idx) => {`,
+                `                summary += \`### System Message \${idx + 1}\\n\\n\`;`,
+                `                summary += msg.content;`,
+                `                summary += "\\n\\n";`,
+                `            });`,
+                `        }`,
+                ``,
+                `        const summaryFile = path.join(subfolderPath, "00_system_prompt.md");`,
+                `        await fs.writeFile(summaryFile, summary, "utf8");`,
+                `    }`,
+                ``,
+                `    {`,
+                `        await Promise.all(`,
+                `            Array.from(userMessages.entries()).map(async ([idx, message]) => {`,
+                `                const messageNum = String(idx + 1).padStart(2, "0");`,
+                `                const contentFileName = \`\${messageNum}_user_message.md\`;`,
+                `                const contentFilePath = path.join(subfolderPath, contentFileName);`,
+                ``,
+                `                {`,
+                `                    const messageSizeBytes = Buffer.byteLength(message.content, "utf8");`,
+                `                    const messageSizeKb = Math.floor(messageSizeBytes / 1024);`,
+                `                    if (messageSizeKb > WARN_KB) {`,
+                `                        console.warn(`,
+                `                            \`User message \${idx + 1} is \${messageSizeBytes} bytes (\${messageSizeKb}kb), which exceeds warning limit\``,
+                `                        );`,
+                `                    }`,
+                `                }`,
+                ``,
+                `                let content = \`# User Input \${idx + 1}\\n\\n\`;`,
+                `                content += \`**ResultId**: \${resultId}\\n\\n\`;`,
+                `                content += message.content;`,
+                `                content += "\\n";`,
+                ``,
+                `                await fs.writeFile(contentFilePath, content, "utf8");`,
+                `            })`,
+                `        );`,
+                `    }`,
+                ``,
+                `    {`,
+                `        const messageNum = String(userMessages.length + 1).padStart(2, "0");`,
+                `        const contentFileName = \`\${messageNum}_llm_output.md\`;`,
+                `        const contentFilePath = path.join(subfolderPath, contentFileName);`,
+                ``,
+                `        let content = "# Full Outline Result\\n\\n";`,
+                `        content += \`**ResultId**: \${resultId}\\n\\n\`;`,
+                ``,
+                `        if (result) {`,
+                `            content += "## Output Data\\n\\n";`,
+                `            content += "\`\`\`json\\n";`,
+                `            content += JSON.stringify(result, null, 2);`,
+                `            content += "\\n\`\`\`\\n";`,
+                `        }`,
+                ``,
+                `        await fs.writeFile(contentFilePath, content, "utf8");`,
+                `    }`,
+                `}`
+            ].join("\n");
+        };
+        /**
+         * Generates text() helper for LLM text generation.
+         * Uses Ollama deepseek-v3.1:671b model for market analysis.
+         *
+         * @param symbol - Trading pair symbol (used in prompt)
+         * @returns Generated async text() function
+         */
+        this.getTextTemplate = async (symbol) => {
+            this.loggerService.log("optimizerTemplateService getTextTemplate", {
+                symbol,
+            });
+            // Escape special characters in symbol to prevent code injection
+            const escapedSymbol = String(symbol)
+                .replace(/\\/g, '\\\\')
+                .replace(/`/g, '\\`')
+                .replace(/\$/g, '\\$')
+                .toUpperCase();
+            return [
+                `async function text(messages) {`,
+                `    const ollama = new Ollama({`,
+                `        host: "https://ollama.com",`,
+                `        headers: {`,
+                `            Authorization: \`Bearer \${process.env.OLLAMA_API_KEY}\`,`,
+                `        },`,
+                `    });`,
+                ``,
+                `    const response = await ollama.chat({`,
+                `        model: "deepseek-v3.1:671b",`,
+                `        messages: [`,
+                `            {`,
+                `                role: "system",`,
+                `                content: [`,
+                `                    "В ответ напиши торговую стратегию где нет ничего лишнего,",`,
+                `                    "только отчёт готовый для копипасты целиком",`,
+                `                    "",`,
+                `                    "**ВАЖНО**: Не здоровайся, не говори что делаешь - только отчёт!"`,
+                `                ].join("\\n"),`,
+                `            },`,
+                `            ...messages,`,
+                `            {`,
+                `                role: "user",`,
+                `                content: [`,
+                `                    "На каких условиях мне купить ${escapedSymbol}?",`,
+                `                    "Дай анализ рынка на основе поддержки/сопротивления, точек входа в LONG/SHORT позиции.",`,
+                `                    "Какой RR ставить для позиций?",`,
+                `                    "Предпочтительны LONG или SHORT позиции?",`,
+                `                    "",`,
+                `                    "Сделай не сухой технический, а фундаментальный анализ, содержащий стратигическую рекомендацию, например, покупать на низу боковика"`,
+                `                ].join("\\n")`,
+                `            }`,
+                `        ]`,
+                `    });`,
+                ``,
+                `    const content = response.message.content.trim();`,
+                `    return content`,
+                `        .replace(/\\\\/g, '\\\\\\\\')`,
+                `        .replace(/\`/g, '\\\\\`')`,
+                `        .replace(/\\$/g, '\\\\$')`,
+                `        .replace(/"/g, '\\\\"')`,
+                `        .replace(/'/g, "\\\\'");`,
+                `}`
+            ].join("\n");
+        };
+        /**
+         * Generates json() helper for structured LLM output.
+         * Uses Ollama with JSON schema for trading signals.
+         *
+         * Signal schema:
+         * - position: "wait" | "long" | "short"
+         * - note: strategy explanation
+         * - priceOpen: entry price
+         * - priceTakeProfit: target price
+         * - priceStopLoss: stop price
+         * - minuteEstimatedTime: expected duration (max 360 min)
+         *
+         * @param symbol - Trading pair symbol (unused, for consistency)
+         * @returns Generated async json() function with signal schema
+         */
+        this.getJsonTemplate = async (symbol) => {
+            this.loggerService.log("optimizerTemplateService getJsonTemplate", {
+                symbol,
+            });
+            return [
+                `async function json(messages) {`,
+                `    const ollama = new Ollama({`,
+                `        host: "https://ollama.com",`,
+                `        headers: {`,
+                `            Authorization: \`Bearer \${process.env.OLLAMA_API_KEY}\`,`,
+                `        },`,
+                `    });`,
+                ``,
+                `    const response = await ollama.chat({`,
+                `        model: "deepseek-v3.1:671b",`,
+                `        messages: [`,
+                `            {`,
+                `                role: "system",`,
+                `                content: [`,
+                `                    "Проанализируй торговую стратегию и верни торговый сигнал.",`,
+                `                    "",`,
+                `                    "ПРАВИЛА ОТКРЫТИЯ ПОЗИЦИЙ:",`,
+                `                    "",`,
+                `                    "1. ТИПЫ ПОЗИЦИЙ:",`,
+                `                    "   - position='wait': нет четкого сигнала, жди лучших условий",`,
+                `                    "   - position='long': бычий сигнал, цена будет расти",`,
+                `                    "   - position='short': медвежий сигнал, цена будет падать",`,
+                `                    "",`,
+                `                    "2. ЦЕНА ВХОДА (priceOpen):",`,
+                `                    "   - Может быть текущей рыночной ценой для немедленного входа",`,
+                `                    "   - Может быть отложенной ценой для входа при достижении уровня",`,
+                `                    "   - Укажи оптимальную цену входа согласно технического анализа",`,
+                `                    "",`,
+                `                    "3. УРОВНИ ВЫХОДА:",`,
+                `                    "   - LONG: priceTakeProfit > priceOpen > priceStopLoss",`,
+                `                    "   - SHORT: priceStopLoss > priceOpen > priceTakeProfit",`,
+                `                    "   - Уровни должны иметь техническое обоснование (Fibonacci, S/R, Bollinger)",`,
+                `                    "",`,
+                `                    "4. ВРЕМЕННЫЕ РАМКИ:",`,
+                `                    "   - minuteEstimatedTime: прогноз времени до TP (макс 360 минут)",`,
+                `                    "   - Расчет на основе ATR, ADX, MACD, Momentum, Slope",`,
+                `                    "   - Если индикаторов, осциллятор или других метрик нет, посчитай их самостоятельно",`,
+                `                ].join("\\n"),`,
+                `            },`,
+                `            ...messages,`,
+                `        ],`,
+                `        format: {`,
+                `            type: "object",`,
+                `            properties: {`,
+                `                position: {`,
+                `                    type: "string",`,
+                `                    enum: ["wait", "long", "short"],`,
+                `                    description: "Trade decision: wait (no signal), long (buy), or short (sell)",`,
+                `                },`,
+                `                note: {`,
+                `                    type: "string",`,
+                `                    description: "Professional trading recommendation with price levels",`,
+                `                },`,
+                `                priceOpen: {`,
+                `                    type: "number",`,
+                `                    description: "Entry price (current market price or limit order price)",`,
+                `                },`,
+                `                priceTakeProfit: {`,
+                `                    type: "number",`,
+                `                    description: "Take profit target price",`,
+                `                },`,
+                `                priceStopLoss: {`,
+                `                    type: "number",`,
+                `                    description: "Stop loss exit price",`,
+                `                },`,
+                `                minuteEstimatedTime: {`,
+                `                    type: "number",`,
+                `                    description: "Expected time to reach TP in minutes (max 360)",`,
+                `                },`,
+                `            },`,
+                `            required: ["position", "note", "priceOpen", "priceTakeProfit", "priceStopLoss", "minuteEstimatedTime"],`,
+                `        },`,
+                `    });`,
+                ``,
+                `    const jsonResponse = JSON.parse(response.message.content.trim());`,
+                `    return jsonResponse;`,
+                `}`
+            ].join("\n");
+        };
+    }
+}
+
+/**
+ * Service for managing optimizer schema registration and retrieval.
+ * Provides validation and registry management for optimizer configurations.
+ *
+ * Uses ToolRegistry for immutable schema storage.
+ */
+class OptimizerSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._registry = new ToolRegistry("optimizerSchema");
+        /**
+         * Registers a new optimizer schema.
+         * Validates required fields before registration.
+         *
+         * @param key - Unique optimizer name
+         * @param value - Optimizer schema configuration
+         * @throws Error if schema validation fails
+         */
+        this.register = (key, value) => {
+            this.loggerService.log(`optimizerSchemaService register`, { key });
+            this.validateShallow(value);
+            this._registry = this._registry.register(key, value);
+        };
+        /**
+         * Validates optimizer schema structure.
+         * Checks required fields: optimizerName, rangeTrain, source, getPrompt.
+         *
+         * @param optimizerSchema - Schema to validate
+         * @throws Error if validation fails
+         */
+        this.validateShallow = (optimizerSchema) => {
+            this.loggerService.log(`optimizerTemplateService validateShallow`, {
+                optimizerSchema,
+            });
+            if (typeof optimizerSchema.optimizerName !== "string") {
+                throw new Error(`optimizer template validation failed: missing optimizerName`);
+            }
+            if (!Array.isArray(optimizerSchema.rangeTrain) || optimizerSchema.rangeTrain.length === 0) {
+                throw new Error(`optimizer template validation failed: rangeTrain must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+            if (!Array.isArray(optimizerSchema.source) || optimizerSchema.source.length === 0) {
+                throw new Error(`optimizer template validation failed: source must be a non-empty array for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+            if (typeof optimizerSchema.getPrompt !== "function") {
+                throw new Error(`optimizer template validation failed: getPrompt must be a function for optimizerName=${optimizerSchema.optimizerName}`);
+            }
+        };
+        /**
+         * Partially overrides an existing optimizer schema.
+         * Merges provided values with existing schema.
+         *
+         * @param key - Optimizer name to override
+         * @param value - Partial schema values to merge
+         * @returns Updated complete schema
+         * @throws Error if optimizer not found
+         */
+        this.override = (key, value) => {
+            this.loggerService.log(`optimizerSchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        /**
+         * Retrieves optimizer schema by name.
+         *
+         * @param key - Optimizer name
+         * @returns Complete optimizer schema
+         * @throws Error if optimizer not found
+         */
+        this.get = (key) => {
+            this.loggerService.log(`optimizerSchemaService get`, { key });
+            return this._registry.get(key);
+        };
+    }
+}
+
+/**
+ * Service for validating optimizer existence and managing optimizer registry.
+ * Maintains a Map of registered optimizers for validation purposes.
+ *
+ * Uses memoization for efficient repeated validation checks.
+ */
+class OptimizerValidationService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._optimizerMap = new Map();
+        /**
+         * Adds optimizer to validation registry.
+         * Prevents duplicate optimizer names.
+         *
+         * @param optimizerName - Unique optimizer identifier
+         * @param optimizerSchema - Complete optimizer schema
+         * @throws Error if optimizer with same name already exists
+         */
+        this.addOptimizer = (optimizerName, optimizerSchema) => {
+            this.loggerService.log("optimizerValidationService addOptimizer", {
+                optimizerName,
+                optimizerSchema,
+            });
+            if (this._optimizerMap.has(optimizerName)) {
+                throw new Error(`optimizer ${optimizerName} already exist`);
+            }
+            this._optimizerMap.set(optimizerName, optimizerSchema);
+        };
+        /**
+         * Validates that optimizer exists in registry.
+         * Memoized for performance on repeated checks.
+         *
+         * @param optimizerName - Optimizer name to validate
+         * @param source - Source method name for error messages
+         * @throws Error if optimizer not found
+         */
+        this.validate = memoize(([optimizerName]) => optimizerName, (optimizerName, source) => {
+            this.loggerService.log("optimizerValidationService validate", {
+                optimizerName,
+                source,
+            });
+            const optimizer = this._optimizerMap.get(optimizerName);
+            if (!optimizer) {
+                throw new Error(`optimizer ${optimizerName} not found source=${source}`);
+            }
+            return true;
+        });
+        /**
+         * Lists all registered optimizer schemas.
+         *
+         * @returns Array of all optimizer schemas
+         */
+        this.list = async () => {
+            this.loggerService.log("optimizerValidationService list");
+            return Array.from(this._optimizerMap.values());
+        };
+    }
+}
+
+/**
+ * Emitter for optimizer progress events.
+ */
+const progressOptimizerEmitter = new Subject();
+/**
+ * Emitter for error events.
+ */
+const errorEmitter = new Subject();
+
+const ITERATION_LIMIT = 25;
+const DEFAULT_SOURCE_NAME = "unknown";
+const CREATE_PREFIX_FN = () => (Math.random() + 1).toString(36).substring(7);
+/**
+ * Wrapper to call onSourceData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ */
+const CALL_SOURCE_DATA_CALLBACKS_FN = trycatch(async (self, symbol, name, data, startDate, endDate) => {
+    if (self.params.callbacks?.onSourceData) {
+        await self.params.callbacks.onSourceData(symbol, name, data, startDate, endDate);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientOptimizer CALL_SOURCE_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        engine$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ */
+const CALL_DATA_CALLBACKS_FN = trycatch(async (self, symbol, strategyList) => {
+    if (self.params.callbacks?.onData) {
+        await self.params.callbacks.onData(symbol, strategyList);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientOptimizer CALL_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        engine$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onCode callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ */
+const CALL_CODE_CALLBACKS_FN = trycatch(async (self, symbol, code) => {
+    if (self.params.callbacks?.onCode) {
+        await self.params.callbacks.onCode(symbol, code);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientOptimizer CALL_CODE_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        engine$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onDump callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ */
+const CALL_DUMP_CALLBACKS_FN = trycatch(async (self, symbol, filepath) => {
+    if (self.params.callbacks?.onDump) {
+        await self.params.callbacks.onDump(symbol, filepath);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientOptimizer CALL_DUMP_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        engine$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Default user message formatter.
+ * Delegates to template's getUserMessage method.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Fetched data array
+ * @param name - Source name
+ * @param self - ClientOptimizer instance
+ * @returns Formatted user message content
+ */
+const DEFAULT_USER_FN = async (symbol, data, name, self) => {
+    return await self.params.template.getUserMessage(symbol, data, name);
+};
+/**
+ * Default assistant message formatter.
+ * Delegates to template's getAssistantMessage method.
+ *
+ * @param symbol - Trading pair symbol
+ * @param data - Fetched data array
+ * @param name - Source name
+ * @param self - ClientOptimizer instance
+ * @returns Formatted assistant message content
+ */
+const DEFAULT_ASSISTANT_FN = async (symbol, data, name, self) => {
+    return await self.params.template.getAssistantMessage(symbol, data, name);
+};
+/**
+ * Resolves paginated data from source with deduplication.
+ * Uses iterateDocuments to handle pagination automatically.
+ *
+ * @param fetch - Source fetch function
+ * @param filterData - Filter arguments (symbol, dates)
+ * @returns Deduplicated array of all fetched data
+ */
+const RESOLVE_PAGINATION_FN = async (fetch, filterData) => {
+    const iterator = iterateDocuments({
+        limit: ITERATION_LIMIT,
+        async createRequest({ limit, offset }) {
+            return await fetch({
+                symbol: filterData.symbol,
+                startDate: filterData.startDate,
+                endDate: filterData.endDate,
+                limit,
+                offset,
+            });
+        },
+    });
+    const distinct = distinctDocuments(iterator, (data) => data.id);
+    return await resolveDocuments(distinct);
+};
+/**
+ * Collects data from all sources and generates strategy metadata.
+ * Iterates through training ranges, fetches data from each source,
+ * builds LLM conversation history, and generates strategy prompts.
+ *
+ * @param symbol - Trading pair symbol
+ * @param self - ClientOptimizer instance
+ * @returns Array of generated strategies with conversation context
+ */
+const GET_STRATEGY_DATA_FN = async (symbol, self) => {
+    const strategyList = [];
+    const totalSources = self.params.rangeTrain.length * self.params.source.length;
+    let processedSources = 0;
+    for (const { startDate, endDate } of self.params.rangeTrain) {
+        const messageList = [];
+        for (const source of self.params.source) {
+            // Emit progress event at the start of processing each source
+            await self.onProgress({
+                optimizerName: self.params.optimizerName,
+                symbol,
+                totalSources,
+                processedSources,
+                progress: totalSources > 0 ? processedSources / totalSources : 0,
+            });
+            if (typeof source === "function") {
+                const data = await RESOLVE_PAGINATION_FN(source, {
+                    symbol,
+                    startDate,
+                    endDate,
+                });
+                await CALL_SOURCE_DATA_CALLBACKS_FN(self, symbol, DEFAULT_SOURCE_NAME, data, startDate, endDate);
+                const [userContent, assistantContent] = await Promise.all([
+                    DEFAULT_USER_FN(symbol, data, DEFAULT_SOURCE_NAME, self),
+                    DEFAULT_ASSISTANT_FN(symbol, data, DEFAULT_SOURCE_NAME, self),
+                ]);
+                messageList.push({
+                    role: "user",
+                    content: userContent,
+                }, {
+                    role: "assistant",
+                    content: assistantContent,
+                });
+                processedSources++;
+            }
+            else {
+                const { fetch, name = DEFAULT_SOURCE_NAME, assistant = DEFAULT_ASSISTANT_FN, user = DEFAULT_USER_FN, } = source;
+                const data = await RESOLVE_PAGINATION_FN(fetch, {
+                    symbol,
+                    startDate,
+                    endDate,
+                });
+                await CALL_SOURCE_DATA_CALLBACKS_FN(self, symbol, name, data, startDate, endDate);
+                const [userContent, assistantContent] = await Promise.all([
+                    user(symbol, data, name, self),
+                    assistant(symbol, data, name, self),
+                ]);
+                messageList.push({
+                    role: "user",
+                    content: userContent,
+                }, {
+                    role: "assistant",
+                    content: assistantContent,
+                });
+                processedSources++;
+            }
+            const name = "name" in source
+                ? source.name || DEFAULT_SOURCE_NAME
+                : DEFAULT_SOURCE_NAME;
+            strategyList.push({
+                symbol,
+                name,
+                messages: messageList,
+                strategy: await self.params.getPrompt(symbol, messageList),
+            });
+        }
+    }
+    // Emit final progress event (100%)
+    await self.onProgress({
+        optimizerName: self.params.optimizerName,
+        symbol,
+        totalSources,
+        processedSources: totalSources,
+        progress: 1.0,
+    });
+    await CALL_DATA_CALLBACKS_FN(self, symbol, strategyList);
+    return strategyList;
+};
+/**
+ * Generates complete executable strategy code.
+ * Assembles all components: imports, helpers, exchange, frames, strategies, walker, launcher.
+ *
+ * @param symbol - Trading pair symbol
+ * @param self - ClientOptimizer instance
+ * @returns Generated TypeScript/JavaScript code as string
+ */
+const GET_STRATEGY_CODE_FN = async (symbol, self) => {
+    const strategyData = await self.getData(symbol);
+    const prefix = CREATE_PREFIX_FN();
+    const sections = [];
+    const exchangeName = `${prefix}_exchange`;
+    // 1. Top banner with imports
+    {
+        sections.push(await self.params.template.getTopBanner(symbol));
+        sections.push("");
+    }
+    // 2. JSON dump helper function
+    {
+        sections.push(await self.params.template.getJsonDumpTemplate(symbol));
+        sections.push("");
+    }
+    // 3. Helper functions (text and json)
+    {
+        sections.push(await self.params.template.getTextTemplate(symbol));
+        sections.push("");
+    }
+    {
+        sections.push(await self.params.template.getJsonTemplate(symbol));
+        sections.push("");
+    }
+    // 4. Exchange template (assuming first strategy has exchange info)
+    {
+        sections.push(await self.params.template.getExchangeTemplate(symbol, exchangeName));
+        sections.push("");
+    }
+    // 5. Train frame templates
+    {
+        for (let i = 0; i < self.params.rangeTrain.length; i++) {
+            const range = self.params.rangeTrain[i];
+            const frameName = `${prefix}_train_frame-${i + 1}`;
+            sections.push(await self.params.template.getFrameTemplate(symbol, frameName, "1m", // default interval
+            range.startDate, range.endDate));
+            sections.push("");
+        }
+    }
+    // 6. Test frame template
+    {
+        const testFrameName = `${prefix}_test_frame`;
+        sections.push(await self.params.template.getFrameTemplate(symbol, testFrameName, "1m", // default interval
+        self.params.rangeTest.startDate, self.params.rangeTest.endDate));
+        sections.push("");
+    }
+    // 7. Strategy templates for each generated strategy
+    {
+        for (let i = 0; i < strategyData.length; i++) {
+            const strategy = strategyData[i];
+            const strategyName = `${prefix}_strategy-${i + 1}`;
+            const interval = "5m"; // default interval
+            sections.push(await self.params.template.getStrategyTemplate(strategyName, interval, strategy.strategy));
+            sections.push("");
+        }
+    }
+    // 8. Walker template (uses test frame for validation)
+    {
+        const walkerName = `${prefix}_walker`;
+        const testFrameName = `${prefix}_test_frame`;
+        const strategies = strategyData.map((_, i) => `${prefix}_strategy-${i + 1}`);
+        sections.push(await self.params.template.getWalkerTemplate(walkerName, `${exchangeName}`, testFrameName, strategies));
+        sections.push("");
+    }
+    // 9. Launcher template
+    {
+        const walkerName = `${prefix}_walker`;
+        sections.push(await self.params.template.getLauncherTemplate(symbol, walkerName));
+        sections.push("");
+    }
+    const code = sections.join("\n");
+    await CALL_CODE_CALLBACKS_FN(self, symbol, code);
+    return code;
+};
+/**
+ * Saves generated strategy code to file.
+ * Creates directory if needed, writes .mjs file with generated code.
+ *
+ * @param symbol - Trading pair symbol
+ * @param path - Output directory path
+ * @param self - ClientOptimizer instance
+ */
+const GET_STRATEGY_DUMP_FN = async (symbol, path, self) => {
+    const report = await self.getCode(symbol);
+    try {
+        const dir = join(process.cwd(), path);
+        await mkdir(dir, { recursive: true });
+        const filename = `${self.params.optimizerName}_${symbol}.mjs`;
+        const filepath = join(dir, filename);
+        await writeFile(filepath, report, "utf-8");
+        self.params.logger.info(`Optimizer report saved: ${filepath}`);
+        await CALL_DUMP_CALLBACKS_FN(self, symbol, filepath);
+    }
+    catch (error) {
+        self.params.logger.warn(`Failed to save optimizer report:`, error);
+        throw error;
+    }
+};
+/**
+ * Client implementation for optimizer operations.
+ *
+ * Features:
+ * - Data collection from multiple sources with pagination
+ * - LLM conversation history building
+ * - Strategy code generation with templates
+ * - File export with callbacks
+ *
+ * Used by OptimizerConnectionService to create optimizer instances.
+ */
+class ClientOptimizer {
+    constructor(params, onProgress) {
+        this.params = params;
+        this.onProgress = onProgress;
+        /**
+         * Fetches data from all sources and generates strategy metadata.
+         * Processes each training range and builds LLM conversation history.
+         *
+         * @param symbol - Trading pair symbol
+         * @returns Array of generated strategies with conversation context
+         */
+        this.getData = async (symbol) => {
+            this.params.logger.debug("ClientOptimizer getData", {
+                symbol,
+            });
+            return await GET_STRATEGY_DATA_FN(symbol, this);
+        };
+        /**
+         * Generates complete executable strategy code.
+         * Includes imports, helpers, strategies, walker, and launcher.
+         *
+         * @param symbol - Trading pair symbol
+         * @returns Generated TypeScript/JavaScript code as string
+         */
+        this.getCode = async (symbol) => {
+            this.params.logger.debug("ClientOptimizer getCode", {
+                symbol,
+            });
+            return await GET_STRATEGY_CODE_FN(symbol, this);
+        };
+        /**
+         * Generates and saves strategy code to file.
+         * Creates directory if needed, writes .mjs file.
+         *
+         * @param symbol - Trading pair symbol
+         * @param path - Output directory path (default: "./")
+         */
+        this.dump = async (symbol, path = "./") => {
+            this.params.logger.debug("ClientOptimizer dump", {
+                symbol,
+                path,
+            });
+            return await GET_STRATEGY_DUMP_FN(symbol, path, this);
+        };
+    }
+}
+
+/**
+ * Callback function for emitting progress events to progressOptimizerEmitter.
+ */
+const COMMIT_PROGRESS_FN = async (progress) => progressOptimizerEmitter.next(progress);
+/**
+ * Service for creating and caching optimizer client instances.
+ * Handles dependency injection and template merging.
+ *
+ * Features:
+ * - Memoized optimizer instances (one per optimizerName)
+ * - Template merging (custom + defaults)
+ * - Logger injection
+ * - Delegates to ClientOptimizer for actual operations
+ */
+class OptimizerConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.optimizerSchemaService = inject(TYPES.optimizerSchemaService);
+        this.optimizerTemplateService = inject(TYPES.optimizerTemplateService);
+        /**
+         * Creates or retrieves cached optimizer instance.
+         * Memoized by optimizerName for performance.
+         *
+         * Merges custom templates from schema with defaults from OptimizerTemplateService.
+         *
+         * @param optimizerName - Unique optimizer identifier
+         * @returns ClientOptimizer instance with resolved dependencies
+         */
+        this.getOptimizer = memoize(([optimizerName]) => `${optimizerName}`, (optimizerName) => {
+            const { getPrompt, rangeTest, rangeTrain, source, template: rawTemplate = {}, callbacks, } = this.optimizerSchemaService.get(optimizerName);
+            const { getAssistantMessage = this.optimizerTemplateService.getAssistantMessage, getExchangeTemplate = this.optimizerTemplateService.getExchangeTemplate, getFrameTemplate = this.optimizerTemplateService.getFrameTemplate, getJsonDumpTemplate = this.optimizerTemplateService.getJsonDumpTemplate, getJsonTemplate = this.optimizerTemplateService.getJsonTemplate, getLauncherTemplate = this.optimizerTemplateService.getLauncherTemplate, getStrategyTemplate = this.optimizerTemplateService.getStrategyTemplate, getTextTemplate = this.optimizerTemplateService.getTextTemplate, getWalkerTemplate = this.optimizerTemplateService.getWalkerTemplate, getTopBanner = this.optimizerTemplateService.getTopBanner, getUserMessage = this.optimizerTemplateService.getUserMessage, } = rawTemplate;
+            const template = {
+                getAssistantMessage,
+                getExchangeTemplate,
+                getFrameTemplate,
+                getJsonDumpTemplate,
+                getJsonTemplate,
+                getLauncherTemplate,
+                getStrategyTemplate,
+                getTextTemplate,
+                getWalkerTemplate,
+                getTopBanner,
+                getUserMessage,
+            };
+            return new ClientOptimizer({
+                optimizerName,
+                logger: this.loggerService,
+                getPrompt,
+                rangeTest,
+                rangeTrain,
+                source,
+                template,
+                callbacks,
+            }, COMMIT_PROGRESS_FN);
+        });
+        /**
+         * Fetches data from all sources and generates strategy metadata.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Array of generated strategies with conversation context
+         */
+        this.getData = async (symbol, optimizerName) => {
+            this.loggerService.log("optimizerConnectionService getData", {
+                symbol,
+                optimizerName,
+            });
+            const optimizer = this.getOptimizer(optimizerName);
+            return await optimizer.getData(symbol);
+        };
+        /**
+         * Generates complete executable strategy code.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Generated TypeScript/JavaScript code as string
+         */
+        this.getCode = async (symbol, optimizerName) => {
+            this.loggerService.log("optimizerConnectionService getCode", {
+                symbol,
+                optimizerName,
+            });
+            const optimizer = this.getOptimizer(optimizerName);
+            return await optimizer.getCode(symbol);
+        };
+        /**
+         * Generates and saves strategy code to file.
+         *
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @param path - Output directory path (optional)
+         */
+        this.dump = async (symbol, optimizerName, path) => {
+            this.loggerService.log("optimizerConnectionService getCode", {
+                symbol,
+                optimizerName,
+            });
+            const optimizer = this.getOptimizer(optimizerName);
+            return await optimizer.dump(symbol, path);
+        };
+    }
+}
+
+const METHOD_NAME_GET_DATA = "optimizerGlobalService getData";
+const METHOD_NAME_GET_CODE = "optimizerGlobalService getCode";
+const METHOD_NAME_DUMP = "optimizerGlobalService dump";
+/**
+ * Global service for optimizer operations with validation.
+ * Entry point for public API, performs validation before delegating to ConnectionService.
+ *
+ * Workflow:
+ * 1. Log operation
+ * 2. Validate optimizer exists
+ * 3. Delegate to OptimizerConnectionService
+ */
+class OptimizerGlobalService {
     constructor() {
-        /** Private service handling AI provider operations */
-        this.runnerPrivateService = inject(TYPES.runnerPrivateService);
-        /** Logger service for operation tracking */
         this.loggerService = inject(TYPES.loggerService);
+        this.optimizerConnectionService = inject(TYPES.optimizerConnectionService);
+        this.optimizerValidationService = inject(TYPES.optimizerValidationService);
         /**
-         * Executes a standard AI completion within the specified context.
-         *
-         * @param params - Completion parameters including messages and options
-         * @param context - Execution context with inference provider, model, and API key
-         * @returns Promise resolving to AI response message
+         * Fetches data from all sources and generates strategy metadata.
+         * Validates optimizer existence before execution.
          *
-         * @example
-         * ```typescript
-         * const result = await runnerPublicService.getCompletion({
-         *   messages: [
-         *     { role: "system", content: "You are a trading analyst" },
-         *     { role: "user", content: "Analyze BTC/USDT" }
-         *   ]
-         * }, {
-         *   inference: InferenceName.ClaudeInference,
-         *   model: "claude-3-5-sonnet-20240620",
-         *   apiKey: "sk-ant-..."
-         * });
-         * ```
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Array of generated strategies with conversation context
+         * @throws Error if optimizer not found
          */
-        this.getCompletion = async (params, context) => {
-            this.loggerService.log("runnerPublicService getCompletion");
-            return await ContextService.runInContext(async () => {
-                return await this.runnerPrivateService.getCompletion(params);
-            }, context);
+        this.getData = async (symbol, optimizerName) => {
+            this.loggerService.log(METHOD_NAME_GET_DATA, {
+                symbol,
+                optimizerName,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_DATA);
+            return await this.optimizerConnectionService.getData(symbol, optimizerName);
         };
         /**
-         * Executes a streaming AI completion within the specified context.
-         *
-         * Similar to getCompletion but enables streaming mode where supported by the provider.
-         * The response is accumulated and returned as a complete message once streaming finishes.
-         *
-         * @param params - Completion parameters including messages and options
-         * @param context - Execution context with inference provider, model, and API key
-         * @returns Promise resolving to accumulated AI response message
+         * Generates complete executable strategy code.
+         * Validates optimizer existence before execution.
          *
-         * @example
-         * ```typescript
-         * const result = await runnerPublicService.getStreamCompletion({
-         *   messages: [
-         *     { role: "user", content: "Generate trading signal for ETH/USDT" }
-         *   ]
-         * }, {
-         *   inference: InferenceName.GPT5Inference,
-         *   model: "gpt-5o-mini",
-         *   apiKey: "sk-..."
-         * });
-         * ```
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @returns Generated TypeScript/JavaScript code as string
+         * @throws Error if optimizer not found
          */
-        this.getStreamCompletion = async (params, context) => {
-            this.loggerService.log("runnerPublicService getStreamCompletion");
-            return await ContextService.runInContext(async () => {
-                return await this.runnerPrivateService.getStreamCompletion(params);
-            }, context);
+        this.getCode = async (symbol, optimizerName) => {
+            this.loggerService.log(METHOD_NAME_GET_CODE, {
+                symbol,
+                optimizerName,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_GET_CODE);
+            return await this.optimizerConnectionService.getCode(symbol, optimizerName);
         };
         /**
-         * Executes a structured outline completion within the specified context.
-         *
-         * Uses structured output (JSON schema validation) to ensure the AI response
-         * conforms to a predefined format. Ideal for extracting structured data
-         * from AI responses (e.g., trading signals with specific fields).
-         *
-         * @param params - Outline completion parameters including messages and schema
-         * @param context - Execution context with inference provider, model, and API key
-         * @returns Promise resolving to structured AI response
+         * Generates and saves strategy code to file.
+         * Validates optimizer existence before execution.
          *
-         * @example
-         * ```typescript
-         * const signal = await runnerPublicService.getOutlineCompletion({
-         *   messages: [
-         *     { role: "user", content: "Decide position for BTC/USDT" }
-         *   ]
-         * }, {
-         *   inference: InferenceName.DeepseekInference,
-         *   model: "deepseek-chat",
-         *   apiKey: "sk-..."
-         * });
-         * // Returns: { position: "long", price_open: 50000, ... }
-         * ```
+         * @param symbol - Trading pair symbol
+         * @param optimizerName - Optimizer identifier
+         * @param path - Output directory path (optional)
+         * @throws Error if optimizer not found
          */
-        this.getOutlineCompletion = async (params, context) => {
-            this.loggerService.log("runnerPublicService getOutlineCompletion");
-            return await ContextService.runInContext(async () => {
-                return await this.runnerPrivateService.getOutlineCompletion(params);
-            }, context);
+        this.dump = async (symbol, optimizerName, path) => {
+            this.loggerService.log(METHOD_NAME_DUMP, {
+                symbol,
+                optimizerName,
+                path,
+            });
+            this.optimizerValidationService.validate(optimizerName, METHOD_NAME_DUMP);
+            return await this.optimizerConnectionService.dump(symbol, optimizerName, path);
         };
     }
 }
@@ -855,6 +2493,22 @@ class RunnerPublicService {
     provide(TYPES.runnerPublicService, () => new RunnerPublicService());
     provide(TYPES.outlinePublicService, () => new OutlinePublicService());
 }
+{
+    provide(TYPES.signalPromptService, () => new SignalPromptService());
+}
+{
+    provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
+}
+/**
+ * Register optimizer services.
+ */
+{
+    provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
+    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
+    provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
+    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
+    provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
+}
 
 /**
  * Enumeration of supported LLM inference providers.
@@ -924,7 +2578,7 @@ var InferenceName$1 = InferenceName;
  * ```
  */
 const getGrok = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getGrok.clear();
         throw new Error("Grok provider does not support token rotation");
@@ -1654,7 +3308,7 @@ class OllamaWrapper {
     constructor(_config) {
         this._config = _config;
         /** Round-robin chat function factory */
-        this._chatFn = RoundRobin.create(lib.contextService.context.apiKey, (token) => {
+        this._chatFn = RoundRobin.create(engine$1.contextService.context.apiKey, (token) => {
             const ollama = new Ollama({
                 ...this._config,
                 headers: {
@@ -1670,7 +3324,7 @@ class OllamaWrapper {
                 }
             };
         });
-        if (!lib.contextService.context.apiKey) {
+        if (!engine$1.contextService.context.apiKey) {
             throw new Error("OllamaRotate required apiKey[] to process token rotation");
         }
     }
@@ -1755,7 +3409,7 @@ const getOllamaRotate = singleshot(() => new OllamaWrapper({
  * ```
  */
 const getOllama = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         return getOllamaRotate();
     }
@@ -2149,7 +3803,7 @@ class OllamaProvider {
  * ```
  */
 const getClaude = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getClaude.clear();
         throw new Error("Claude provider does not support token rotation");
@@ -2492,7 +4146,7 @@ class ClaudeProvider {
  * ```
  */
 const getOpenAi = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getOpenAi.clear();
         throw new Error("OpenAI provider does not support token rotation");
@@ -2843,7 +4497,7 @@ class GPT5Provider {
  * ```
  */
 const getDeepseek = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getDeepseek.clear();
         throw new Error("Deepseek provider does not support token rotation");
@@ -3165,7 +4819,7 @@ class DeepseekProvider {
  * ```
  */
 const getMistral = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getMistral.clear();
         throw new Error("Mistral provider does not support token rotation");
@@ -3487,7 +5141,7 @@ class MistralProvider {
  * ```
  */
 const getPerplexity = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getPerplexity.clear();
         throw new Error("Perplexity provider does not support token rotation");
@@ -3767,7 +5421,7 @@ class PerplexityProvider {
  * ```
  */
 const getCohere = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getCohere.clear();
         throw new Error("Cohere provider does not support token rotation");
@@ -4437,7 +6091,7 @@ class AlibabaProvider {
  * ```
  */
 const getZAi = singleshot(() => {
-    const apiKey = lib.contextService.context.apiKey;
+    const apiKey = engine$1.contextService.context.apiKey;
     if (Array.isArray(apiKey)) {
         getZAi.clear();
         throw new Error("Z.ai provider does not support token rotation");
@@ -4855,6 +6509,19 @@ const publicServices = {
     runnerPublicService: inject(TYPES.runnerPublicService),
     outlinePublicService: inject(TYPES.outlinePublicService),
 };
+const promptServices = {
+    signalPromptService: inject(TYPES.signalPromptService),
+};
+const markdownServices = {
+    outlineMarkdownService: inject(TYPES.outlineMarkdownService),
+};
+const optimizerServices = {
+    optimizerTemplateService: inject(TYPES.optimizerTemplateService),
+    optimizerSchemaService: inject(TYPES.optimizerSchemaService),
+    optimizerValidationService: inject(TYPES.optimizerValidationService),
+    optimizerConnectionService: inject(TYPES.optimizerConnectionService),
+    optimizerGlobalService: inject(TYPES.optimizerGlobalService),
+};
 /**
  * Main engine object containing all services.
  * Provides unified access to the entire service layer.
@@ -4864,6 +6531,9 @@ const engine = {
     ...baseServices,
     ...privateServices,
     ...publicServices,
+    ...promptServices,
+    ...markdownServices,
+    ...optimizerServices,
 };
 // Initialize DI container
 init();
@@ -4885,7 +6555,7 @@ init();
 }
 // Make engine globally accessible for debugging
 Object.assign(globalThis, { engine });
-var lib = engine;
+var engine$1 = engine;
 
 const INFERENCE_TIMEOUT$2 = 35000;
 const LOCAL_RUNNER_FN$2 = timeout(async (params) => {
@@ -5217,7 +6887,7 @@ addOutline({
  *
  * @throws Error if validation fails (missing or duplicate registrations)
  */
-validate({
+validate$1({
     CompletionName: CompletionName$1,
     OutlineName: OutlineName$1,
 });
@@ -5242,7 +6912,7 @@ validate({
  * ```
  */
 const ollama = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.OllamaInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.OllamaInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Grok models.
@@ -5263,7 +6933,7 @@ const ollama = async (messages, model, apiKey) => {
  * ```
  */
 const grok = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.GrokInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.GrokInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Hugging Face models.
@@ -5283,7 +6953,7 @@ const grok = async (messages, model, apiKey) => {
  * ```
  */
 const hf = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.HfInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.HfInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Claude models.
@@ -5304,7 +6974,7 @@ const hf = async (messages, model, apiKey) => {
  * ```
  */
 const claude = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.ClaudeInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.ClaudeInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from OpenAI GPT models.
@@ -5325,7 +6995,7 @@ const claude = async (messages, model, apiKey) => {
  * ```
  */
 const gpt5 = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.GPT5Inference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.GPT5Inference, model, apiKey);
 };
 /**
  * Generate structured trading signal from DeepSeek models.
@@ -5346,7 +7016,7 @@ const gpt5 = async (messages, model, apiKey) => {
  * ```
  */
 const deepseek = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.DeepseekInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.DeepseekInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Mistral AI models.
@@ -5367,7 +7037,7 @@ const deepseek = async (messages, model, apiKey) => {
  * ```
  */
 const mistral = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.MistralInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.MistralInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Perplexity AI models.
@@ -5388,7 +7058,7 @@ const mistral = async (messages, model, apiKey) => {
  * ```
  */
 const perplexity = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.PerplexityInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.PerplexityInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Cohere models.
@@ -5409,7 +7079,7 @@ const perplexity = async (messages, model, apiKey) => {
  * ```
  */
 const cohere = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.CohereInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.CohereInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Alibaba Cloud Qwen models.
@@ -5430,7 +7100,7 @@ const cohere = async (messages, model, apiKey) => {
  * ```
  */
 const alibaba = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.AlibabaInference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.AlibabaInference, model, apiKey);
 };
 /**
  * Generate structured trading signal from Zhipu AI GLM-4 models.
@@ -5454,7 +7124,7 @@ const alibaba = async (messages, model, apiKey) => {
  * ```
  */
 const glm4 = async (messages, model, apiKey) => {
-    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.GLM4Inference, model, apiKey);
+    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.GLM4Inference, model, apiKey);
 };
 
 /**
@@ -5475,7 +7145,7 @@ const glm4 = async (messages, model, apiKey) => {
  * ```
  */
 const setLogger = (logger) => {
-    lib.loggerService.setLogger(logger);
+    engine$1.loggerService.setLogger(logger);
 };
 
 /**
@@ -5536,4 +7206,520 @@ function overrideSignalFormat(format) {
     });
 }
 
-export { alibaba, claude, cohere, deepseek, glm4, gpt5, grok, hf, engine as lib, mistral, ollama, overrideSignalFormat, perplexity, setLogger };
+const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
+/**
+ * Dumps signal data and LLM conversation history to markdown files.
+ * Used by AI-powered strategies to save debug logs for analysis.
+ *
+ * Creates a directory structure with:
+ * - 00_system_prompt.md - System messages and output summary
+ * - XX_user_message.md - Each user message in separate file (numbered)
+ * - XX_llm_output.md - Final LLM output with signal data
+ *
+ * Skips if directory already exists to avoid overwriting previous results.
+ *
+ * @param signalId - Unique identifier for the result (used as directory name, e.g., UUID)
+ * @param history - Array of message models from LLM conversation
+ * @param signal - Signal DTO returned by LLM (position, priceOpen, TP, SL, etc.)
+ * @param outputDir - Output directory path (default: "./dump/strategy")
+ * @returns Promise that resolves when all files are written
+ *
+ * @example
+ * ```typescript
+ * import { dumpSignal, getCandles } from "backtest-kit";
+ * import { v4 as uuid } from "uuid";
+ *
+ * addStrategy({
+ *   strategyName: "llm-strategy",
+ *   interval: "5m",
+ *   getSignal: async (symbol) => {
+ *     const messages = [];
+ *
+ *     // Build multi-timeframe analysis conversation
+ *     const candles1h = await getCandles(symbol, "1h", 24);
+ *     messages.push(
+ *       { role: "user", content: `Analyze 1h trend:\n${formatCandles(candles1h)}` },
+ *       { role: "assistant", content: "Trend analyzed" }
+ *     );
+ *
+ *     const candles5m = await getCandles(symbol, "5m", 24);
+ *     messages.push(
+ *       { role: "user", content: `Analyze 5m structure:\n${formatCandles(candles5m)}` },
+ *       { role: "assistant", content: "Structure analyzed" }
+ *     );
+ *
+ *     // Request signal
+ *     messages.push({
+ *       role: "user",
+ *       content: "Generate trading signal. Use position: 'wait' if uncertain."
+ *     });
+ *
+ *     const resultId = uuid();
+ *     const signal = await llmRequest(messages);
+ *
+ *     // Save conversation and result for debugging
+ *     await dumpSignal(resultId, messages, signal);
+ *
+ *     return signal;
+ *   }
+ * });
+ *
+ * // Creates: ./dump/strategy/{uuid}/00_system_prompt.md
+ * //          ./dump/strategy/{uuid}/01_user_message.md (1h analysis)
+ * //          ./dump/strategy/{uuid}/02_assistant_message.md
+ * //          ./dump/strategy/{uuid}/03_user_message.md (5m analysis)
+ * //          ./dump/strategy/{uuid}/04_assistant_message.md
+ * //          ./dump/strategy/{uuid}/05_user_message.md (signal request)
+ * //          ./dump/strategy/{uuid}/06_llm_output.md (final signal)
+ * ```
+ */
+async function dumpSignalData(signalId, history, signal, outputDir = "./dump/strategy") {
+    engine$1.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
+        signalId,
+        history,
+        signal,
+        outputDir,
+    });
+    return await engine$1.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
+}
+
+const METHOD_NAME = "validate.validate";
+/**
+ * Retrieves all registered optimizers as a map
+ * @private
+ * @returns Map of optimizer names
+ */
+const getOptimizerMap = async () => {
+    const optimizerMap = {};
+    for (const { optimizerName } of await engine$1.optimizerValidationService.list()) {
+        Object.assign(optimizerMap, { [optimizerName]: optimizerName });
+    }
+    return optimizerMap;
+};
+/**
+ * Internal validation function that processes all provided entity enums.
+ *
+ * Iterates through each enum's values and validates them against their
+ * respective validation services. Uses memoized validation for performance.
+ *
+ * If entity enums are not provided, fetches all registered entities from
+ * their respective validation services and validates them.
+ *
+ * @private
+ * @param args - Validation arguments containing entity name enums
+ * @throws {Error} If any entity name is not found in its registry
+ */
+const validateInternal = async (args) => {
+    const { OptimizerName = await getOptimizerMap(), } = args;
+    for (const optimizerName of Object.values(OptimizerName)) {
+        engine$1.optimizerValidationService.validate(optimizerName, METHOD_NAME);
+    }
+};
+/**
+ * Validates the existence of all provided entity names across validation services.
+ *
+ * This function accepts enum objects for various entity types (exchanges, frames,
+ * strategies, risks, sizings, optimizers, walkers) and validates that each entity
+ * name exists in its respective registry. Validation results are memoized for performance.
+ *
+ * If no arguments are provided (or specific entity types are omitted), the function
+ * automatically fetches and validates ALL registered entities from their respective
+ * validation services. This is useful for comprehensive validation of the entire setup.
+ *
+ * Use this before running backtests or optimizations to ensure all referenced
+ * entities are properly registered and configured.
+ *
+ * @public
+ * @param args - Partial validation arguments containing entity name enums to validate.
+ *                If empty or omitted, validates all registered entities.
+ * @throws {Error} If any entity name is not found in its validation service
+ *
+ * @example
+ * ```typescript
+ * // Validate ALL registered entities (exchanges, frames, strategies, etc.)
+ * await validate({});
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Define your entity name enums
+ * enum ExchangeName {
+ *   BINANCE = "binance",
+ *   BYBIT = "bybit"
+ * }
+ *
+ * enum StrategyName {
+ *   MOMENTUM_BTC = "momentum-btc"
+ * }
+ *
+ * // Validate specific entities before running backtest
+ * await validate({
+ *   ExchangeName,
+ *   StrategyName,
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Validate specific entity types
+ * await validate({
+ *   RiskName: { CONSERVATIVE: "conservative" },
+ *   SizingName: { FIXED_1000: "fixed-1000" },
+ * });
+ * ```
+ */
+async function validate(args = {}) {
+    engine$1.loggerService.log(METHOD_NAME);
+    return await validateInternal(args);
+}
+
+const METHOD_NAME_SIGNAL = "history.commitSignalPromptHistory";
+/**
+ * Commits signal prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds signal-specific system prompts at the beginning and user prompt
+ * at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitSignalPromptHistory("BTCUSDT", messages);
+ * // messages now contains system prompts at start and user prompt at end
+ * ```
+ */
+async function commitSignalPromptHistory(symbol, history) {
+    engine$1.loggerService.log(METHOD_NAME_SIGNAL, {
+        symbol,
+    });
+    const { strategyName, exchangeName, frameName } = await getContext();
+    const mode = await getMode();
+    const isBacktest = mode === "backtest";
+    const systemPrompts = await engine$1.signalPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await engine$1.signalPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+
+const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizerSchema";
+/**
+ * Registers an optimizer configuration in the framework.
+ *
+ * The optimizer generates trading strategies by:
+ * - Collecting data from multiple sources across training periods
+ * - Building LLM conversation history with fetched data
+ * - Generating strategy prompts using getPrompt()
+ * - Creating executable backtest code with templates
+ *
+ * The optimizer produces a complete .mjs file containing:
+ * - Exchange, Frame, Strategy, and Walker configurations
+ * - Multi-timeframe analysis logic
+ * - LLM integration for signal generation
+ * - Event listeners for progress tracking
+ *
+ * @param optimizerSchema - Optimizer configuration object
+ * @param optimizerSchema.optimizerName - Unique optimizer identifier
+ * @param optimizerSchema.rangeTrain - Array of training time ranges (each generates a strategy variant)
+ * @param optimizerSchema.rangeTest - Testing time range for strategy validation
+ * @param optimizerSchema.source - Array of data sources (functions or source objects with custom formatters)
+ * @param optimizerSchema.getPrompt - Function to generate strategy prompt from conversation history
+ * @param optimizerSchema.template - Optional custom template overrides (top banner, helpers, strategy logic, etc.)
+ * @param optimizerSchema.callbacks - Optional lifecycle callbacks (onData, onCode, onDump, onSourceData)
+ *
+ * @example
+ * ```typescript
+ * // Basic optimizer with single data source
+ * addOptimizerSchema({
+ *   optimizerName: "llm-strategy-generator",
+ *   rangeTrain: [
+ *     {
+ *       note: "Bull market period",
+ *       startDate: new Date("2024-01-01"),
+ *       endDate: new Date("2024-01-31"),
+ *     },
+ *     {
+ *       note: "Bear market period",
+ *       startDate: new Date("2024-02-01"),
+ *       endDate: new Date("2024-02-28"),
+ *     },
+ *   ],
+ *   rangeTest: {
+ *     note: "Validation period",
+ *     startDate: new Date("2024-03-01"),
+ *     endDate: new Date("2024-03-31"),
+ *   },
+ *   source: [
+ *     {
+ *       name: "historical-backtests",
+ *       fetch: async ({ symbol, startDate, endDate, limit, offset }) => {
+ *         // Fetch historical backtest results from database
+ *         return await db.backtests.find({
+ *           symbol,
+ *           date: { $gte: startDate, $lte: endDate },
+ *         })
+ *         .skip(offset)
+ *         .limit(limit);
+ *       },
+ *       user: async (symbol, data, name) => {
+ *         return `Analyze these ${data.length} backtest results for ${symbol}:\n${JSON.stringify(data)}`;
+ *       },
+ *       assistant: async (symbol, data, name) => {
+ *         return "Historical data analyzed successfully";
+ *       },
+ *     },
+ *   ],
+ *   getPrompt: async (symbol, messages) => {
+ *     // Generate strategy prompt from conversation
+ *     return `"Analyze ${symbol} using RSI and MACD. Enter LONG when RSI < 30 and MACD crosses above signal."`;
+ *   },
+ *   callbacks: {
+ *     onData: (symbol, strategyData) => {
+ *       console.log(`Generated ${strategyData.length} strategies for ${symbol}`);
+ *     },
+ *     onCode: (symbol, code) => {
+ *       console.log(`Generated ${code.length} characters of code for ${symbol}`);
+ *     },
+ *     onDump: (symbol, filepath) => {
+ *       console.log(`Saved strategy to ${filepath}`);
+ *     },
+ *     onSourceData: (symbol, sourceName, data, startDate, endDate) => {
+ *       console.log(`Fetched ${data.length} rows from ${sourceName} for ${symbol}`);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+function addOptimizerSchema(optimizerSchema) {
+    engine$1.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
+        optimizerSchema,
+    });
+    engine$1.optimizerValidationService.addOptimizer(optimizerSchema.optimizerName, optimizerSchema);
+    engine$1.optimizerSchemaService.register(optimizerSchema.optimizerName, optimizerSchema);
+}
+
+/**
+ * Subscribe to optimizer progress events.
+ * Receives updates during optimizer execution with progress percentage.
+ *
+ * @param callback - Function called on each progress update
+ * @returns Unsubscribe function
+ *
+ * @example
+ * ```typescript
+ * const unsub = listenOptimizerProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`Processed: ${event.processedSources} / ${event.totalSources}`);
+ * });
+ * // Later: unsub();
+ * ```
+ */
+function listenOptimizerProgress(callback) {
+    return progressOptimizerEmitter.subscribe(callback);
+}
+/**
+ * Subscribe to error events.
+ * Receives errors from optimizer operations.
+ *
+ * @param callback - Function called on each error
+ * @returns Unsubscribe function
+ *
+ * @example
+ * ```typescript
+ * const unsub = listenError((error) => {
+ *   console.error("Error occurred:", error);
+ * });
+ * // Later: unsub();
+ * ```
+ */
+function listenError(callback) {
+    return errorEmitter.subscribe(callback);
+}
+
+const GET_OPTIMIZER_METHOD_NAME = "get.getOptimizerSchema";
+/**
+ * Retrieves a registered optimizer schema by name.
+ *
+ * @param optimizerName - Unique optimizer identifier
+ * @returns The optimizer schema configuration object
+ * @throws Error if optimizer is not registered
+ *
+ * @example
+ * ```typescript
+ * const optimizer = getOptimizer("llm-strategy-generator");
+ * console.log(optimizer.rangeTrain); // Array of training ranges
+ * console.log(optimizer.rangeTest); // Testing range
+ * console.log(optimizer.source); // Array of data sources
+ * console.log(optimizer.getPrompt); // async function
+ * ```
+ */
+function getOptimizerSchema(optimizerName) {
+    engine$1.loggerService.log(GET_OPTIMIZER_METHOD_NAME, {
+        optimizerName,
+    });
+    engine$1.optimizerValidationService.validate(optimizerName, GET_OPTIMIZER_METHOD_NAME);
+    return engine$1.optimizerSchemaService.get(optimizerName);
+}
+
+const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizerSchema";
+/**
+ * Returns a list of all registered optimizer schemas.
+ *
+ * Retrieves all optimizers that have been registered via addOptimizer().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of optimizer schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listOptimizers, addOptimizer } from "backtest-kit";
+ *
+ * addOptimizer({
+ *   optimizerName: "llm-strategy-generator",
+ *   note: "Generates trading strategies using LLM",
+ *   rangeTrain: [
+ *     {
+ *       note: "Training period 1",
+ *       startDate: new Date("2024-01-01"),
+ *       endDate: new Date("2024-01-31"),
+ *     },
+ *   ],
+ *   rangeTest: {
+ *     note: "Testing period",
+ *     startDate: new Date("2024-02-01"),
+ *     endDate: new Date("2024-02-28"),
+ *   },
+ *   source: [],
+ *   getPrompt: async (symbol, messages) => "Generate strategy",
+ * });
+ *
+ * const optimizers = listOptimizers();
+ * console.log(optimizers);
+ * // [{ optimizerName: "llm-strategy-generator", note: "Generates...", ... }]
+ * ```
+ */
+async function listOptimizerSchema() {
+    engine$1.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
+    return await engine$1.optimizerValidationService.list();
+}
+
+const OPTIMIZER_METHOD_NAME_GET_DATA = "OptimizerUtils.getData";
+const OPTIMIZER_METHOD_NAME_GET_CODE = "OptimizerUtils.getCode";
+const OPTIMIZER_METHOD_NAME_DUMP = "OptimizerUtils.dump";
+/**
+ * Public API utilities for optimizer operations.
+ * Provides high-level methods for strategy generation and code export.
+ *
+ * Usage:
+ * ```typescript
+ * import { Optimizer } from "@backtest-kit/ollama";
+ *
+ * // Get strategy data
+ * const strategies = await Optimizer.getData("BTCUSDT", {
+ *   optimizerName: "my-optimizer"
+ * });
+ *
+ * // Generate code
+ * const code = await Optimizer.getCode("BTCUSDT", {
+ *   optimizerName: "my-optimizer"
+ * });
+ *
+ * // Save to file
+ * await Optimizer.dump("BTCUSDT", {
+ *   optimizerName: "my-optimizer"
+ * }, "./output");
+ * ```
+ */
+class OptimizerUtils {
+    constructor() {
+        /**
+         * Fetches data from all sources and generates strategy metadata.
+         * Processes each training range and builds LLM conversation history.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with optimizerName
+         * @returns Array of generated strategies with conversation context
+         * @throws Error if optimizer not found
+         */
+        this.getData = async (symbol, context) => {
+            engine$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
+            engine$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_DATA);
+            return await engine$1.optimizerGlobalService.getData(symbol, context.optimizerName);
+        };
+        /**
+         * Generates complete executable strategy code.
+         * Includes imports, helpers, strategies, walker, and launcher.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with optimizerName
+         * @returns Generated TypeScript/JavaScript code as string
+         * @throws Error if optimizer not found
+         */
+        this.getCode = async (symbol, context) => {
+            engine$1.loggerService.info(OPTIMIZER_METHOD_NAME_GET_CODE, {
+                symbol,
+                context,
+            });
+            engine$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_GET_CODE);
+            return await engine$1.optimizerGlobalService.getCode(symbol, context.optimizerName);
+        };
+        /**
+         * Generates and saves strategy code to file.
+         * Creates directory if needed, writes .mjs file.
+         *
+         * Format: `{optimizerName}_{symbol}.mjs`
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with optimizerName
+         * @param path - Output directory path (default: "./")
+         * @throws Error if optimizer not found or file write fails
+         */
+        this.dump = async (symbol, context, path) => {
+            engine$1.loggerService.info(OPTIMIZER_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
+            engine$1.optimizerValidationService.validate(context.optimizerName, OPTIMIZER_METHOD_NAME_DUMP);
+            await engine$1.optimizerGlobalService.dump(symbol, context.optimizerName, path);
+        };
+    }
+}
+/**
+ * Singleton instance of OptimizerUtils.
+ * Public API for optimizer operations.
+ *
+ * @example
+ * ```typescript
+ * import { Optimizer } from "@backtest-kit/ollama";
+ *
+ * await Optimizer.dump("BTCUSDT", { optimizerName: "my-optimizer" });
+ * ```
+ */
+const Optimizer = new OptimizerUtils();
+
+export { Optimizer, addOptimizerSchema, alibaba, claude, cohere, commitSignalPromptHistory, deepseek, dumpSignalData, getOptimizerSchema, glm4, gpt5, grok, hf, engine as lib, listOptimizerSchema, listenError, listenOptimizerProgress, mistral, ollama, overrideSignalFormat, perplexity, setLogger, validate };