@backtest-kit/ollama 0.2.0 → 1.0.0

package/build/index.mjs

@@ -1,14 +1,14 @@
-import { json, event, validateToolArguments, RoundRobin, addCompletion, addOutline, validate as validate$1, overrideOutline } from 'agent-swarm-kit';
+import { event, validateToolArguments, RoundRobin, addCompletion } 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 { createRequire } from 'module';
+import { createActivator } from 'di-kit';
+import { memoize, ToolRegistry, Subject, trycatch, errorData, getErrorMessage, iterateDocuments, distinctDocuments, resolveDocuments, singleshot, randomString, fetchApi, str, timeout } from 'functools-kit';
+import { Markdown, getSymbol, getContext, getMode } from 'backtest-kit';
 import MarkdownIt from 'markdown-it';
 import sanitizeHtml from 'sanitize-html';
 import { lint } from 'markdownlint/promise';
 import { applyFixes } from 'markdownlint';
-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';
@@ -18,8 +18,6 @@ import { InferenceClient } from '@huggingface/inference';
 import { ChatOpenAI } from '@langchain/openai';
 import { get, set } from 'lodash-es';
 import { Ollama } from 'ollama';
-import { zodResponseFormat } from 'openai/helpers/zod';
-import { z } from 'zod';
 
 /**
  * Enumeration of completion strategy types.
@@ -43,7 +41,6 @@ var CompletionName;
     /** Outline completion mode (structured JSON with schema validation) */
     CompletionName["RunnerOutlineCompletion"] = "runner_outline_completion";
 })(CompletionName || (CompletionName = {}));
-var CompletionName$1 = CompletionName;
 
 /**
  * Scoped context service for isolated execution contexts.
@@ -218,14 +215,6 @@ class LoggerService {
  */
 const { provide, inject, init, override } = createActivator("ollama");
 
-/**
- * Common service type identifiers.
- * Services used across the entire application.
- */
-const commonServices$1 = {
-    /** Logger service for application-wide logging */
-    loggerService: Symbol("loggerService"),
-};
 /**
  * Base service type identifiers.
  * Core foundational services.
@@ -233,6 +222,7 @@ const commonServices$1 = {
 const baseServices$1 = {
     /** Context service for scoped execution contexts */
     contextService: Symbol('contextService'),
+    loggerService: Symbol("loggerService"),
 };
 /**
  * Private service type identifiers.
@@ -241,8 +231,6 @@ const baseServices$1 = {
 const privateServices$1 = {
     /** Runner private service for AI provider operations */
     runnerPrivateService: Symbol('runnerPrivateService'),
-    /** Outline private service for structured completions */
-    outlinePrivateService: Symbol('outlinePrivateService'),
 };
 /**
  * Public service type identifiers.
@@ -251,20 +239,29 @@ const privateServices$1 = {
 const publicServices$1 = {
     /** Runner public service for context-managed AI operations */
     runnerPublicService: Symbol('runnerPublicService'),
-    /** Outline public service for simplified structured completions */
-    outlinePublicService: Symbol('outlinePublicService'),
 };
 const promptServices$1 = {
-    signalPromptService: Symbol('signalPromptService'),
+    resolvePromptService: Symbol('resolvePromptService'),
+};
+const cacheServices$1 = {
+    promptCacheService: Symbol('promptCacheService'),
 };
 const markdownServices$1 = {
     outlineMarkdownService: Symbol('outlineMarkdownService'),
 };
-const optimizerServices$1 = {
+const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
+};
+const schemaServices$1 = {
     optimizerSchemaService: Symbol('optimizerSchemaService'),
+};
+const validationServices$1 = {
     optimizerValidationService: Symbol('optimizerValidationService'),
+};
+const connectionServices$1 = {
     optimizerConnectionService: Symbol('optimizerConnectionService'),
+};
+const globalServices$1 = {
     optimizerGlobalService: Symbol('optimizerGlobalService'),
 };
 /**
@@ -283,15 +280,66 @@ const optimizerServices$1 = {
  * ```
  */
 const TYPES = {
-    ...commonServices$1,
     ...baseServices$1,
     ...promptServices$1,
+    ...cacheServices$1,
     ...markdownServices$1,
-    ...optimizerServices$1,
+    ...templateServices$1,
+    ...schemaServices$1,
+    ...validationServices$1,
+    ...connectionServices$1,
+    ...globalServices$1,
     ...privateServices$1,
     ...publicServices$1,
 };
 
+const PROMPT_TYPE_SYMBOL = Symbol("prompt-type");
+class Prompt {
+    constructor(source) {
+        this.source = source;
+        this.__type__ = PROMPT_TYPE_SYMBOL;
+    }
+}
+Prompt.fromPrompt = (source) => {
+    if (!source || typeof source !== "object") {
+        throw new Error("Source must be a valid PromptModel object");
+    }
+    return new Prompt(source);
+};
+Prompt.isPrompt = (value) => {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.__type__ === PROMPT_TYPE_SYMBOL);
+};
+
+const require = createRequire(import.meta.url);
+const REQUIRE_MODULE_FN = memoize(([module]) => module, (module) => {
+    const modulePath = require.resolve(join(module.baseDir, module.path));
+    return require(modulePath);
+});
+class PromptCacheService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.readModule = (module) => {
+            this.loggerService.log("promptCacheService readModule", {
+                path: module.path,
+                baseDir: module.baseDir,
+            });
+            const source = REQUIRE_MODULE_FN(module);
+            return Prompt.fromPrompt(source);
+        };
+        this.clear = (module) => {
+            this.loggerService.log("promptCacheService clear", {
+                module,
+            });
+            if (module) {
+                REQUIRE_MODULE_FN.clear(module);
+            }
+            REQUIRE_MODULE_FN.clear();
+        };
+    }
+}
+
 /**
  * Warning threshold for message size in kilobytes.
  * Messages exceeding this size trigger console warnings.
@@ -448,203 +496,6 @@ class OutlineMarkdownService {
     }
 }
 
-/**
- * Enumeration of supported JSON schema outlines.
- *
- * Defines unique identifiers for structured output schemas used with
- * LLM providers. Outlines enforce JSON schema validation for critical
- * data structures like trading signals.
- *
- * @example
- * ```typescript
- * import { OutlineName } from '@backtest-kit/ollama';
- *
- * const outlineName = OutlineName.SignalOutline;
- * ```
- */
-var OutlineName;
-(function (OutlineName) {
-    /** Trading signal JSON schema for position, TP/SL, and risk parameters */
-    OutlineName["SignalOutline"] = "signal_outline";
-})(OutlineName || (OutlineName = {}));
-var OutlineName$1 = OutlineName;
-
-/**
- * Lints and auto-fixes markdown content using markdownlint rules.
- *
- * Validates markdown syntax and applies automatic fixes for common issues
- * like inconsistent list markers, trailing spaces, and heading styles.
- * Returns the original content if no errors found or fixes cannot be applied.
- *
- * @param content - Raw markdown content to lint
- * @returns Promise resolving to linted markdown content
- *
- * @example
- * ```typescript
- * const markdown = "# Title\n\n\n## Subtitle"; // Multiple blank lines
- * const linted = await toLintMarkdown(markdown);
- * // Returns: "# Title\n\n## Subtitle" (extra blank line removed)
- * ```
- */
-const toLintMarkdown = async (content) => {
-    if (!content) {
-        return "";
-    }
-    const { content: errors } = await lint({ strings: { content } });
-    if (!errors.length) {
-        return content;
-    }
-    const value = applyFixes(content, errors);
-    return value ? value : content;
-};
-
-/**
- * Converts markdown content to plain text with Telegram-compatible HTML formatting.
- *
- * Processes markdown through three stages:
- * 1. Lints and fixes markdown using markdownlint
- * 2. Renders markdown to HTML using markdown-it
- * 3. Sanitizes HTML to Telegram-compatible subset
- *
- * Supported tags: b, i, a, code, pre, s, u, tg-spoiler, blockquote, br
- * Transforms: headings removed, lists to bullets, multiple newlines collapsed
- *
- * @param content - Raw markdown content
- * @returns Promise resolving to sanitized plain text with HTML formatting
- *
- * @example
- * ```typescript
- * const markdown = "# Title\n**Bold** and *italic*\n- Item 1\n- Item 2";
- * const plain = await toPlainString(markdown);
- * // Returns: "Bold and italic\n• Item 1\n• Item 2"
- * ```
- */
-const toPlainString = async (content) => {
-    if (!content) {
-        return "";
-    }
-    const markdown = await toLintMarkdown(content);
-    const md = new MarkdownIt({
-        html: false,
-        breaks: true,
-        linkify: true,
-        typographer: true,
-    });
-    let telegramHtml = md.render(markdown);
-    telegramHtml = sanitizeHtml(telegramHtml, {
-        allowedTags: [
-            "b",
-            "i",
-            "a",
-            "code",
-            "pre",
-            "s",
-            "u",
-            "tg-spoiler",
-            "blockquote",
-            "br",
-        ],
-        allowedAttributes: {
-            a: ["href"],
-        },
-        transformTags: {
-            h1: "",
-            h2: "",
-            h3: "",
-            h4: "",
-            h5: "",
-            h6: "",
-            a: "",
-            strong: "",
-            em: "",
-            p: () => "",
-            ul: () => "",
-            li: () => "• ",
-            ol: () => "",
-            hr: () => "\n",
-            br: () => "\n",
-            div: () => "",
-        },
-    });
-    return telegramHtml.replaceAll(/\n[\s\n]*\n/g, "\n").trim();
-};
-
-/**
- * Private service for processing structured outline completions.
- *
- * Handles the core logic for executing outline-based AI completions with schema validation.
- * Processes AI responses through the agent-swarm-kit json function to extract and validate
- * structured trading signal data.
- *
- * Key features:
- * - JSON schema validation using agent-swarm-kit
- * - Trading signal extraction and transformation
- * - Type conversion for numeric fields
- * - Markdown formatting cleanup for notes
- * - Error handling for validation failures
- *
- * @example
- * ```typescript
- * const outlinePrivate = inject<OutlinePrivateService>(TYPES.outlinePrivateService);
- * const signal = await outlinePrivate.getCompletion([
- *   { role: "user", content: "Analyze market" }
- * ]);
- * ```
- */
-class OutlinePrivateService {
-    constructor() {
-        /** Logger service for operation tracking */
-        this.loggerService = inject(TYPES.loggerService);
-        /**
-         * Processes outline completion messages and extracts structured signal data.
-         *
-         * Sends messages to the AI provider, validates the response against the signal schema,
-         * and transforms the data into a structured format. Returns null if the AI decides
-         * to wait (no position).
-         *
-         * @param messages - Array of conversation messages for the AI
-         * @returns Promise resolving to structured signal data or null if position is "wait"
-         * @throws Error if validation fails or AI returns an error
-         *
-         * @example
-         * ```typescript
-         * const signal = await outlinePrivateService.getCompletion([
-         *   { role: "system", content: "Trading analyst role" },
-         *   { role: "user", content: "Market analysis data..." }
-         * ]);
-         *
-         * if (signal) {
-         *   console.log(`Position: ${signal.position}`);
-         *   console.log(`Entry: ${signal.priceOpen}`);
-         *   console.log(`SL: ${signal.priceStopLoss}`);
-         *   console.log(`TP: ${signal.priceTakeProfit}`);
-         * }
-         * ```
-         */
-        this.getCompletion = async (messages) => {
-            this.loggerService.log("outlinePrivateService getCompletion", {
-                messages,
-            });
-            const { data, resultId, error } = await json(OutlineName$1.SignalOutline, messages);
-            if (error) {
-                throw new Error(error);
-            }
-            if (data.position === "wait") {
-                return null;
-            }
-            return {
-                id: resultId,
-                position: data.position,
-                minuteEstimatedTime: +data.minute_estimated_time,
-                priceStopLoss: +data.price_stop_loss,
-                priceTakeProfit: +data.price_take_profit,
-                note: await toPlainString(data.risk_note),
-                priceOpen: data.price_open ? +data.price_open : undefined,
-            };
-        };
-    }
-}
-
 /**
  * Private service managing AI inference provider registry and execution.
  *
@@ -765,47 +616,19 @@ 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.
+ * Provides access to system and user prompts from Prompt.
  * 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 {
+class ResolvePromptService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         /**
@@ -816,6 +639,7 @@ class SignalPromptService {
          * - Async/sync function returning string array (executed and awaited)
          * - Undefined (returns empty array)
          *
+         * @param prompt - Prompt containing the loaded module
          * @param symbol - Trading symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -823,15 +647,15 @@ class SignalPromptService {
          * @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", {
+        this.getSystemPrompt = async (prompt, symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("resolvePromptService getSystemPrompt", {
                 symbol,
                 strategyName,
                 exchangeName,
                 frameName,
                 backtest,
             });
-            const { system } = GET_PROMPT_FN();
+            const { system } = prompt.source;
             if (Array.isArray(system)) {
                 return system;
             }
@@ -843,6 +667,7 @@ class SignalPromptService {
         /**
          * Retrieves user prompt string for AI input.
          *
+         * @param prompt - Prompt containing the loaded module
          * @param symbol - Trading symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -850,15 +675,15 @@ class SignalPromptService {
          * @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", {
+        this.getUserPrompt = async (prompt, symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("resolvePromptService getUserPrompt", {
                 symbol,
                 strategyName,
                 exchangeName,
                 frameName,
                 backtest,
             });
-            const { user } = GET_PROMPT_FN();
+            const { user } = prompt.source;
             if (typeof user === "string") {
                 return user;
             }
@@ -870,92 +695,6 @@ class SignalPromptService {
     }
 }
 
-/**
- * Public-facing service for structured AI outline completions.
- *
- * Provides a simplified interface for executing structured AI completions with schema validation.
- * Handles context creation and isolation for outline-based operations.
- * Used for extracting structured data from AI responses (e.g., trading signals).
- *
- * Key features:
- * - Simplified API with automatic context management
- * - JSON schema validation for structured outputs
- * - Support for multiple AI providers
- * - Optional API key parameter with fallback
- * - Logging integration
- *
- * @example
- * ```typescript
- * import { engine } from "./lib";
- * import { InferenceName } from "./enum/InferenceName";
- *
- * const signal = await engine.outlinePublicService.getCompletion(
- *   [{ role: "user", content: "Analyze BTC/USDT and decide position" }],
- *   InferenceName.ClaudeInference,
- *   "claude-3-5-sonnet-20240620",
- *   "sk-ant-..."
- * );
- *
- * // Returns structured signal:
- * // {
- * //   position: "long",
- * //   priceOpen: 50000,
- * //   priceStopLoss: 48000,
- * //   priceTakeProfit: 52000,
- * //   minuteEstimatedTime: 120,
- * //   note: "Strong bullish momentum..."
- * // }
- * ```
- */
-class OutlinePublicService {
-    constructor() {
-        /** Logger service for operation tracking */
-        this.loggerService = inject(TYPES.loggerService);
-        /** Private service handling outline completion logic */
-        this.outlinePrivateService = inject(TYPES.outlinePrivateService);
-        /**
-         * Executes a structured outline completion with schema validation.
-         *
-         * Creates an isolated execution context and processes messages through the AI provider
-         * to generate a structured response conforming to a predefined schema.
-         *
-         * @param messages - Array of conversation messages for the AI
-         * @param inference - AI provider identifier
-         * @param model - Model name/identifier
-         * @param apiKey - Optional API key(s), required for most providers
-         * @returns Promise resolving to structured signal data or null if position is "wait"
-         *
-         * @example
-         * ```typescript
-         * const result = await outlinePublicService.getCompletion(
-         *   [
-         *     { role: "system", content: "You are a trading analyst" },
-         *     { role: "user", content: "Analyze current BTC market" }
-         *   ],
-         *   InferenceName.DeepseekInference,
-         *   "deepseek-chat",
-         *   "sk-..."
-         * );
-         * ```
-         */
-        this.getCompletion = async (messages, inference, model, apiKey) => {
-            this.loggerService.log("outlinePublicService getCompletion", {
-                messages,
-                model,
-                apiKey,
-                inference,
-            });
-            return await ContextService.runInContext(async () => {
-                return await this.outlinePrivateService.getCompletion(messages);
-            }, {
-                apiKey: apiKey,
-                inference,
-                model,
-            });
-        };
-    }
-}
-
 /**
  * Public-facing service for AI inference operations with context management.
  *
@@ -1093,6 +832,106 @@ class RunnerPublicService {
     }
 }
 
+/**
+ * Lints and auto-fixes markdown content using markdownlint rules.
+ *
+ * Validates markdown syntax and applies automatic fixes for common issues
+ * like inconsistent list markers, trailing spaces, and heading styles.
+ * Returns the original content if no errors found or fixes cannot be applied.
+ *
+ * @param content - Raw markdown content to lint
+ * @returns Promise resolving to linted markdown content
+ *
+ * @example
+ * ```typescript
+ * const markdown = "# Title\n\n\n## Subtitle"; // Multiple blank lines
+ * const linted = await toLintMarkdown(markdown);
+ * // Returns: "# Title\n\n## Subtitle" (extra blank line removed)
+ * ```
+ */
+const toLintMarkdown = async (content) => {
+    if (!content) {
+        return "";
+    }
+    const { content: errors } = await lint({ strings: { content } });
+    if (!errors.length) {
+        return content;
+    }
+    const value = applyFixes(content, errors);
+    return value ? value : content;
+};
+
+/**
+ * Converts markdown content to plain text with Telegram-compatible HTML formatting.
+ *
+ * Processes markdown through three stages:
+ * 1. Lints and fixes markdown using markdownlint
+ * 2. Renders markdown to HTML using markdown-it
+ * 3. Sanitizes HTML to Telegram-compatible subset
+ *
+ * Supported tags: b, i, a, code, pre, s, u, tg-spoiler, blockquote, br
+ * Transforms: headings removed, lists to bullets, multiple newlines collapsed
+ *
+ * @param content - Raw markdown content
+ * @returns Promise resolving to sanitized plain text with HTML formatting
+ *
+ * @example
+ * ```typescript
+ * const markdown = "# Title\n**Bold** and *italic*\n- Item 1\n- Item 2";
+ * const plain = await toPlainString(markdown);
+ * // Returns: "Bold and italic\n• Item 1\n• Item 2"
+ * ```
+ */
+const toPlainString = async (content) => {
+    if (!content) {
+        return "";
+    }
+    const markdown = await toLintMarkdown(content);
+    const md = new MarkdownIt({
+        html: false,
+        breaks: true,
+        linkify: true,
+        typographer: true,
+    });
+    let telegramHtml = md.render(markdown);
+    telegramHtml = sanitizeHtml(telegramHtml, {
+        allowedTags: [
+            "b",
+            "i",
+            "a",
+            "code",
+            "pre",
+            "s",
+            "u",
+            "tg-spoiler",
+            "blockquote",
+            "br",
+        ],
+        allowedAttributes: {
+            a: ["href"],
+        },
+        transformTags: {
+            h1: "",
+            h2: "",
+            h3: "",
+            h4: "",
+            h5: "",
+            h6: "",
+            a: "",
+            strong: "",
+            em: "",
+            p: () => "",
+            ul: () => "",
+            li: () => "• ",
+            ol: () => "",
+            hr: () => "\n",
+            br: () => "\n",
+            div: () => "",
+        },
+    });
+    return telegramHtml.replaceAll(/\n[\s\n]*\n/g, "\n").trim();
+};
+
 /**
  * Default template service for generating optimizer code snippets.
  * Implements all IOptimizerTemplate methods with Ollama LLM integration.
@@ -2467,46 +2306,62 @@ class OptimizerGlobalService {
  * This file is imported by lib/index.ts to ensure services are registered
  * before the DI container is initialized.
  */
-/**
- * Register common services.
- */
-{
-    provide(TYPES.loggerService, () => new LoggerService());
-}
 /**
  * Register base services.
  */
 {
     provide(TYPES.contextService, () => new ContextService());
+    provide(TYPES.loggerService, () => new LoggerService());
 }
 /**
  * Register private services.
  */
 {
     provide(TYPES.runnerPrivateService, () => new RunnerPrivateService());
-    provide(TYPES.outlinePrivateService, () => new OutlinePrivateService());
 }
 /**
  * Register public services.
  */
 {
     provide(TYPES.runnerPublicService, () => new RunnerPublicService());
-    provide(TYPES.outlinePublicService, () => new OutlinePublicService());
 }
 {
-    provide(TYPES.signalPromptService, () => new SignalPromptService());
+    provide(TYPES.resolvePromptService, () => new ResolvePromptService());
+}
+{
+    provide(TYPES.promptCacheService, () => new PromptCacheService());
 }
 {
     provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
 }
 /**
- * Register optimizer services.
+ * Register template services.
  */
 {
     provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
+}
+/**
+ * Register schema services.
+ */
+{
     provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
+}
+/**
+ * Register validation services.
+ */
+{
     provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
+}
+/**
+ * Register connection services.
+ */
+{
     provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
+}
+/**
+ * Register global services.
+ */
+{
     provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
 }
 
@@ -6483,43 +6338,47 @@ class GLM4Provider {
  * );
  * ```
  */
-/**
- * Common service instances.
- */
-const commonServices = {
-    loggerService: inject(TYPES.loggerService),
-};
 /**
  * Base service instances.
  */
 const baseServices = {
     contextService: inject(TYPES.contextService),
+    loggerService: inject(TYPES.loggerService),
 };
 /**
  * Private service instances.
  */
 const privateServices = {
     runnerPrivateService: inject(TYPES.runnerPrivateService),
-    outlinePrivateService: inject(TYPES.outlinePrivateService),
 };
 /**
  * Public service instances.
  */
 const publicServices = {
     runnerPublicService: inject(TYPES.runnerPublicService),
-    outlinePublicService: inject(TYPES.outlinePublicService),
 };
 const promptServices = {
-    signalPromptService: inject(TYPES.signalPromptService),
+    resolvePromptService: inject(TYPES.resolvePromptService),
+};
+const cacheServices = {
+    promptCacheService: inject(TYPES.promptCacheService),
 };
 const markdownServices = {
     outlineMarkdownService: inject(TYPES.outlineMarkdownService),
 };
-const optimizerServices = {
+const templateServices = {
     optimizerTemplateService: inject(TYPES.optimizerTemplateService),
+};
+const schemaServices = {
     optimizerSchemaService: inject(TYPES.optimizerSchemaService),
+};
+const validationServices = {
     optimizerValidationService: inject(TYPES.optimizerValidationService),
+};
+const connectionServices = {
     optimizerConnectionService: inject(TYPES.optimizerConnectionService),
+};
+const globalServices = {
     optimizerGlobalService: inject(TYPES.optimizerGlobalService),
 };
 /**
@@ -6527,13 +6386,17 @@ const optimizerServices = {
  * Provides unified access to the entire service layer.
  */
 const engine = {
-    ...commonServices,
     ...baseServices,
     ...privateServices,
     ...publicServices,
     ...promptServices,
+    ...cacheServices,
     ...markdownServices,
-    ...optimizerServices,
+    ...templateServices,
+    ...schemaServices,
+    ...validationServices,
+    ...connectionServices,
+    ...globalServices,
 };
 // Initialize DI container
 init();
@@ -6685,446 +6548,356 @@ addCompletion({
 });
 
 /**
- * Zod schema for trading signal structured output.
+ * Wrap async function with Ollama inference context.
  *
- * Defines the JSON schema used for LLM-generated trading signals with
- * comprehensive field descriptions and validation rules. Used with outline
- * completion to enforce structured output from language models.
+ * Creates a higher-order function that executes the provided async function
+ * within an Ollama inference context. Supports token rotation by passing multiple API keys.
  *
- * Fields:
- * - position: Trading direction (long/short/wait)
- * - price_open: Entry price in USD
- * - price_stop_loss: Stop-loss price in USD
- * - price_take_profit: Take-profit price in USD
- * - minute_estimated_time: Estimated hold duration in minutes
- * - risk_note: Detailed risk assessment with specific metrics
- *
- * @example
- * ```typescript
- * import { SignalSchema } from './schema/Signal.schema';
- *
- * const signal = SignalSchema.parse({
- *   position: 'long',
- *   price_open: 50000,
- *   price_stop_loss: 49000,
- *   price_take_profit: 52000,
- *   minute_estimated_time: 120,
- *   risk_note: 'RSI oversold at 32%, volume spike +45%'
- * });
- * ```
- */
-const SignalSchema = z.object({
-    position: z
-        .enum(["long", "short", "wait"])
-        .describe(str.newline("Position direction (ALWAYS required):", "long: market shows consistent bullish signals, uptrend or growth potential", "short: market shows consistent bearish signals, downtrend or decline potential", "wait: conflicting signals between timeframes OR unfavorable trading conditions")),
-    price_open: z
-        .number()
-        .describe(str.newline("Position entry price in USD", "Can be either:", "- Current market price for immediate entry (market order)", "- Price above/below market to open a limit order and wait for its resolve before entering")),
-    price_stop_loss: z
-        .number()
-        .describe(str.newline("Stop-loss price in USD", "For LONG: price below price_open (protection against decline)", "For SHORT: price above price_open (protection against rise)", "NEVER set SL in 'empty space' without technical justification")),
-    price_take_profit: z
-        .number()
-        .describe(str.newline("Take-profit price in USD", "For LONG: price above price_open (growth target)", "For SHORT: price below price_open (decline target)", "NEVER set TP based on trend without technical justification")),
-    minute_estimated_time: z
-        .number()
-        .describe(str.newline("Estimated time to reach Take Profit in minutes", "Calculated based on HONEST technical analysis, using:", "ATR, ADX, MACD, Momentum, Slope and other metrics")),
-    risk_note: z
-        .string()
-        .describe(str.newline("Description of current market situation risks:", "", "Analyze and specify applicable risks:", "1. Whale manipulations (volume spikes, long shadows, pin bars, candle engulfing, false breakouts)", "2. Order book (order book walls, spoofing, bid/ask imbalance, low liquidity)", "3. P&L history (recurring mistakes on similar patterns)", "4. Time factors (trading session, low liquidity, upcoming events)", "5. Correlations (overall market trend, conflicting trends across timeframes)", "6. Technical risks (indicator divergences, weak volumes, critical levels)", "7. Gaps and anomalies (price gaps, unfilled gaps, movements without volume)", "", "Provide SPECIFIC numbers, percentages and probabilities.")),
-});
-
-/**
- * Trading signal outline schema registration.
- *
- * Registers a structured outline for trading signal generation with comprehensive
- * validation rules. This outline enforces a strict schema for AI-generated trading
- * signals, ensuring all required fields are present and correctly formatted.
- *
- * Schema fields:
- * - position: Trading direction ("long", "short", or "wait")
- * - price_open: Entry price for the position
- * - price_stop_loss: Stop-loss price level
- * - price_take_profit: Take-profit price level
- * - minute_estimated_time: Estimated time to reach TP (in minutes)
- * - risk_note: Risk assessment and reasoning (markdown format)
- *
- * Validation rules:
- * 1. All required fields must be present
- * 2. Prices must be positive numbers
- * 3. For LONG: SL < entry < TP
- * 4. For SHORT: TP < entry < SL
- * 5. Estimated time must be <= 360 minutes (6 hours)
- * 6. Wait position skips price validations
- *
- * @example
- * ```typescript
- * import { json } from "agent-swarm-kit";
- * import { OutlineName } from "./enum/OutlineName";
- *
- * const { data } = await json(OutlineName.SignalOutline, [
- *   { role: "user", content: "Analyze BTC/USDT and decide position" }
- * ]);
- *
- * if (data.position !== "wait") {
- *   console.log(`Position: ${data.position}`);
- *   console.log(`Entry: ${data.price_open}`);
- *   console.log(`SL: ${data.price_stop_loss}`);
- *   console.log(`TP: ${data.price_take_profit}`);
- * }
- * ```
- */
-addOutline({
-    outlineName: OutlineName.SignalOutline,
-    completion: CompletionName.RunnerOutlineCompletion,
-    format: zodResponseFormat(SignalSchema, "position_open_decision"),
-    getOutlineHistory: async ({ history, param: messages = [] }) => {
-        await history.push(messages);
-    },
-    validations: [
-        {
-            validate: ({ data }) => {
-                if (!data.position) {
-                    throw new Error("The position field is not filled");
-                }
-            },
-            docDescription: "Validates that position direction (long/short/wait) is specified.",
-        },
-        {
-            validate: ({ data }) => {
-                if (!data.risk_note) {
-                    throw new Error("The risk_note field is not filled");
-                }
-            },
-            docDescription: "Validates that risk description is provided.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position !== "wait" &&
-                    (!data.price_open || data.price_open <= 0)) {
-                    throw new Error("When position='long' or 'short', the price_open field is required and must be positive");
-                }
-            },
-            docDescription: "Validates that opening price is specified and positive when opening a position.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position !== "wait" &&
-                    (!data.price_stop_loss || data.price_stop_loss <= 0)) {
-                    throw new Error("When position='long' or 'short', the price_stop_loss field is required and must be positive");
-                }
-            },
-            docDescription: "Validates that stop-loss is specified when opening a position.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position !== "wait" &&
-                    (!data.price_take_profit || data.price_take_profit <= 0)) {
-                    throw new Error("When position='long' or 'short', the price_take_profit field is required and must be positive");
-                }
-            },
-            docDescription: "Validates that take-profit is specified when opening a position.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position === "long" && data.price_open && data.price_stop_loss && data.price_take_profit) {
-                    if (data.price_stop_loss >= data.price_open) {
-                        throw new Error("For LONG position, price_stop_loss must be below price_open");
-                    }
-                    if (data.price_take_profit <= data.price_open) {
-                        throw new Error("For LONG position, price_take_profit must be above price_open");
-                    }
-                }
-            },
-            docDescription: "Validates price correctness for LONG position.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position === "short" && data.price_open && data.price_stop_loss && data.price_take_profit) {
-                    if (data.price_stop_loss <= data.price_open) {
-                        throw new Error("For SHORT position, price_stop_loss must be above price_open");
-                    }
-                    if (data.price_take_profit >= data.price_open) {
-                        throw new Error("For SHORT position, price_take_profit must be below price_open");
-                    }
-                }
-            },
-            docDescription: "Validates price correctness for SHORT position.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position !== "wait" &&
-                    (!data.minute_estimated_time || data.minute_estimated_time <= 0)) {
-                    throw new Error("When position='long' or 'short', the minute_estimated_time field is required and must be positive");
-                }
-            },
-            docDescription: "Validates that estimated time to TP is specified when opening a position.",
-        },
-        {
-            validate: ({ data }) => {
-                if (data.position !== "wait" && data.minute_estimated_time > 360) {
-                    throw new Error("Estimated time to reach TP exceeds 6 hours (360 minutes). Use position='wait' for low volatility conditions");
-                }
-            },
-            docDescription: "Validates that estimated time to reach TP does not exceed 6 hours.",
-        },
-    ],
-});
-
-/**
- * Bootstrap module for agent-swarm-kit validation.
- *
- * Validates that all completion and outline names are properly registered
- * with agent-swarm-kit before the application starts. This ensures that
- * all referenced completions and outlines exist and are correctly configured.
- *
- * Validation checks:
- * - All CompletionName enum values have corresponding registered handlers
- * - All OutlineName enum values have corresponding registered schemas
- * - No duplicate registrations exist
- *
- * This file is imported by index.ts to run validation at startup.
- *
- * @throws Error if validation fails (missing or duplicate registrations)
- */
-validate$1({
-    CompletionName: CompletionName$1,
-    OutlineName: OutlineName$1,
-});
-
-/**
- * Generate structured trading signal from Ollama models.
- *
- * Supports token rotation by passing multiple API keys. Automatically enforces
- * the signal JSON schema defined in Signal.schema.ts.
- *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Ollama model name (e.g., "llama3.3:70b")
  * @param apiKey - Single API key or array of keys for rotation
- * @returns Promise resolving to structured trading signal
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { ollama } from '@backtest-kit/ollama';
  *
- * const signal = await ollama(messages, 'llama3.3:70b', ['key1', 'key2']);
- * console.log(signal.position); // "long" | "short" | "wait"
+ * const wrappedFn = ollama(myAsyncFn, 'llama3.3:70b', ['key1', 'key2']);
+ * const result = await wrappedFn(args);
  * ```
  */
-const ollama = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.OllamaInference, model, apiKey);
+const ollama = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.OllamaInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Grok models.
+ * Wrap async function with Grok inference context.
  *
- * Uses xAI Grok models through direct API access. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within a Grok (xAI) inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Grok model name (e.g., "grok-beta")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { grok } from '@backtest-kit/ollama';
  *
- * const signal = await grok(messages, 'grok-beta', process.env.GROK_API_KEY);
+ * const wrappedFn = grok(myAsyncFn, 'grok-beta', process.env.GROK_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const grok = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.GrokInference, model, apiKey);
+const grok = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.GrokInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Hugging Face models.
+ * Wrap async function with HuggingFace inference context.
  *
- * Uses HuggingFace Router API for model access. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within a HuggingFace Router API inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
- * @param model - HuggingFace model name
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
+ * @template T - Async function type
+ * @param fn - Async function to wrap
+ * @param model - HuggingFace model name (e.g., "meta-llama/Llama-3-70b")
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { hf } from '@backtest-kit/ollama';
  *
- * const signal = await hf(messages, 'meta-llama/Llama-3-70b', process.env.HF_API_KEY);
+ * const wrappedFn = hf(myAsyncFn, 'meta-llama/Llama-3-70b', process.env.HF_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const hf = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.HfInference, model, apiKey);
+const hf = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.HfInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Claude models.
+ * Wrap async function with Claude inference context.
  *
- * Uses Anthropic Claude through OpenAI-compatible API. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within an Anthropic Claude inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Claude model name (e.g., "claude-3-5-sonnet-20241022")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { claude } from '@backtest-kit/ollama';
  *
- * const signal = await claude(messages, 'claude-3-5-sonnet-20241022', process.env.ANTHROPIC_API_KEY);
+ * const wrappedFn = claude(myAsyncFn, 'claude-3-5-sonnet-20241022', process.env.ANTHROPIC_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const claude = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.ClaudeInference, model, apiKey);
+const claude = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.ClaudeInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from OpenAI GPT models.
+ * Wrap async function with OpenAI GPT inference context.
  *
- * Uses official OpenAI SDK with JSON schema enforcement. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within an OpenAI GPT inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - OpenAI model name (e.g., "gpt-4o", "gpt-4-turbo")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { gpt5 } from '@backtest-kit/ollama';
  *
- * const signal = await gpt5(messages, 'gpt-4o', process.env.OPENAI_API_KEY);
+ * const wrappedFn = gpt5(myAsyncFn, 'gpt-4o', process.env.OPENAI_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const gpt5 = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.GPT5Inference, model, apiKey);
+const gpt5 = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.GPT5Inference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from DeepSeek models.
+ * Wrap async function with DeepSeek inference context.
  *
- * Uses DeepSeek AI through OpenAI-compatible API. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within a DeepSeek AI inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - DeepSeek model name (e.g., "deepseek-chat")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { deepseek } from '@backtest-kit/ollama';
  *
- * const signal = await deepseek(messages, 'deepseek-chat', process.env.DEEPSEEK_API_KEY);
+ * const wrappedFn = deepseek(myAsyncFn, 'deepseek-chat', process.env.DEEPSEEK_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const deepseek = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.DeepseekInference, model, apiKey);
+const deepseek = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.DeepseekInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Mistral AI models.
+ * Wrap async function with Mistral AI inference context.
  *
- * Uses Mistral AI through OpenAI-compatible API. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within a Mistral AI inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Mistral model name (e.g., "mistral-large-latest")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { mistral } from '@backtest-kit/ollama';
  *
- * const signal = await mistral(messages, 'mistral-large-latest', process.env.MISTRAL_API_KEY);
+ * const wrappedFn = mistral(myAsyncFn, 'mistral-large-latest', process.env.MISTRAL_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const mistral = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.MistralInference, model, apiKey);
+const mistral = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.MistralInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Perplexity AI models.
+ * Wrap async function with Perplexity AI inference context.
  *
- * Uses Perplexity AI through OpenAI-compatible API. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within a Perplexity AI inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Perplexity model name (e.g., "llama-3.1-sonar-huge-128k-online")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { perplexity } from '@backtest-kit/ollama';
  *
- * const signal = await perplexity(messages, 'llama-3.1-sonar-huge-128k-online', process.env.PERPLEXITY_API_KEY);
+ * const wrappedFn = perplexity(myAsyncFn, 'llama-3.1-sonar-huge-128k-online', process.env.PERPLEXITY_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const perplexity = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.PerplexityInference, model, apiKey);
+const perplexity = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.PerplexityInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Cohere models.
+ * Wrap async function with Cohere inference context.
  *
- * Uses Cohere AI through OpenAI-compatible API. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within a Cohere AI inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Cohere model name (e.g., "command-r-plus")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { cohere } from '@backtest-kit/ollama';
  *
- * const signal = await cohere(messages, 'command-r-plus', process.env.COHERE_API_KEY);
+ * const wrappedFn = cohere(myAsyncFn, 'command-r-plus', process.env.COHERE_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const cohere = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.CohereInference, model, apiKey);
+const cohere = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.CohereInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Alibaba Cloud Qwen models.
+ * Wrap async function with Alibaba Qwen inference context.
  *
- * Uses Alibaba DashScope API through direct HTTP requests. Does NOT support token rotation.
+ * Creates a higher-order function that executes the provided async function
+ * within an Alibaba DashScope API inference context.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - Qwen model name (e.g., "qwen-max")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { alibaba } from '@backtest-kit/ollama';
  *
- * const signal = await alibaba(messages, 'qwen-max', process.env.ALIBABA_API_KEY);
+ * const wrappedFn = alibaba(myAsyncFn, 'qwen-max', process.env.ALIBABA_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const alibaba = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.AlibabaInference, model, apiKey);
+const alibaba = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.AlibabaInference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 /**
- * Generate structured trading signal from Zhipu AI GLM-4 models.
+ * Wrap async function with Zhipu AI GLM-4 inference context.
  *
- * Uses Zhipu AI's GLM-4 through OpenAI-compatible Z.ai API. Does NOT support token rotation.
- * GLM-4 is a powerful Chinese language model with strong reasoning capabilities.
+ * Creates a higher-order function that executes the provided async function
+ * within a Zhipu AI GLM-4 inference context via OpenAI-compatible Z.ai API.
  *
- * @param messages - Array of outline messages (user/assistant/system)
+ * @template T - Async function type
+ * @param fn - Async function to wrap
  * @param model - GLM-4 model name (e.g., "glm-4-plus", "glm-4-air")
- * @param apiKey - Single API key (token rotation not supported)
- * @returns Promise resolving to structured trading signal
- * @throws Error if apiKey is an array (token rotation not supported)
+ * @param apiKey - Single API key or array of keys
+ * @returns Wrapped function with same signature as input
  *
  * @example
  * ```typescript
  * import { glm4 } from '@backtest-kit/ollama';
  *
- * const signal = await glm4(messages, 'glm-4-plus', process.env.ZAI_API_KEY);
- * console.log(`Position: ${signal.position}`);
- * console.log(`Entry: ${signal.priceOpen}`);
+ * const wrappedFn = glm4(myAsyncFn, 'glm-4-plus', process.env.ZAI_API_KEY);
+ * const result = await wrappedFn(args);
  * ```
  */
-const glm4 = async (messages, model, apiKey) => {
-    return await engine$1.outlinePublicService.getCompletion(messages, InferenceName$1.GLM4Inference, model, apiKey);
+const glm4 = (fn, model, apiKey) => {
+    const wrappedFn = async (args) => {
+        return await ContextService.runInContext(async () => {
+            return await fn(...args);
+        }, {
+            apiKey,
+            inference: InferenceName$1.GLM4Inference,
+            model,
+        });
+    };
+    return wrappedFn;
 };
 
 /**
@@ -7148,64 +6921,6 @@ const setLogger = (logger) => {
     engine$1.loggerService.setLogger(logger);
 };
 
-/**
- * Overrides the default signal format schema for LLM-generated trading signals.
- *
- * This function allows customization of the structured output format used by the
- * SignalOutline. It replaces the default signal schema with a custom Zod schema,
- * enabling flexible signal structure definitions while maintaining type safety.
- *
- * The override affects all subsequent signal generation calls using SignalOutline
- * until the application restarts or the schema is overridden again.
- *
- * @template ZodInput - The Zod schema type used for validation and type inference
- *
- * @param {ZodInput} format - Custom Zod schema defining the signal structure.
- *                            Must be a valid Zod type (z.object, z.string, etc.)
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- * import { overrideSignalFormat } from '@backtest-kit/ollama';
- *
- * // Override with custom signal schema
- * const CustomSignalSchema = z.object({
- *   position: z.enum(['long', 'short', 'wait']),
- *   price_open: z.number(),
- *   confidence: z.number().min(0).max(100),
- *   custom_field: z.string()
- * });
- *
- * overrideSignalFormat(CustomSignalSchema);
- * ```
- *
- * @example
- * ```typescript
- * // Override with simplified schema
- * const SimpleSignalSchema = z.object({
- *   action: z.enum(['buy', 'sell', 'hold']),
- *   price: z.number()
- * });
- *
- * overrideSignalFormat(SimpleSignalSchema);
- * ```
- *
- * @remarks
- * - The custom schema replaces the default SignalSchema completely
- * - Schema name in OpenAI format is always "position_open_decision"
- * - Changes persist until application restart or next override
- * - Ensure the custom schema matches your signal processing logic
- *
- * @see {@link SignalSchema} - Default signal schema structure
- * @see {@link OutlineName.SignalOutline} - Outline being overridden
- */
-function overrideSignalFormat(format) {
-    overrideOutline({
-        outlineName: OutlineName$1.SignalOutline,
-        format: zodResponseFormat(format, "position_open_decision"),
-    });
-}
-
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
 /**
  * Dumps signal data and LLM conversation history to markdown files.
@@ -7373,7 +7088,36 @@ async function validate(args = {}) {
     return await validateInternal(args);
 }
 
+const MODULE_TYPE_SYMBOL = Symbol("module-type");
+class Module {
+    constructor(path, baseDir) {
+        this.path = path;
+        this.baseDir = baseDir;
+        this.__type__ = MODULE_TYPE_SYMBOL;
+    }
+}
+Module.fromPath = (path, baseDir = join(process.cwd(), "config/prompt")) => {
+    if (!path || typeof path !== "string" || !path.trim()) {
+        throw new Error("Path must be a non-empty string");
+    }
+    return new Module(path, baseDir);
+};
+Module.isModule = (value) => {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.__type__ === MODULE_TYPE_SYMBOL);
+};
+
 const METHOD_NAME_SIGNAL = "history.commitSignalPromptHistory";
+const GET_PROMPT_FN = async (source) => {
+    if (Prompt.isPrompt(source)) {
+        return source;
+    }
+    if (Module.isModule(source)) {
+        return await engine$1.promptCacheService.readModule(source);
+    }
+    throw new Error("Source must be a Prompt or Module instance");
+};
 /**
  * Commits signal prompt history to the message array.
  *
@@ -7382,40 +7126,40 @@ const METHOD_NAME_SIGNAL = "history.commitSignalPromptHistory";
  * 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
+ * - symbol: From getSymbol()
+ * - backtest mode: From getMode()
+ * - strategyName, exchangeName, frameName: From getContext()
  *
- * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param source - Module object containing path to .cjs module
  * @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) {
+async function commitPrompt(source, history) {
     engine$1.loggerService.log(METHOD_NAME_SIGNAL, {
-        symbol,
+        source,
     });
+    const symbol = await getSymbol();
     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);
+    const prompt = await GET_PROMPT_FN(source);
+    const systemPrompts = await engine$1.resolvePromptService.getSystemPrompt(prompt, symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await engine$1.resolvePromptService.getUserPrompt(prompt, symbol, strategyName, exchangeName, frameName, isBacktest);
     if (systemPrompts.length > 0) {
         for (const content of systemPrompts) {
+            if (!content.trim()) {
+                continue;
+            }
             history.unshift({
                 role: "system",
                 content,
             });
         }
     }
-    if (userPrompt && userPrompt.trim() !== "") {
+    if (userPrompt && userPrompt.trim()) {
         history.push({
             role: "user",
             content: userPrompt,
@@ -7722,4 +7466,4 @@ class OptimizerUtils {
  */
 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 };
+export { CompletionName, Module, Optimizer, Prompt, addOptimizerSchema, alibaba, claude, cohere, commitPrompt, deepseek, dumpSignalData, getOptimizerSchema, glm4, gpt5, grok, hf, engine as lib, listOptimizerSchema, listenError, listenOptimizerProgress, mistral, ollama, perplexity, setLogger, validate };