@backtest-kit/ollama 13.5.0 → 14.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 # 🤖 @backtest-kit/ollama
 
-> Multi-provider LLM context wrapper for trading strategies. Supports 10+ providers with unified HOF API.
+> Universal LLM adapter for [backtest-kit](https://www.npmjs.com/package/backtest-kit) trading strategies. One higher-order-function API across **12 providers**, schema-enforced structured output, userspace prompt modules, token rotation — plus an **LLM strategy optimizer** that generates runnable strategy code.
 
 ![screenshot](https://raw.githubusercontent.com/tripolskypetr/backtest-kit/HEAD/assets/screenshots/screenshot16.png)
 
@@ -10,84 +10,92 @@
 [![npm](https://img.shields.io/npm/v/@backtest-kit/ollama.svg?style=flat-square)](https://npmjs.org/package/@backtest-kit/ollama)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue)]()
 
-Transform technical analysis into trading decisions with multi-provider LLM support, structured output, and built-in risk management.
+📚 **[Docs](https://backtest-kit.github.io/documents/article_07_ai_news_trading_signals.html)** · 🌟 **[Reference implementation](https://github.com/tripolskypetr/backtest-kit/tree/master/example)** · 🐙 **[GitHub](https://github.com/tripolskypetr/backtest-kit)**
 
-📚 **[Backtest Kit Docs](https://backtest-kit.github.io/documents/article_07_ai_news_trading_signals.html)** | 🌟 **[GitHub](https://github.com/tripolskypetr/backtest-kit)**
+```bash
+npm install @backtest-kit/ollama backtest-kit agent-swarm-kit
+```
 
-> **New to backtest-kit?** The fastest way to get a real, production-ready setup is to clone the [reference implementation](https://github.com/tripolskypetr/backtest-kit/tree/master/example) — a fully working news-sentiment AI trading system with LLM forecasting, multi-timeframe data, and a documented February 2026 backtest. Start there instead of from scratch.
+---
 
-## ✨ Features
+## Why
 
-- 🔌 10+ LLM Providers: OpenAI, Claude, DeepSeek, Grok, Mistral, Perplexity, Cohere, Alibaba, Hugging Face, Ollama, GLM-4
-- ⚡ Higher-Order Functions: Wrap async functions with inference context via `di-scoped`
-- 📝 Userspace Prompts: Load prompts from `.cjs` modules in `config/prompt/`
-- 🎯 Userspace Schema: Define your own Zod or JSON schema with `addOutline`
-- 🔄 Token Rotation: Pass array of API keys for automatic rotation
-- 🗄️ Memoized Cache: Prompt modules cached with `memoize` from `functools-kit`
+AI strategies normally mean per-provider SDK boilerplate and JSON you can't trust. This package collapses all of it: wrap any async function with a provider HOF and it runs inside that provider's inference context — swap `deepseek()` → `claude()` → `gpt5()` with no other change. Structured output is schema-enforced (Zod or JSON schema via `agent-swarm-kit`'s `addOutline`), prompts live as memoized userspace modules
 
-## 📦 Installation
+- 🔌 **12 providers** — OpenAI, Claude, DeepSeek, Grok, Groq, Mistral, Perplexity, Cohere, Alibaba, Hugging Face, Ollama (local), GLM-4 (Z.ai).
+- ⚡ **Higher-order functions** — wrap an async fn with inference context via `di-scoped`; same signature in, same out.
+- 🎯 **Userspace schema** — define your own Zod or JSON schema; structured output enforced with auto-retry + custom validations.
+- 📝 **Userspace prompts** — load from `.cjs` modules in `config/prompt/`, or inline; memoized via `functools-kit`.
+- 🔄 **Token rotation** — pass an array of API keys for automatic rotation.
+- 🧬 **Strategy optimizer** — `Optimizer` generates *complete executable strategy code* from LLM analysis across training ranges.
 
-```bash
-npm install @backtest-kit/ollama backtest-kit agent-swarm-kit
+---
+
+## The provider HOF
+
+The whole adapter is one shape, repeated for 12 providers: `provider(fn, model, apiKey?) => fn`. It returns a function with the **same signature** as `fn`, executed inside the provider's inference context (so any `agent-swarm-kit` completion inside resolves to that provider).
+
+```typescript
+import { deepseek } from '@backtest-kit/ollama';
+import { addStrategy } from 'backtest-kit';
+
+addStrategy({
+  strategyName: 'llm-signal', interval: '5m',
+  // swap deepseek() → claude() / gpt5() / ollama() / groq() with no other change
+  getSignal: deepseek(getSignal, 'deepseek-chat', process.env.DEEPSEEK_API_KEY),
+});
 ```
 
-## 🚀 Usage
+<details>
+<summary>All 12 providers, base URLs & token rotation</summary>
+
+| Provider | Function | Inference | Base URL |
+|----------|----------|-----------|----------|
+| OpenAI | `gpt5()` | `gpt5_inference` | `https://api.openai.com/v1/` |
+| Claude | `claude()` | `claude_inference` | `https://api.anthropic.com/v1/` |
+| DeepSeek | `deepseek()` | `deepseek_inference` | `https://api.deepseek.com/` |
+| Grok (xAI) | `grok()` | `grok_inference` | `https://api.x.ai/v1/` |
+| Groq | `groq()` | `groq_inference` | `https://api.groq.com/` |
+| Mistral | `mistral()` | `mistral_inference` | `https://api.mistral.ai/v1/` |
+| Perplexity | `perplexity()` | `perplexity_inference` | `https://api.perplexity.ai/` |
+| Cohere | `cohere()` | `cohere_inference` | `https://api.cohere.ai/compatibility/v1/` |
+| Alibaba (Qwen) | `alibaba()` | `alibaba_inference` | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1/` |
+| Hugging Face | `hf()` | `hf_inference` | `https://router.huggingface.co/v1/` |
+| Ollama (local) | `ollama()` | `ollama_inference` | `http://localhost:11434/` |
+| GLM-4 (Z.ai) | `glm4()` | `glm4_inference` | `https://open.bigmodel.cn/api/paas/v4/` |
+
+```typescript
+// apiKey accepts a single key OR an array → automatic rotation across calls
+const wrappedFn = ollama(myFn, 'llama3.3:70b', ['key1', 'key2', 'key3']);
+```
+
+All twelve share one signature — `<T>(fn: T, model: string, apiKey?: string | string[]) => T` — and run `fn` inside `ContextService.runInContext({ apiKey, inference, model })`. The matching `InferenceName` enum + per-provider `client/*Provider.client.ts` + `config/*.ts` resolve the actual SDK call.
+
+</details>
+
+---
+
+## Structured output
 
-### Signal Schema (userspace)
+Define a schema (Zod or raw JSON), register it as an outline against this package's `CompletionName`, and the LLM is forced to return valid JSON — with custom validations that reject bad signals (e.g. "SL must be below entry for LONG").
+
+<details>
+<summary>Zod outline</summary>
 
 ```typescript
 // schema/Signal.schema.ts
 import { z } from 'zod';
-import { str } from 'functools-kit';
-
 export const SignalSchema = z.object({
-  position: z.enum(['long', 'short', 'wait']).describe(
-    str.newline(
-      'Position direction:',
-      'long: bullish signals, uptrend potential',
-      'short: bearish signals, downtrend potential',
-      'wait: conflicting signals or unfavorable conditions',
-    )
-  ),
-  price_open: z.number().describe(
-    str.newline(
-      'Entry price in USD',
-      'Current market price or limit order price',
-    )
-  ),
-  price_stop_loss: z.number().describe(
-    str.newline(
-      'Stop-loss price in USD',
-      'LONG: below price_open',
-      'SHORT: above price_open',
-    )
-  ),
-  price_take_profit: z.number().describe(
-    str.newline(
-      'Take-profit price in USD',
-      'LONG: above price_open',
-      'SHORT: below price_open',
-    )
-  ),
-  minute_estimated_time: z.number().describe(
-    'Estimated time to reach TP in minutes'
-  ),
-  risk_note: z.string().describe(
-    str.newline(
-      'Risk assessment:',
-      '- Whale manipulations',
-      '- Order book imbalance',
-      '- Technical divergences',
-      'Provide specific numbers and percentages',
-    )
-  ),
+  position: z.enum(['long', 'short', 'wait']).describe('long: bullish · short: bearish · wait: unclear'),
+  price_open: z.number().describe('Entry price in USD'),
+  price_stop_loss: z.number().describe('LONG: below entry · SHORT: above entry'),
+  price_take_profit: z.number().describe('LONG: above entry · SHORT: below entry'),
+  minute_estimated_time: z.number().describe('Estimated minutes to reach TP'),
+  risk_note: z.string().describe('Whale manipulation, order-book imbalance, divergences — with numbers'),
 });
-
 export type TSignalSchema = z.infer<typeof SignalSchema>;
 ```
 
-### Signal Outline with Zod (userspace)
-
 ```typescript
 // outline/signal.outline.ts
 import { addOutline } from 'agent-swarm-kit';
@@ -99,28 +107,22 @@ addOutline<TSignalSchema>({
   outlineName: 'SignalOutline',
   completion: CompletionName.RunnerOutlineCompletion,
   format: zodResponseFormat(SignalSchema, 'position_decision'),
-  getOutlineHistory: async ({ history, param: messages = [] }) => {
-    await history.push(messages);
-  },
-  validations: [
-    {
-      validate: ({ data }) => {
-        if (data.position === 'long' && data.price_stop_loss >= data.price_open) {
-          throw new Error('For LONG, stop_loss must be below price_open');
-        }
-        if (data.position === 'short' && data.price_stop_loss <= data.price_open) {
-          throw new Error('For SHORT, stop_loss must be above price_open');
-        }
-      },
+  getOutlineHistory: async ({ history, param: messages = [] }) => { await history.push(messages); },
+  validations: [{
+    validate: ({ data }) => {
+      if (data.position === 'long'  && data.price_stop_loss >= data.price_open) throw new Error('LONG: SL must be below entry');
+      if (data.position === 'short' && data.price_stop_loss <= data.price_open) throw new Error('SHORT: SL must be above entry');
     },
-  ],
+  }],
 });
 ```
 
-### Signal Outline without Zod (userspace)
+</details>
+
+<details>
+<summary>Raw JSON-schema outline (no Zod)</summary>
 
 ```typescript
-// outline/signal.outline.ts
 import { addOutline, IOutlineFormat } from 'agent-swarm-kit';
 import { CompletionName } from '@backtest-kit/ollama';
 
@@ -128,51 +130,40 @@ const format: IOutlineFormat = {
   type: 'object',
   properties: {
     take_profit_price: { type: 'number', description: 'Take profit price in USD' },
-    stop_loss_price: { type: 'number', description: 'Stop-loss price in USD' },
-    description: { type: 'string', description: 'User-friendly explanation of risks, min 10 sentences' },
-    reasoning: { type: 'string', description: 'Technical analysis, min 15 sentences' },
+    stop_loss_price:   { type: 'number', description: 'Stop-loss price in USD' },
+    description:       { type: 'string', description: 'User-friendly risk explanation, min 10 sentences' },
+    reasoning:         { type: 'string', description: 'Technical analysis, min 15 sentences' },
   },
   required: ['take_profit_price', 'stop_loss_price', 'description', 'reasoning'],
 };
 
 addOutline({
-  outlineName: 'SignalOutline',
-  format,
-  prompt: 'Generate crypto trading signals based on price and volume indicators in JSON format.',
-  completion: CompletionName.RunnerOutlineCompletion,
+  outlineName: 'SignalOutline', format, completion: CompletionName.RunnerOutlineCompletion,
+  prompt: 'Generate crypto trading signals from price & volume indicators in JSON.',
   getOutlineHistory: async ({ history, param }) => {
-    const signalReport = await ioc.signalReportService.getSignalReport(param);
-    await commitReports(history, signalReport);
+    const report = await ioc.signalReportService.getSignalReport(param);
+    await commitReports(history, report);
     await history.push({ role: 'user', content: 'Generate JSON based on reports.' });
   },
   validations: [
-    {
-      validate: ({ data }) => {
-        if (data.action !== 'buy') return;
-        const stopLossChange = percentDiff(data.current_price, data.stop_loss_price);
-        if (stopLossChange > CC_LADDER_STOP_LOSS) {
-          throw new Error(`Stop loss must not exceed -${CC_LADDER_STOP_LOSS}%`);
-        }
-      },
-      docDescription: 'Checks stop-loss price against max loss percentage.',
-    },
-    {
-      validate: ({ data }) => {
-        if (data.action !== 'buy') return;
-        const sellChange = percentDiff(data.current_price, data.take_profit_price);
-        if (sellChange > CC_LADDER_TAKE_PROFIT) {
-          throw new Error(`Take profit must not exceed +${CC_LADDER_TAKE_PROFIT}%`);
-        }
-      },
-      docDescription: 'Checks take-profit price against max profit percentage.',
-    },
+    { docDescription: 'Stop-loss vs max loss %',  validate: ({ data }) => { if (data.action === 'buy' && percentDiff(data.current_price, data.stop_loss_price)   > CC_LADDER_STOP_LOSS)   throw new Error(`SL must not exceed -${CC_LADDER_STOP_LOSS}%`); } },
+    { docDescription: 'Take-profit vs max profit %', validate: ({ data }) => { if (data.action === 'buy' && percentDiff(data.current_price, data.take_profit_price) > CC_LADDER_TAKE_PROFIT) throw new Error(`TP must not exceed +${CC_LADDER_TAKE_PROFIT}%`); } },
   ],
 });
 ```
 
-### Prompt Module (userspace)
+</details>
 
-```typescript
+---
+
+## Prompts
+
+Prompt modules receive trading context automatically. `system` may be a string array or a function of `(symbol, strategyName, exchangeName, frameName, backtest)`; `user` likewise.
+
+<details>
+<summary>Module file, inline prompt & commitPrompt</summary>
+
+```javascript
 // config/prompt/signal.prompt.cjs
 module.exports = {
   system: (symbol, strategyName, exchangeName, frameName, backtest) => [
@@ -180,180 +171,116 @@ module.exports = {
     `Strategy: ${strategyName}, Timeframe: ${frameName}`,
     backtest ? 'Backtest mode' : 'Live mode',
   ],
-  user: (symbol) => `Analyze ${symbol} and return trading decision`,
+  user: (symbol) => `Analyze ${symbol} and return a trading decision`,
 };
 ```
 
-### Strategy
-
 ```typescript
-// strategy.ts
-import './outline/signal.outline'; // register outline
+import { Module, Prompt, commitPrompt, MessageModel } from '@backtest-kit/ollama';
+
+// from a .cjs module (default baseDir: {cwd}/config/prompt/), memoized
+const signalModule = Module.fromPath('./signal.prompt.cjs');
+// or inline
+const inline = Prompt.fromPrompt({ system: ['You are a trading bot'], user: (symbol) => `Trend for ${symbol}?` });
 
+const messages: MessageModel[] = [];
+await commitPrompt(signalModule, messages);   // pushes rendered system + user messages with context
+```
+
+Full strategy: register the outline, build messages from a prompt, request structured JSON, wrap with a provider HOF:
+
+```typescript
+import './outline/signal.outline';
 import { deepseek, Module, commitPrompt, MessageModel } from '@backtest-kit/ollama';
 import { addStrategy } from 'backtest-kit';
 import { json } from 'agent-swarm-kit';
 
 const signalModule = Module.fromPath('./signal.prompt.cjs');
-
 const getSignal = async () => {
   const messages: MessageModel[] = [];
   await commitPrompt(signalModule, messages);
-
   const { data } = await json('SignalOutline', messages);
   return data;
 };
-
-addStrategy({
-  strategyName: 'llm-signal',
-  interval: '5m',
-  getSignal: deepseek(getSignal, 'deepseek-chat', process.env.DEEPSEEK_API_KEY),
-});
+addStrategy({ strategyName: 'llm-signal', interval: '5m',
+  getSignal: deepseek(getSignal, 'deepseek-chat', process.env.DEEPSEEK_API_KEY) });
 ```
 
-### Dynamic Prompt
+</details>
 
-```typescript
-// config/prompt/risk.prompt.cjs
-module.exports = {
-  system: ['You are a risk analyst', 'Be conservative'],
-  user: (symbol, strategyName, exchangeName, frameName, backtest) =>
-    `Evaluate risk for ${symbol} position on ${frameName} timeframe`,
-};
-```
+---
 
-### Inline Prompt
+## Debugging — dump the conversation
 
-```typescript
-import { Prompt, commitPrompt, MessageModel } from '@backtest-kit/ollama';
+`dumpSignalData(signalId, history, signal, outputDir?)` archives the full LLM conversation attached to a signal, so an opaque model decision becomes a readable record. Skips if the directory already exists (never overwrites prior runs).
 
-const prompt = Prompt.fromPrompt({
-  system: ['You are a trading bot'],
-  user: (symbol) => `What is the trend for ${symbol}?`,
-});
+<details>
+<summary>What it writes</summary>
 
-const messages: MessageModel[] = [];
-await commitPrompt(prompt, messages);
-```
+Into `{outputDir}/{signalId}/` (default `./dump/strategy`): `00_system_prompt.md` (system messages + output summary), numbered `XX_user_message.md` / `XX_assistant_message.md` per turn, and a final `XX_llm_output.md` with the signal DTO. Call it from `getSignal` right before returning the signal.
 
-### Token Rotation
+</details>
 
-```typescript
-import { ollama } from '@backtest-kit/ollama';
+---
 
-const wrappedFn = ollama(myFn, 'llama3.3:70b', ['key1', 'key2', 'key3']);
-```
+## Strategy optimizer — generate runnable strategy code
 
-## 🔌 Providers
+The most powerful piece, and the one the rest of the package feeds: `Optimizer` uses an LLM to analyze a symbol across training ranges and emit a **complete, executable strategy file** — imports, helpers, strategies, walker, and launcher — that you can run with backtest-kit directly.
 
-| Provider | Function | Base URL |
-|----------|----------|----------|
-| OpenAI | `gpt5()` | `https://api.openai.com/v1/` |
-| Claude | `claude()` | `https://api.anthropic.com/v1/` |
-| DeepSeek | `deepseek()` | `https://api.deepseek.com/` |
-| Grok | `grok()` | `https://api.x.ai/v1/` |
-| Mistral | `mistral()` | `https://api.mistral.ai/v1/` |
-| Perplexity | `perplexity()` | `https://api.perplexity.ai/` |
-| Cohere | `cohere()` | `https://api.cohere.ai/compatibility/v1/` |
-| Alibaba | `alibaba()` | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1/` |
-| Hugging Face | `hf()` | `https://router.huggingface.co/v1/` |
-| Ollama | `ollama()` | `http://localhost:11434/` |
-| Zhipu AI | `glm4()` | `https://open.bigmodel.cn/api/paas/v4/` |
-
-## 📖 API
-
-### Provider HOF
+<details>
+<summary>Optimizer API + addOptimizerSchema + progress events</summary>
 
 ```typescript
-ollama | gpt5 | claude | deepseek | grok | mistral | perplexity | cohere | alibaba | hf | glm4
-(fn, model, apiKey?) => fn
-```
+import { Optimizer, addOptimizerSchema, listenOptimizerProgress } from '@backtest-kit/ollama';
 
-### Module
-
-```typescript
-Module.fromPath(path: string, baseDir?: string): Module
-```
+// describe sources, training ranges, strategy/template generation (see IOptimizer* interfaces)
+addOptimizerSchema({ optimizerName: 'my-optimizer', /* sources, ranges, strategy, template */ });
 
-Default baseDir: `{cwd}/config/prompt/`
+listenOptimizerProgress((p) => console.log(p)); // ProgressOptimizerContract
 
-### Prompt
-
-```typescript
-Prompt.fromPrompt(source: PromptModel): Prompt
+const strategies = await Optimizer.getData('BTCUSDT', { optimizerName: 'my-optimizer' }); // metadata + LLM context per range
+const code       = await Optimizer.getCode('BTCUSDT', { optimizerName: 'my-optimizer' }); // full TS/JS source as string
+await Optimizer.dump('BTCUSDT', { optimizerName: 'my-optimizer' }, './output');           // writes {optimizerName}_{symbol}.mjs
 ```
 
-### commitPrompt
+`getData` fetches from all sources and builds the LLM conversation per training range; `getCode` assembles the executable strategy; `dump` writes it to `{optimizerName}_{symbol}.mjs`. Companion registry functions: `getOptimizerSchema`, `listOptimizerSchema`, and `listenError`. The engine behind it is `common/ClientOptimizer.ts` driven by the `IOptimizer*` interfaces (`IOptimizerSchema`, `IOptimizerSource`, `IOptimizerStrategy`, `IOptimizerTemplate`, `IOptimizerRange`, `IOptimizerData`, `IOptimizerFetchArgs`, `IOptimizerFilterArgs`, `IOptimizerCallbacks`).
 
-```typescript
-async function commitPrompt(source: Module | Prompt, history: MessageModel[]): Promise<void>
-```
+</details>
 
-### PromptModel
+---
 
-```typescript
-interface PromptModel {
-  system?: string[] | SystemPromptFn;
-  user: string | UserPromptFn;
-}
-
-type SystemPromptFn = (
-  symbol: string,
-  strategyName: string,
-  exchangeName: string,
-  frameName: string,
-  backtest: boolean
-) => Promise<string[]> | string[];
-
-type UserPromptFn = (
-  symbol: string,
-  strategyName: string,
-  exchangeName: string,
-  frameName: string,
-  backtest: boolean
-) => Promise<string> | string;
-```
-
-## 💡 Why Use @backtest-kit/ollama?
-
-Instead of manually integrating LLM SDKs:
-
-**❌ Without ollama (manual work)**
-
-```typescript
-import OpenAI from 'openai';
-import Anthropic from '@anthropic-ai/sdk';
-
-const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
-const response = await openai.chat.completions.create({
-  model: 'gpt-4o',
-  messages,
-  response_format: { type: 'json_object' }
-});
-const signal = JSON.parse(response.choices[0].message.content);
-// ... manual schema validation
-// ... manual error handling
-// ... no fallback
-```
+## API reference
 
-**✅ With ollama (one line)**
+| Export | Description |
+|--------|-------------|
+| `ollama` `gpt5` `claude` `deepseek` `grok` `groq` `mistral` `perplexity` `cohere` `alibaba` `hf` `glm4` | Provider HOFs — `(fn, model, apiKey?) => fn` |
+| `CompletionName` | Completion-name enum for `agent-swarm-kit` outlines (`RunnerOutlineCompletion`, …) |
+| `Module.fromPath(path, baseDir?)` | Load a prompt `.cjs` module (default baseDir `{cwd}/config/prompt/`) |
+| `Prompt.fromPrompt(source)` | Build a prompt from an inline `PromptModel` |
+| `commitPrompt(source, history)` | Render a Module/Prompt's system+user messages into `history` |
+| `dumpSignalData(id, history, signal, dir?)` | Archive the LLM conversation for one signal |
+| `validate(...)` | Validate an outline result |
+| `Optimizer` | `.getData` / `.getCode` / `.dump` — LLM strategy-code generation |
+| `addOptimizerSchema` · `getOptimizerSchema` · `listOptimizerSchema` | Optimizer schema registry |
+| `listenOptimizerProgress` · `listenError` | Optimizer progress / error events |
+| `MessageModel` `MessageRole` `PromptModel` | Message & prompt models |
+| `IOptimizer*` · `ProgressOptimizerContract` | Optimizer interfaces & progress contract |
+| `lib` | The internal engine (IoC container) for advanced use |
 
-```typescript
-const signal = await gpt5(messages, 'gpt-4o');
-```
+<details>
+<summary>Complete source map</summary>
 
-**🔥 Benefits:**
+- `function/signal.function.ts` — the 12 provider HOFs. `function/{add,get,list,event,setup,validate,history,dump,signal}.ts` — registry, events, `setLogger`, `commitPrompt`, `dumpSignalData`.
+- `client/*Provider.client.ts` (12) — per-provider SDK adapters. `config/*.ts` — per-provider base URLs/params, `ollama.rotate.ts` (token rotation), `params.ts`, `emitters.ts`.
+- `classes/` — `Module`, `Prompt`, `Optimizer`. `common/ClientOptimizer.ts` — the optimizer engine.
+- `enum/` — `InferenceName` (12), `CompletionName`. `interface/Optimizer.interface.ts`, `contract/ProgressOptimizer.contract.ts`, `model/{Message,Prompt}.model.ts`.
+- `helpers/{toLintMarkdown,toPlainString}.ts`, `lib/` (IoC: `core/{di,provide,types}`, services). Nothing in `src/` is undocumented.
 
-- ⚡ Unified API across 10+ providers
-- 🎯 Enforced JSON schema (no parsing errors)
-- 🔄 Built-in token rotation (Ollama)
-- 🔑 Context-based API keys
-- 🛡️ Type-safe TypeScript interfaces
-- 📊 Trading-specific output format
+</details>
 
 ## 🤝 Contribute
 
-Fork/PR on [GitHub](https://github.com/tripolskypetr/backtest-kit).
+Fork / PR on [GitHub](https://github.com/tripolskypetr/backtest-kit).
 
 ## 📜 License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtest-kit/ollama",
-  "version": "13.5.0",
+  "version": "14.0.0",
   "description": "Multi-provider LLM inference library for AI-powered trading strategies. Supports 10+ providers including OpenAI, Claude, DeepSeek, Grok, Mistral with unified API and automatic token rotation.",
   "author": {
     "name": "Petr Tripolsky",
@@ -81,24 +81,24 @@
     "ts-morph": "27.0.2",
     "tslib": "2.7.0",
     "typedoc": "0.27.9",
-    "backtest-kit": "13.5.0",
-    "worker-testbed": "2.0.0"
+    "backtest-kit": "14.0.0",
+    "worker-testbed": "2.1.0"
   },
   "peerDependencies": {
     "@huggingface/inference": "^4.7.1",
     "@langchain/core": "^0.3.57",
     "@langchain/xai": "^0.0.2",
-    "backtest-kit": "^13.5.0",
+    "backtest-kit": "^14.0.0",
     "groq-sdk": "^0.37.0",
     "ollama": "^0.6.0",
     "openai": "^4.97.0",
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "agent-swarm-kit": "^2.7.0",
+    "agent-swarm-kit": "^3.2.0",
     "di-kit": "^1.1.1",
     "di-scoped": "^1.0.21",
-    "functools-kit": "^2.3.0",
+    "functools-kit": "^3.0.0",
     "get-moment-stamp": "^2.0.0",
     "jsonrepair": "^3.12.0",
     "markdown-it": "^14.1.0",