changelog.txt

0.14.0 MAR/18/2026
 - feat: Add GPT-5.4 mini and nano OpenAI model support
   - [ADDED] `Model::GPT54Mini` mapped to `"gpt-5.4-mini"`
   - [ADDED] `Model::GPT54Nano` mapped to `"gpt-5.4-nano"`
   - Added `tests/openai_models_tests.rs` to verify enum-to-string mapping and `OpenAIClient::new_with_model_enum()` model selection

0.13.0 MAR/11/2026
Note: historical entries below use the original ThoughtChain / thoughtchaind
names because they describe the repo as it shipped at the time. The project is
now being rebranded to MentisDB / mentisdbd.

 - feat: Deepen ThoughtChain versioning, migration, and registry support
   - ThoughtChain thoughts now carry a schema version and optional signing metadata for future signed-agent workflows
   - Added per-chain agent registries and a global chain registry backing richer `list_chains` and `list_agents` responses
   - `thoughtchaind` now migrates legacy ThoughtChain data on startup before serving traffic
   - New ThoughtChain chains default to binary storage, configurable through `THOUGHTCHAIN_DEFAULT_STORAGE_ADAPTER`
 - feat: Make ThoughtChain's server stack the default crate experience
   - Updated the workspace to consume `thoughtchain 0.2.1` without an explicit `server` feature flag
   - Updated daemon build/run instructions to use `cargo run --bin thoughtchaind`
   - Aligned the launcher script and ThoughtChain REST documentation with the new default
 - feat: Deepen ThoughtChain as an effectively unbounded agent memory primitive
   - Updated CloudLLM positioning and README guidance to present ThoughtChain as a first-class durable memory layer rather than a small persistence helper
   - Documented the standalone `thoughtchaind` daemon more explicitly, including standard MCP, legacy MCP compatibility, REST, and the new retrospective endpoint
 - feat: Add retrospective memory workflow support in ThoughtChain integrations
   - Added support for `ThoughtType::LessonLearned`
   - Added support for `ThoughtRole::Retrospective`
   - Added `thoughtchain_append_retrospective` to the ThoughtChain MCP surface for hard failures, long debugging snags, and non-obvious fixes
   - Added discovery operations for shared ThoughtChain daemons:
     - `thoughtchain_list_chains`
     - `thoughtchain_list_agents`
   - Updated the persistent agent chat example to teach agents when to use retrospective memory instead of ordinary append
 - docs: Expand cross-project ThoughtChain documentation
   - Updated root `README.md`
   - Updated `thoughtchain/README.md` with Qwen Code and GitHub Copilot CLI MCP setup instructions
   - Updated `THOUGHTCHAIN_MCP.md`, `THOUGHTCHAIN_REST.md`, and the ThoughtChain white paper for retrospective memory guidance and the new discovery functions

0.12.0 MAR/11/2026
 - feat: Extract ThoughtChain into a standalone workspace crate
   - Moved semantic memory out of CloudLLM internals into `thoughtchain/`
   - CloudLLM now depends on `thoughtchain` as an external crate instead of an internal module
   - Removed the legacy internal `thought_chain.rs`
   - Preserved append-only, hash-chained memory semantics while redesigning the schema for richer semantic retrieval
 - feat: Restructure the repository as a multi-crate workspace
   - The root repository now contains three Rust crates with clear dependency direction:
     - `cloudllm/` remains the main agent framework crate
     - `thoughtchain/` is the standalone semantic memory and daemon crate
     - `mcp/` is the new shared MCP runtime/protocol crate used by both `cloudllm` and `thoughtchain`
       - Published on crates.io as `cloudllm_mcp` while preserving the in-code crate path `mcp`
   - This removes the old risk of circular dependencies between CloudLLM and ThoughtChain
   - Shared MCP protocol/server/client types now live in `mcp/` instead of being embedded only inside CloudLLM
   - CloudLLM keeps its higher-level agent/tool integrations, while ThoughtChain consumes the shared MCP layer independently
 - feat: World-class ThoughtChain schema and query model
   - Added richer `ThoughtType` taxonomy for semantic agent memory
   - Added `ThoughtRole` to separate semantic meaning from operational lifecycle concerns
   - Added stable thought ids, importance, confidence, tags, concepts, refs, and typed relations in the crate model
   - Added query and export primitives including `MEMORY.md` rendering from ThoughtChain state
   - Added shared-chain agent identity fields and filters: `agent_id`, `agent_name`, `agent_owner`
 - feat: ThoughtChain storage adapter abstraction
   - Introduced a swappable `StorageAdapter` interface in the standalone crate
   - Added `JsonlStorageAdapter` as the default backend
   - Refactored ThoughtChain to be adapter-backed instead of hard-wired to direct JSONL file I/O
   - Updated server head metadata to report a generic `storage_location`
 - feat: Standalone ThoughtChain servers and daemon
   - Added crate-owned MCP server and REST server implementations under `thoughtchain::server`
   - Added `thoughtchaind` binary with env-based configuration:
     - `THOUGHTCHAIN_DIR`
     - `THOUGHTCHAIN_DEFAULT_KEY`
     - `THOUGHTCHAIN_STORAGE_ADAPTER`
     - `THOUGHTCHAIN_BIND_HOST`
     - `THOUGHTCHAIN_MCP_PORT`
     - `THOUGHTCHAIN_REST_PORT`
   - Added REST endpoints for bootstrap, append, search, recent context, memory markdown export, and chain head inspection
   - Moved ThoughtChain MCP implementation out of example-local code and into the crate itself
 - feat: Introduce shared `mcp/` crate for protocol and runtime reuse
   - Extracted reusable MCP-facing protocol types out of CloudLLM into `mcp/`
   - Added shared tool metadata, parameters, results, registry, resource metadata, MCP events, and HTTP runtime utilities
   - Added shared `McpClientProtocol`, `UnifiedMcpServer`, generic `MCPServerBuilder`, `IpFilter`, and `AuthConfig`
   - Refactored CloudLLM MCP modules into compatibility wrappers/re-exports over the new crate
   - Refactored ThoughtChain server metadata/results to use shared `mcp` types instead of local duplicated MCP schema structs
 - feat: Persistent agent chat example backed by ThoughtChain over MCP
   - Added a long-running GPT-5.4 chat example that boots a ThoughtChain on first run
   - The example restores prior context from ThoughtChain and persists new durable memories after each turn
   - When no external ThoughtChain endpoint is provided, it starts an embedded local ThoughtChain MCP server
 - fix: Native multi-tool-call execution in `Agent::send()`
   - Fixed OpenAI-native tool-call loop to execute all tool calls returned in a single assistant message
   - Appends one tool response per `tool_call_id` before requesting the next model turn
   - Prevents HTTP 400 failures caused by unresolved tool calls in provider history
   - Improved session history handling so trimming preserves assistant/tool-call groups atomically
 - docs: Added ThoughtChain protocol documentation
   - Added `THOUGHTCHAIN_MCP.md`
   - Added `THOUGHTCHAIN_REST.md`
   - Documented tool/endpoint contracts, agent usage flow, refs usage, and daemon configuration
 - test: Refreshed CloudLLM integration tests to match current contracts
   - Updated provider-backed tests to skip cleanly on missing API keys, quota exhaustion, and offline/network failures
   - Updated memory/protocol/orchestration/planner/tool integration tests to match current tool metadata and prompt/tool delivery behavior
   - Verified all CloudLLM tests and examples build successfully, including `mcp-server` examples
 - build: Makefile now builds the whole workspace
   - `make build` now builds `cloudllm`, `mcp`, `thoughtchain`, and the `thoughtchaind` binary
   - `make check`, `make clippy`, `make test`, and `make doc` now operate on the workspace rather than only the root crate
   - `make publish` now publishes `cloudllm_mcp`, then `thoughtchain`, then `cloudllm`

0.11.3 MAR/05/2026
 - feat: Add GPT-5.4 model support for OpenAI client
   - [ADDED] Model::GPT54 enum variant mapped to "gpt-5.4"
   - Added match arm in model_to_string() for Model::GPT54

0.11.2 FEB/25/2026
 - maint: Remove deprecated grok-2-image-1212 image generation model
   - [REMOVED] ImageModel::Grok2Image enum variant mapped to deprecated grok-2-image-1212
   - xAI deprecated grok-2-image-1212 model effective FEB/28/2026; now exclusively use grok-imagine-image
   - Simplified ImageModel enum to single GrokImagineImage variant
   - Simplified image_model_to_string() to single pattern match (no breaking change; function is private)
 - docs: Updated README.md Grok Imagine model table from grok-2-image-1212 to grok-imagine-image
 - test: Updated image generation tests to expect grok-imagine-image model name

0.11.1 FEB/20/2026
 - security: Fix 3 Critical and 4 High vulnerabilities (full audit by ai-systems-security-engineer)
   - [CRITICAL] C1: Bearer token auth was dead code — all MCP HTTP endpoints were unauthenticated
     - Added check_auth() wired into all four routes: /tools/list, /tools/execute, /resources/list, /resources/read
     - Extracts and validates Authorization: Bearer <token> header on every request
   - [CRITICAL] C2: IP filter config silently discarded in MCPServerBuilder
     - start_at() always passed allowed_ips: Vec::new() to HttpServerConfig regardless of allow_ip()/allow_cidr() calls
     - Fixed: IpFilter passed through builder → HttpServerConfig → AxumHttpAdapter and evaluated correctly
   - [CRITICAL] C3: Non-timing-safe bearer token comparison enabled timing oracle attack
     - Direct string equality short-circuits on first differing byte; attacker could enumerate tokens character by character
     - Replaced with subtle::ConstantTimeEq (subtle v2 added as direct dep) in both mcp_http_adapter.rs and mcp_server_builder_utils.rs
     - Applied to both Bearer and Basic auth paths
   - [HIGH] H1: SSRF via HttpClientTool — agents could reach loopback, link-local (169.254/16 — AWS IMDS), and RFC-1918 addresses
     - Added is_ssrf_ip() deny-list covering 127/8, 169.254/16, 10/8, 172.16/12, 192.168/16, ::1, fe80::/10, unspecified
     - check_ssrf_blocked() resolves hostname via tokio::task::spawn_blocking (DNS is blocking) before each request
   - [HIGH] H2: HTTP response body fully buffered before size check — OOM DoS possible
     - response.text().await loaded unlimited data into heap before comparing against max_response_size
     - Switched to bytes_stream() + incremental accumulation that aborts immediately when running total exceeds limit
   - [HIGH] H3: FileSystemTool path traversal via symlink escape past root boundary
     - validate_path() used starts_with() before canonicalization, so symlinks inside root pointing outside were not caught
     - Fixed: fully canonicalize existing paths; for non-existent paths walk up to nearest existing ancestor, canonicalize it,
       then reconstruct the non-existent suffix beneath it
     - read_directory_recursive() now canonicalizes each entry and skips any that resolve outside the configured root
   - [HIGH] H4: McpClientProtocol silently swallowed deserialization errors — cache poisoning vector
     - unwrap_or_default() / unwrap_or_else(|_| ToolResult::failure(...)) on serde_json::from_value() masked malformed
       server responses with empty tool lists or phantom successes
     - Replaced with ? propagation returning ToolError::ProtocolError at both tool-list and tool-result deserialization sites

 - security: Harden BashTool — fix absolute-path bypass and enforce output size limit
   - [FIX] Absolute-path denylist bypass: /bin/rm bypassed a denylist entry of "rm"
     - is_command_allowed() now extracts the basename of the first token (strips leading path via rsplit('/'))
     - Checks both the full command string and the basename; closes /bin/rm, ./rm, ../bin/rm, etc.
   - [FIX] max_output_size was declared but never enforced (#[allow(dead_code)]) — OOM attack via unbounded output
     - Switched from command.output() (buffers everything) to spawn() + incremental reads via read_limited() helper
     - Stops at max_output_size bytes, kills the child process, returns BashError::OutputTooLarge
     - Added with_max_output_size() builder method
   - [FIX] Timeout never fired — std::process::Command::output() blocks the tokio thread preventing cancellation
     - Switched to tokio::process::Command (async, truly cancellable by tokio::time::timeout)
   - [FIX] cwd_restriction stored but never applied to spawned process
     - Now passed to tokio::process::Command::current_dir()
   - Added 62-test suite covering output/exit codes, timeout enforcement, allowlist/denylist security,
     env vars, platform, thread safety, CWD restriction, and BashProtocol integration
   - Added module-level security documentation with PoC payloads and hardening guidance for 6 threat categories

 - feat: MCP event tracing (McpEvent) for full observability of MCP server/client interactions
   - New McpEvent enum with 14 variants covering server-side and client-side lifecycle
   - Server-side: ServerStarted, ToolListRequested, ToolListReturned, ToolCallReceived,
     ToolCallCompleted, ToolError, RequestRejected
   - Client-side: ConnectionInitialized, ConnectionClosed, ToolsDiscovered, CacheHit,
     CacheExpired, RemoteToolCallStarted, RemoteToolCallCompleted
   - EventHandler gains on_mcp_event() default no-op method; McpEvent re-exported from crate root
   - MCPServerBuilder gains with_event_handler() builder method
   - McpClientProtocol gains with_event_handler() builder method
   - ToolError fires on transport/protocol failures distinct from ToolCallCompleted { success: false }
   - Fix: UnifiedMcpServer::list_tools() deduplicates protocols by Arc pointer to avoid redundant calls

 - feat: McpClientProtocol endpoint paths fixed to match AxumHttpAdapter routes
   - GET {endpoint}/tools → POST {endpoint}/tools/list
   - POST {endpoint}/execute → POST {endpoint}/tools/execute

 - fix: parse_tool_call panic on multibyte Unicode characters in agent responses
   - Mixed byte offsets (from str::find) with char indices (from chars().enumerate()) causing panic
     inside multibyte chars like '─' (U+2500, 3 bytes) when slicing the response string
   - Fixed by using response[start_idx..].char_indices() so all offsets stay in byte space

 - feat: tetris_mcp_server example — RALPH orchestration via MCP HTTP transport
   - Ports tetris_planner_team.rs to route all tool calls through MCPServerBuilder on localhost:9090
   - Agents connect via McpClientProtocol (HTTP round-trips instead of in-process calls)
   - TetrisMcpEventHandler implements all four EventHandler methods including on_mcp_event
   - Added [[example]] entry in Cargo.toml with required-features = ["mcp-server"]

0.10.7 FEB/17/2026
 - feat: Agent::send() now fires PlannerEvents alongside AgentEvents
   - Every agent turn emits both [agent] and [planner] scoped events
   - Added emit_planner() helper on Agent mirroring existing emit()
   - Mapping: SendStarted→TurnStarted, LLMCallStarted/Completed, ToolCallDetected,
     ToolExecutionCompleted, ToolMaxIterationsReached, SendCompleted→TurnCompleted
   - plan_id is the agent's id; event handlers can show [planner] log entries
   - Full backward compatibility — all existing AgentEvent emissions unchanged

0.10.6 FEB/17/2026
 - feat: Add Model::ClaudeSonnet46 enum variant
   - Maps to "claude-sonnet-4-6" model identifier
   - Latest Claude Sonnet 4.6 generation
 - enhance: tetris_planner_team example improvements
   - Always delete stale output file at run start (fresh slate each run)
   - Rescue mechanism: extract HTML from agent response text when write_tetris_file not called
   - New system context frames instructions as PATTERN A / PATTERN B response formats
   - Tool self-descriptions printed to stdout before orchestration starts
   - Fixed starter HTML (raw string had escaped quotes that produced invalid HTML)
   - Switch to Model::ClaudeSonnet46 for better instruction-following
   - Memory tool now accepts both inline and split-parameter command styles
   - Memory::get_protocol_spec() corrected to match actual implementation format
   - MemoryProtocol::execute() normalises GET/PUT/LIST/DELETE/CLEAR aliases

0.10.5 FEB/16/2026
 - feat: Planner module for single-turn orchestration
   - Planner trait with policy, memory, and streaming hooks
   - BasicPlanner implementation with tool loop support
   - Tests for planner tool execution, policy denial, memory injection, streaming hooks
 - feat: Tetris planner example (Claude Haiku 4.5)
   - Multi-agent planner workflow writes tetris_planner_output.html

0.10.4 FEB/13/2026
 - enhance: Update Grok Imagine API integration
   - Switch from deprecated grok-2-image-1212 to current grok-imagine-image model
   - Pass aspect_ratio and response_format parameters to API (now supported)
   - Improved error handling: include HTTP status + full error body in error messages
   - Log full API response at error level when requests fail (previously debug-only)
   - Add info-level logging of request metadata (model, prompt length, image count)

0.10.3 FEB/13/2026
 - chore: Update all transitive dependencies to latest compatible versions
   - tokio: 1.48.0 → 1.49.0
   - reqwest: 0.12.24 → 0.12.28
   - axum: 0.8.7 → 0.8.8
   - serde_json: 1.0.145 → 1.0.149
   - regex: 1.11.1 → 1.12.3
   - url: 2.4.1 → 2.5.8
   - chrono, evalexpr, env_logger, log, tempfile, and 100+ transitive dependencies updated
   - Security and stability improvements across HTTP, TLS, cryptography, and Unicode handling
   - Cargo.lock updated via `cargo update`
 - verify: Confirmed Claude Opus 4.6 support in ClientWrapper
   - Model::ClaudeOpus46 enum variant already available
   - Maps to "claude-opus-4-6" model identifier
   - All latest Claude models supported (Opus 4.6, 4.5, Sonnet 4.5, Haiku 4.5)

0.10.2 FEB/11/2026
 - fix: Critical bug — AnthropicAgentTeams Memory never pre-populated with tasks
   - Agents calling `memory L` received empty results because tasks were logged but never stored
   - Memory is now pre-populated with task data before orchestration starts
   - Keys use hierarchical scheme: `teams:<pool_id>:unclaimed:<task_id>`
 - fix: RALPH checklist now includes task IDs for completion markers
   - Agents previously couldn't emit `[TASK_COMPLETE:task_id]` because the checklist only showed title and description
   - Checklist format changed from `- [ ] Title — Description` to `- [ ] Title (id: task_id) — Description`
 - enhance: ToolExecutionCompleted event now includes tool result data
   - Added `result: Option<serde_json::Value>` field to ToolExecutionCompleted event variant
   - Both `send()` and `generate_with_tokens()` in agent.rs now capture and pass tool output
   - Event handlers can now inspect tool execution results for debugging and monitoring
 - enhance: Improved HTML extraction in breakout game examples
   - `extract_html()` now searches backwards through ALL messages for substantial HTML with `<canvas>`
   - Agent system contexts updated to emphasize outputting complete, standalone HTML
   - Agents instructed to use `cat <<'EOF'` heredoc for reliable file writing via Bash tool
 - enhance: Increased iteration and token limits for better task completion
   - breakout_game_agent_teams: max_iterations 6→12, max_tokens 200k→300k
   - breakout_game_ralph: max_iterations 8→10, max_tokens 180k→250k
 - fix: Unescape literal `\n`, `\t`, `\"` in HTML output from LLM responses
   - LLM responses encode newlines as literal two-character `\n` sequences instead of real newlines
   - `extract_html()` now unescapes `\\n` → newline, `\\t` → tab, `\\"` → quote before returning
   - `write_game_file` custom tool also unescapes content before writing to disk
   - Fixes broken HTML rendering in both breakout game examples (ralph and agent_teams)
 - enhance: Detailed tool tracing in breakout game event handlers
   - Event handlers now display tool execution results (truncated to 200 chars)
   - Tool call parameter display increased to 300 chars
   - Memory dump section added to agent_teams example after orchestration completes

0.10.1 FEB/11/2026
 - fix: Correct Memory protocol documentation in agent examples
   - Fixed "Unknown Command" errors in breakout game examples
   - Memory tool protocol uses single-letter commands (P, G, L, D, C, SPEC)
   - Updated system context in RALPH and AnthropicAgentTeams examples
   - Agents now receive correct instructions for Memory tool usage
   - Commands should be space-separated strings in 'command' parameter, not separate JSON fields
   - Example: {"command": "P key value"} instead of {"command":"PUT","key":"...","value":"..."}

0.10.0 FEB/10/2026
 - feat: HttpClientProtocol — dedicated protocol for HTTP requests
   - New HttpClientProtocol struct wrapping HttpClient
   - 5 HTTP tools: http_get, http_post, http_put, http_delete, http_patch
   - Discoverable tools via ToolProtocol interface
   - Consistent JSON response format (status, body, headers)
   - Optional JSON body support for POST/PUT/PATCH
   - Full async/await with proper error handling
   - Comprehensive documentation with examples and security notes
   - Integrated into both breakout_game_ralph.rs and breakout_game_agent_teams.rs examples
 - feat: AnthropicAgentTeams orchestration mode (7th collaboration mode)
   - Decentralized task-based coordination inspired by Anthropic's C compiler work
   - No central orchestrator — agents autonomously discover and claim tasks
   - Hierarchical Memory key scheme: teams:<pool_id>:unclaimed:*, :claimed:*, :completed:*
   - New OrchestrationMode::AnthropicAgentTeams variant with pool_id, tasks, max_iterations
   - New WorkItem struct for defining tasks with id, description, acceptance_criteria
   - New OrchestrationEvent variants: TaskClaimed, TaskCompleted, TaskFailed
   - New examples/anthropic_teams.rs: full working demo with 4-agent team on 8-task pool
   - Atoms claim mechanism via Memory PUT (single-threaded, atomic from LLM perspective)
   - Progress tracking by querying completed vs unclaimed task counts in Memory
 - feat: Agent & Orchestration event system
   - New EventHandler trait with on_agent_event() and on_orchestration_event()
   - AgentEvent enum: SendStarted/Completed, LLMCallStarted/Completed,
     ToolCallDetected, ToolExecutionCompleted, ToolMaxIterationsReached,
     ThoughtCommitted, ProtocolAdded/Removed, SystemPromptSet,
     MessageReceived, Forked, ForkedWithContext
   - OrchestrationEvent enum: RunStarted/Completed, RoundStarted/Completed,
     AgentSelected, AgentResponded, AgentFailed, ConvergenceChecked,
     RalphIterationStarted, RalphTaskCompleted
   - Agent::with_event_handler() / set_event_handler() for registration
   - Orchestration::with_event_handler() auto-propagates to agents via add_agent()
   - New src/cloudllm/event.rs module with full re-exports in lib.rs
   - Replaces bare eprintln!() in orchestration error paths with AgentFailed events
 - enhance: Breakout game examples with expanded feature set (18 tasks)
   - Updated examples/breakout_game_ralph.rs: expanded from 10 to 18 PRD tasks
     - Core Mechanics (6): HTML structure, game loop, paddle control, ball physics, brick layout, collision
     - Audio System (2): Background music with muting, collision/powerup/life sounds
     - Powerup System (3): Basic (paddle/speed/projectile), Advanced (lava/bomb/growth/mushroom), Multiball
     - Visual Effects (3): Particle systems, paddle 3D animation, level complete animations
     - Advanced Mechanics (4): Level progression with 10+ patterns, difficulty scaling, mobile controls, scoring
   - New examples/breakout_game_agent_teams.rs: same 18-task game using AnthropicAgentTeams mode
     - Decentralized coordination: 4 Claude Haiku 4.5 agents autonomously discover and claim tasks
     - Supports mobile touch/swipe, responsive canvas, score milestones, 15+ procedural levels
   - Updated max_iterations from 5→8 (RALPH) to support larger task lists
 - enhance: breakout_game_ralph example with BreakoutEventHandler,
   shared Memory tool, and write_game_file custom tool
   - BreakoutEventHandler: real-time pretty-printed event output with elapsed time
   - Shared MemoryProtocol across all 4 agents for coordination
   - CustomToolProtocol with write_game_file tool for writing game files to disk
   - Memory dump section after orchestration run

0.9.0 FEB/10/2026
 - refactor: Per-agent sessions with hub-routed communication
   - Orchestration no longer broadcasts full conversation_history to all agents
   - New Agent::send() method uses LLMSession for stateful generation
   - New Agent::receive_message() for hub-routed message injection
   - Agent::set_system_prompt() for orchestration-managed system prompts
   - Agent::session_history_len() accessor for orchestration to check agent state
   - Agent::fork_with_context() for carrying session state into parallel tasks
   - LLMSession::system_prompt_text() accessor for reading system prompt content
   - Each orchestration mode now routes only relevant messages to each agent
   - Eliminates prompt augmentation duplication in RoundRobin/Moderated/Debate
   - agent_message_cursors tracking prevents duplicate message injection
   - Removed manual trim_history() from Ralph mode (LLMSession handles trimming)
   - generate_with_tokens() preserved for backward compatibility
   - New tests: test_agent_send_uses_session, test_agent_receive_message,
     test_hub_routing_no_duplication, test_agent_fork_with_context

0.8.0 JAN/17/2026
 - feat: RALPH Orchestration Mode (6th collaboration mode)
   - Autonomous iterative loop where agents work through a PRD task list
   - Agents iterate until all tasks are marked complete or max_iterations reached
   - PRD-driven: structured RalphTask items with id, title, description
   - Completion detection via [TASK_COMPLETE:task_id] markers in agent responses
   - Progress tracking with task completion percentage as convergence_score
   - New RalphTask struct for defining PRD items
 - new: breakout_game_ralph.rs example
   - Demonstrates RALPH mode building a complete Atari Breakout game
   - 4 specialized agents collaborate through 10 PRD tasks
   - Produces a single index.html with CSS, Canvas, Web Audio API
   - Features: multi-hit bricks, powerups (paddle size, speed, projectiles, multiball)
   - Atari 2600-style chiptune background music and collision sound effects
 - refactor: Rename "Council" to "Orchestration" across the entire codebase
   - Renamed council.rs → orchestration.rs
   - Renamed COUNCIL_TUTORIAL.md → ORCHESTRATION_TUTORIAL.md
   - Renamed examples: council_demo.rs → orchestration_demo.rs, council_with_memory.rs → orchestration_with_memory.rs
   - All public types renamed: Council → Orchestration, CouncilMode → OrchestrationMode, CouncilMessage → OrchestrationMessage, CouncilResponse → OrchestrationResponse
   - Updated all documentation, examples, and internal references
   - No behavioral changes — purely a naming improvement for clarity
 - fix: UTF-8 safe string truncation in examples
   - Fixed panic when truncating multi-byte UTF-8 strings (e.g., 'á', 'é') in debate/panel examples
   - Now finds nearest char boundary before slicing instead of assuming ASCII byte offsets
 - feat: Image Generation Support Across Multiple Providers
   - New ImageGenerationClient trait for unified image generation across providers
   - Type-safe provider selection via ImageGenerationProvider enum (OpenAI, Grok, Gemini)
   - Factory functions: new_image_generation_client() and new_image_generation_client_from_str()
   - Comprehensive ImageGenerationOptions with aspect_ratio, num_images, response_format parameters
   - Support for multiple aspect ratios per provider:
     - OpenAI (gpt-image-1.5): 1:1, 16:9, 4:3, 3:2, 9:16, 3:4, 2:3
     - Grok (grok-2-image): All ratios supported via API (aspect ratio parameter)
     - Gemini (gemini-2.5-flash-image): 10 aspect ratios (1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9)
   - Response formats: URL and Base64 (b64_json) with automatic format detection
   - Unified ImageGenerationResponse with images vec and optional revised_prompt field
 - new: Public utility functions for image handling
   - get_image_extension_from_base64(): Detects PNG, JPG, WebP from base64 magic bytes
   - decode_base64(): Decodes base64 strings to bytes for image file saving
 - new: Image generation implementations for all providers
   - OpenAI: Uses gpt-image-1.5 model via openai-rust2's create_image_old() method
   - Grok: Uses grok-2-image model via Grok Imagine API endpoint
   - Gemini: Uses gemini-2.5-flash-image model via Google's generative language API
 - new: Comprehensive integration test suite
   - OpenAI: 6 integration tests covering basic, landscape, multiple, model_name, factory, and error handling
   - Grok: 9 integration tests with types verification and trait object usage
   - Gemini: 11 integration tests covering all 10 aspect ratios, portrait/landscape/square modes
   - Total: 26+ image generation integration tests with image file saving
   - Base URL normalization tests verifying consistent handling across all providers
 - module: New cloudllm/src/cloudllm/image_generation.rs
   - Core trait, types, and helper functions for image generation
   - Extensive documentation with compilable examples
   - Type definitions: ImageGenerationOptions, ImageData, ImageGenerationResponse
 - module: Updated cloudllm/mod.rs
   - Added image_generation module exports
   - ImageGenerationProvider enum with type-safe factory pattern
   - Public API exports for images generation types and utilities
 - module: Enhanced client implementations
   - OpenAI: ImageGenerationClient trait implementation with size mapping for gpt-image-1.5
   - Grok: ImageGenerationClient trait implementation with model name resolution
   - Gemini: ImageGenerationClient trait implementation with direct HTTP API calls
 - refactor: Base URL normalization across all clients
   - OpenAI, Grok, and Gemini clients now normalize base_url by removing trailing slashes
   - Consistent URL construction with explicit "/" separators
   - Custom base_url parameters honored for flexible endpoint configuration
   - Backward compatible - works with both trailing and non-trailing slash URLs
 - docs: README.md updated with image generation section
   - New "Image Generation with Multiple Providers" section
   - Type-safe provider selection examples
   - Aspect ratio configuration guide
   - Factory function usage patterns
 - feature: Landscape aspect ratio support
   - Primary use case: landscape images for blog/social media content
   - Seamless mapping across provider APIs (different size/aspect ratio naming conventions)
   - Supported in all three providers with consistent interface
 - new: register_image_generation_tool() helper function
   - Dramatically simplifies tool registration for agents (boilerplate reduction: ~80 lines → 1 line)
   - Automatically handles tool metadata, parameter marshalling, response parsing, and error handling
   - Encapsulates all complexity of closing image generation into tools
   - Usage: protocol.register_image_generation_tool(image_client).await
 - new: FromStr trait implementation for ImageGenerationProvider
   - Implements standard library FromStr trait for string-to-enum conversion
   - Case-insensitive parsing: "openai", "grok", "gemini" (any case)
   - New ImageGenerationProviderError type implementing std::error::Error
   - Enables idiomatic Rust: let provider = ImageGenerationProvider::from_str("openai")?;
   - Convenience function new_image_generation_client_from_str() wraps FromStr internally
 - docs: Module-level documentation enhancements
   - Comprehensive examples in image_generation.rs with compilable code snippets
   - FromStr trait usage examples showing case-insensitive parsing
   - ImageGenerationProvider enum methods documented: as_str(), display_name()
   - Provider-specific implementation notes and response format details
 - docs: README.md "Parsing from Strings with FromStr" section
   - Demonstrates FromStr trait for runtime provider selection
   - Shows both traits-based and convenience function approaches
   - Practical examples with error handling
 - fix: Code quality improvements (6 clippy warnings resolved)
   - Collapsed nested if statement in Gemini aspect ratio validation
   - Removed unnecessary u8 casts in base64 decoder
   - Replaced get(0) with first() for idiomaticity
   - Proper FromStr trait implementation (not custom method)
   - All code passes: cargo clippy -- -D warnings
 - chore: Updated .gitignore for development artifacts
   - Ignore generated image files (PNG, JPG, JPEG, WebP, GIF)
   - Ignore temporary markdown files created during development
 - backward-compatibility: Fully backward compatible
   - No changes to existing ClientWrapper trait
   - Image generation is opt-in via separate ImageGenerationClient trait
   - No impact on text generation or streaming functionality

0.7.1 DEC/08/2025
 - fix: Test suite corrections for OpenAI tools trait parameter
   - Fixed MockClient implementations in orchestration.rs, llm_session_tests.rs
   - Corrected send_message() parameter count across all test files
   - All 45 library tests now passing
 - new: openai_bitcoin_price_example.rs
   - Practical example demonstrating real-time Bitcoin price lookup
   - Shows web_search tool usage with high context configuration
   - Demonstrates token usage tracking for financial queries
 - fix: Removed unsupported max_num_results from web_search tool usage
   - max_num_results is for file_search only, not web_search
   - Example now uses only supported parameters for web_search

0.7.0 DEC/08/2025
 - feat: OpenAI Responses API Support for Agentic Tool Calling
   - OpenAIClient now automatically switches between Chat Completions and Responses API
   - When tools are provided (web_search, file_search, code_interpreter), uses /v1/responses endpoint
   - Without tools, uses standard /v1/chat/completions endpoint
   - Real-time web search with configurable context size (high/medium/low)
   - Geographic filtering support (country, city, region, timezone)
 - new: OpenAI tool types in openai-rust2 (1.7.2):
   - OpenAITool struct with web_search, file_search, code_interpreter factory methods
   - UserLocation struct for geographic filtering on web searches
   - OpenAIResponsesArguments for Responses API requests
   - Client::create_openai_responses() for /v1/responses endpoint
 - new: send_and_track_openai_responses() in common.rs for OpenAI Responses API calls
 - feature: Dual API routing pattern now available for both Grok and OpenAI clients
   - Automatic endpoint selection based on tool presence
   - Unified response handling through ResponsesCompletion
   - Token usage tracking for all tool-based requests
 - update: ClientWrapper trait now supports both Grok and OpenAI tools
   - send_message() accepts optional_openai_tools parameter
   - send_message_stream() accepts optional_openai_tools parameter
   - All client implementations updated for backward compatibility
 - update: Agent API extended with OpenAI tool support
   - Agent::with_openai_tools() builder method
   - Transparent tool forwarding through Agent → LLMSession → Client layers
 - update: LLMSession supports OpenAI tools
   - send_message() accepts optional_openai_tools parameter
   - send_message_stream() accepts optional_openai_tools parameter
 - new: openai_web_search_example.rs demonstrating all tool capabilities
   - Basic web search with context size control
   - Geographic filtering example
   - Multi-turn LLMSession conversation with web search
 - fix: Updated 4 existing examples for new trait signature
   - interactive_session.rs
   - interactive_streaming_session.rs
   - streaming_example.rs
   - openai_web_search_example.rs (new)
 - deps: openai-rust2 upgraded to 1.7.2 (now supports OpenAI Responses API)
 - docs: Comprehensive example showing all OpenAI tool usage patterns
 - See: https://platform.openai.com/docs/guides/tools-web-search
 - Supported Models: gpt-5, gpt-4o, and other models with Responses API support

0.6.3 DEC/04/2025
 - feat: xAI Responses API Support for Agentic Tool Calling
   - GrokClient now automatically switches between Chat Completions and Responses API
   - When tools are provided (web_search, x_search, etc.), uses /v1/responses endpoint
   - Without tools, uses standard /v1/chat/completions endpoint
   - Real-time web search now working with current data and citations
 - new: send_and_track_responses() in common.rs for Responses API calls
 - refactor: GrokClient restructured with direct openai_rust::Client access
   - Removed OpenAIClient delegation pattern for better API control
   - Added token_usage tracking directly in GrokClient
 - deps: openai-rust2 upgraded to 1.7.1
   - Adds ResponsesArguments, ResponsesMessage, ResponsesCompletion types
   - Adds Client::create_responses() for /v1/responses endpoint
   - grok_tools field serializes as "server_tools" for Chat Completions
 - fix: ClientWrapper trait updated for GrokTool support across all clients
 - docs: Updated examples and tests for new Grok tool calling API
 - See: https://docs.x.ai/docs/guides/tools/search-tools

0.6.2 NOV/17/2025
 - feat: OpenAI Model GPT-5.1 Support
   - Added GPT51 model variant for flagship coding and agentic tasks
   - Supports configurable reasoning and non-reasoning effort levels
   - Updated model_to_string() function to handle new model identifier
 - deps: Updated dependencies for stability and performance
   - tokio: 1.47.1 → 1.48.0
   - async-trait: 0.1.88 → 0.1.89
   - log: 0.4.27 → 0.4.28
   - bumpalo: 3.16 → 3.19.0
   - reqwest: 0.12 → 0.12.24 (explicit version pinning)
   - futures-util: 0.3 → 0.3.31 (explicit version pinning)
   - serde: 1.0 → 1.0.228 (explicit version pinning)
   - serde_json: 1.0 → 1.0.145 (explicit version pinning)
   - evalexpr: 12.0 → 13.0.0
   - urlencoding: 2.1 → 2.1.3 (explicit version pinning)
   - axum: 0.8.6 → 0.8.7
   - tempfile: 3.10 → 3.23

0.6.1 OCT/27/2025
 - feat: MCPServerBuilder - Simplified MCP Server Creation
   - New MCPServerBuilder with fluent API for creating MCP servers
   - Built-in tool support: Memory, Bash, and custom tools via with_*_tool() methods
   - IP filtering with single IP, IPv6, and CIDR block support
   - Authentication support: Bearer tokens and basic auth
   - Pluggable HTTP adapter trait for framework flexibility (Axum, Actix, Warp, etc.)
   - Localhost-only convenience method for secure local development
   - Methods: allow_ip(), allow_cidr(), allow_localhost_only(), with_bearer_token(), with_basic_auth()
 - example: Comprehensive MCP Server with All Tools
   - New examples/mcp_server_all_tools.rs demonstrating complete server setup
   - All 5 framework tools integrated: Memory, Calculator, FileSystem, HTTP Client, Bash
   - Localhost-only security (127.0.0.1, ::1)
   - Ready for OpenAI Desktop Client integration at http://localhost:8008/mcp
   - Beautiful formatted startup output with tool descriptions and usage examples
   - CustomToolProtocol wrappers for flexible tool integration
 - feat: Calculator Tool Enhancement
   - Migrated from unmaintained meval v0.2 to actively maintained evalexpr v12.0.3
   - Added inverse hyperbolic functions: asinh(), acosh(), atanh()
   - Significantly improved performance and reliability
   - Removed future-incompatible nom v1.2.4 dependency
 - fix: HTTP Adapter Borrow Checker Issues
   - Fixed move conflicts in route handlers by wrapping bearer_token and allowed_ips in Arc
   - Pre-cloned Arc values before passing to route handlers
   - HTTP adapter now compiles cleanly with --features mcp-server
 - feat: Documentation and Examples
   - Updated all example documentation to clarify HTTP (not HTTPS) is secure for localhost-only servers
   - Explanation that localhost binding provides security, not protocol choice
   - Follows industry standard practice (npm, Flask, Django, etc.)
 - fix: Code Quality
   - Removed unused std::fs import in filesystem.rs tests
   - Added #[allow(dead_code)] attribute for example struct fields not currently used
   - All 185+ tests passing with zero warnings
 - deps: Updated dependencies
   - axum updated to 0.8.6 (from 0.7.9)
   - tower updated to 0.5.2 (from 0.4.13)
   - Improved HTTP server stability and performance

0.5.0 OCT/25/2025
 - feat: Multi-Protocol ToolRegistry for Agents
   - Extended ToolRegistry to support agents connecting to multiple MCP servers simultaneously
   - Agents transparently access tools from all connected sources as if they were local
   - New API methods for dynamic protocol management:
     - `ToolRegistry::empty()` - Create registry for multi-protocol mode
     - `add_protocol(name, protocol)` - Register protocols with auto-tool discovery
     - `remove_protocol(name)` - Remove protocols and cascade-delete their tools
     - `get_tool_protocol(tool_name)` - Query which protocol handles a tool
     - `list_protocols()` - Get all registered protocol names
     - `discover_tools_from_primary()` - Manually discover tools from primary protocol
   - Automatic tool routing via `tool_to_protocol` HashMap
   - Tool discovery on protocol registration
   - Full backwards compatibility with single-protocol code
 - feat: Unified MCP Server Implementation
   - New UnifiedMcpServer struct implementing ToolProtocol trait
   - Aggregates multiple tools and routes tool calls to appropriate implementations
   - Suitable for deployment as HTTP service accessed by multiple agents
   - Thread-safe via Arc<RwLock<>> for concurrent tool executions
   - API methods:
     - `register_tool(tool_name, protocol)` - Register a tool
     - `unregister_tool(tool_name)` - Remove a tool
     - `list_tools()` - Discover all available tools
 - feat: Enhanced Tool Discovery and Execution
   - ToolRegistry now auto-discovers tools when protocols are added
   - Agent tool system prompts include all available tools from all protocols
   - Tool execution transparently routes to correct protocol
   - Support for both single and multi-protocol agent configurations
 - feat: Renamed Tool Adapters for Clarity
   - Renamed tool_adapters.rs to tool_protocols.rs (adapters are ToolProtocol implementations)
   - All adapter classes renamed:
     - CustomToolAdapter → CustomToolProtocol
     - McpAdapter → McpClientProtocol
     - MemoryToolAdapter → MemoryProtocol
     - McpMemoryClient → McpMemoryClient (unchanged - already correct)
     - OpenAIFunctionAdapter → OpenAIFunctionProtocol
   - Backwards compatibility maintained with deprecated re-exports
 - feat: Agent Tool Discovery Enhancements
   - Agent.with_tools() documentation enhanced with multi-protocol examples
   - Tool registry field documentation clarifies single and multi-protocol modes
   - Orchestration module updated to support multi-protocol tool registries
 - example: New Multi-MCP Agent Example
   - examples/multi_mcp_agent.rs demonstrates connecting to 3 MCP servers:
     - Local MCP server (custom tools)
     - Remote YouTube MCP server (youtube_search, youtube_get_transcript)
     - Remote GitHub MCP server (github_search_repos, github_get_issues)
   - Shows how agent transparently uses tools from all sources
   - Demonstrates dynamic protocol registration at runtime
 - docs: Enhanced Multi-Protocol Documentation
   - README.md updated with multi-protocol ToolRegistry section
   - Includes basic usage examples and key features
   - Shows comparison between single and multi-protocol modes
   - examples/MULTI_MCP_ARCHITECTURE.md comprehensive architecture guide
   - Examples show tool routing, aggregation, and composition patterns
 - test: Comprehensive Multi-Protocol Test Coverage
   - 9 new tests in tool_protocol.rs (26 total library tests):
     - test_empty_registry_creation
     - test_add_single_protocol_to_empty_registry
     - test_add_multiple_protocols
     - test_remove_protocol
     - test_get_tool_protocol
     - test_remove_protocol_removes_tools
     - test_execute_tool_through_registry
     - test_backwards_compatibility_single_protocol
     - test_discover_tools_from_primary
   - 7 existing UnifiedMcpServer tests continue to pass
   - All tests verify tool routing, discovery, and protocol management
 - fix: Tool Protocol Documentation
   - Fixed HTML tag warning in mcp_server.rs documentation
   - Improved docstring formatting across tool_protocol.rs
   - Enhanced examples in README.md with working code snippets
 - docs: Updated HANDOFF.md
   - Comprehensive session summary of multi-protocol implementation
   - Quick API reference for both single and multi-protocol modes
   - Complete feature list and backwards compatibility notes

0.4.0 OCT/13/2025
 - feat: Multi-Agent Orchestration System
   - New orchestration.rs module implementing collaborative multi-agent orchestration
   - Five orchestration modes for different collaboration patterns:
     - Parallel: All agents process prompt simultaneously, responses aggregated
     - RoundRobin: Agents take sequential turns building on previous responses
     - Moderated: Agents submit proposals, moderator synthesizes final answer
     - Hierarchical: Lead agent coordinates, specialists handle specific aspects
     - Debate: Agents discuss and challenge each other until convergence
   - Agent identity system with name, expertise, personality, and optional tool access
   - Conversation history tracking with OrchestrationMessage and round metadata
   - OrchestrationResponse includes final answer, message history, rounds executed, convergence score, and total tokens used
 - feat: Tool Protocol Abstraction Layer (tool_protocol.rs)
   - Flexible abstraction for connecting agents to various tool protocols
   - ToolProtocol trait with execute(), list_tools(), get_tool_metadata()
   - Support for MCP (Model Context Protocol), custom functions, and user-defined protocols
   - ToolResult struct with success status, output, error, and execution metadata
   - ToolParameter system with support for String, Number, Integer, Boolean, Array, Object types
   - ToolMetadata with parameter definitions and protocol-specific metadata
   - ToolRegistry for centralized tool management
   - Tool and ToolError types for type-safe tool operations
 - feat: Tool Adapters (tool_adapters.rs)
   - CustomToolAdapter: Execute user-defined Rust closures as tools
   - MCPToolAdapter: Integration with Model Context Protocol servers
   - OpenAIToolAdapter: Compatible with OpenAI function calling format
   - All adapters implement async ToolProtocol trait
 - feat: Automatic Tool Execution in Agent Generation
   - Agents automatically discover and execute tools during response generation
   - Tool information injected into system prompts with name, description, and parameters
   - JSON-based tool calling format: {"tool_call": {"name": "...", "parameters": {...}}}
   - Automatic tool execution loop with max 5 iterations to prevent infinite loops
   - Tool results fed back to LLM as user messages for continued generation
   - Token usage tracked cumulatively across all LLM calls and tool executions
   - New AgentResponse struct returns both content and token usage
   - Agent::generate_with_tokens() method for internal use with token tracking
 - feat: Convergence Detection for Debate Mode
   - Jaccard similarity-based convergence detection for debate termination
   - Compares word sets between consecutive debate rounds
   - Configurable convergence threshold (default: 0.75 / 75% similarity)
   - Early termination when agents reach consensus, saving tokens and cost
   - Convergence score returned in OrchestrationResponse for inspection
   - calculate_convergence_score() and jaccard_similarity() helper methods
 - feat: Token Usage Tracking in Orchestration Modes
   - Parallel mode tracks and aggregates tokens from all concurrent agents
   - RoundRobin mode accumulates tokens across sequential turns
   - Token usage includes all LLM calls plus tool execution overhead
   - OrchestrationResponse.total_tokens_used provides complete cost visibility
 - feat: Comprehensive Multi-Agent Tutorial (ORCHESTRATION_TUTORIAL.md)
   - Cookbook-style tutorial with progressive complexity
   - Five detailed recipes demonstrating each orchestration mode
   - Real-world carbon capture strategy problem domain
   - Examples use multiple LLM providers (OpenAI, Claude, Gemini, Grok)
   - Up to 5 agents per example with distinct expertise and personalities
   - Tool integration example with MCPToolAdapter
   - Best practices guide for agent design and orchestration mode selection
   - Troubleshooting section with common issues and solutions
   - Complete multi-stage pipeline example combining multiple modes
 - test: Added comprehensive test coverage
   - test_agent_with_tool_execution: Validates tool discovery, execution, and result integration
   - test_debate_mode_convergence: Validates convergence detection with mock agents
   - test_parallel_execution: Tests concurrent agent execution
   - test_round_robin_execution: Tests sequential turn-taking
   - test_moderated_execution: Tests proposal aggregation
   - test_hierarchical_execution: Tests lead-specialist coordination
   - test_debate_execution: Tests debate discussion flow
   - All 12 tests passing
 - refactor: Code quality improvements
   - Fixed all compiler warnings
   - Switched from std::sync::Mutex to tokio::sync::Mutex for async compatibility
   - Removed unused imports and assignments
   - Improved error handling in orchestration execution paths
 - docs: Added inline documentation for orchestration system and tool protocol
   - Module-level documentation with architecture diagrams
   - Example code in doc comments
   - Detailed parameter and return value documentation

0.3.0 OCT/11/2025
 - feat: Add first-class streaming support for LLM responses
   - New MessageChunk type for incremental content delivery
   - ClientWrapper::send_message_stream() method for streaming responses
   - Implemented in OpenAIClient and GrokClient (delegates to OpenAI)
   - LLMSession::send_message_stream() for session-aware streaming
   - Dramatically reduces perceived latency - users see tokens as they arrive
   - Streaming returns Stream<Item = Result<MessageChunk, Box<dyn Error>>>
   - Backward compatible - existing non-streaming code unchanged
   - Added streaming_example.rs demonstrating usage
   - Added futures-util dependency for Stream trait
 - Note: Token usage tracking not available for streaming responses
 - Optimized LLMSession conversation history with VecDeque to eliminate O(N²) insert/remove churn
 - Minimize string formatting overhead in hot path error logs
 - Replace std::sync::Mutex with tokio::sync::Mutex for async-friendly token usage tracking
 - Change ClientWrapper::send_message to accept &[Message] instead of Vec<Message>
 - refactor: Move all client tests to external integration test files
 - feat: make token usage retrieval async and clean up Claude/OpenAI client usage
 - Implement token count caching for efficient message trimming
 - Implement pre-transmission trimming to reduce network overhead and latency
 - Arena/bump allocation for message bodies
 - Reuse request buffers in LLMSession to avoid repeated allocations on each send
 - OpenAI and Gemini clients preallocate formatted_messages with Vec::with_capacity
 - feat: Add model_name() to ClientWrapper and LLMSession
 - feat: Implement persistent HTTP connection pooling for all provider clients

0.2.12 SEP/21/2025
 - Added Claude client implementation at src/cloudllm/clients/claude.rs:
   - ClaudeClient struct follows the same delegate pattern as GrokClient, using OpenAIClient internally
   - Supports Anthropic API base URL (https://api.anthropic.com/v1)
   - Includes 6 Claude model variants: Claude35Sonnet20241022, Claude35Haiku20241022, Claude3Opus20240229, Claude35Sonnet20240620, Claude3Sonnet20240229, Claude3Haiku20240307
   - Implements all standard constructor methods and ClientWrapper trait
   - Added test function with CLAUDE_API_KEY environment variable
   - Updated README.md to mark Claude as supported (removed "Coming Soon")
   - Added Claude example to interactive_session.rs example

0.2.10 SEP/21/2025
 - New Grok model enums added to the GrokClient:
   - grok-4-fast-reasoning
   - grok-4-fast-non-reasoning
   - grok-code-fast-1

0.2.9
 - New OpenAI model enums added to the OpenAIClient:
   - gpt-5
   - gpt-5-mini
   - gpt-5-nano
   - gpt-5-chat-latest
 - Upgraded tokio to 1.47.1

0.2.8
 - Bumped cloudllm version to 0.2.8
 - Upgraded tokio dependency from 1.44.5 to 1.46.1
 - Updated Grok client model names and enums in src/cloudllm/clients/grok.rs:
  - Renamed Grok3MiniFastBeta to Grok3MiniFast, Grok3MiniBeta to Grok3Mini, Grok3FastBeta to Grok3Fast, Grok3Beta to Grok3, and Grok3Latest to Grok4_0709
  - Updated model_to_string function to reflect new model names
  - Changed test client initialization to use Grok4_0709 instead of Grok3Latest
 - Updated Gemini client model names and enums in src/cloudllm/clients/gemini.rs:
  - Renamed Gemini25FlashPreview0520 to Gemini25Flash and Gemini25ProPreview0506 to Gemini25Pro to reflect stable releases
  - Added new model enum Gemini25FlashLitePreview0617 for lightweight preview model
  - Updated model_to_string function to map new enum names: gemini-2.5-flash, gemini-2.5-pro, and gemini-2.5-flash-lite-preview-06-17

0.2.7
- Bumped cloudllm version to 0.2.7
- Upgraded openai-rust2 dependency from 1.5.9 to 1.6.0
- Extended ChatArguments and client wrappers for search and tool support:
  - Added `SearchParameters` struct and `with_search_parameters()` builder to `openai_rust::chat::ChatArguments`
  - Added `ToolType` enum and `Tool` struct, plus `tools` field and `with_tools()` builder (snake_case serialization)
  - Updated `ClientWrapper::send_message` signature to accept `optional_search_parameters: Option<SearchParameters>`
  - Modified `clients/common.rs` `send_and_track()` to take and inject `optional_search_parameters`
  - Updated `OpenAIClient`, `GeminiClient`, and `GrokClient` to forward `optional_search_parameters` to `send_and_track`
  - Exposed `optional_search_parameters` through `LLMSession::send_message` and its callers
- Other updates:
  - Added `Grok3Latest` variant to `grok::Model` enum and updated test to use it
  - Ensured backward compatibility: all existing call sites default `optional_search_parameters` to `None`

0.2.6
- Implemented token usage tracking across the LLMSession and ClientWrapper trait, including:
  - New TokenUsage struct for standardized tracking of input, output, and total tokens.
  - LLMSession now accumulates actual token usage after each message.
  - LLMSession::token_usage() method added for external inspection.
  - ClientWrapper trait extended with get_last_usage() (default: None) and new usage_slot() hook.
- Refactored token usage handling in OpenAIClient and GeminiClient:
  - Introduced a common send_and_track helper in clients/common.rs to centralize usage capture logic.
  - OpenAIClient and GeminiClient now store usage in an internal Mutex<Option<TokenUsage>>.
  - Redundant get_last_usage() implementations removed; only usage_slot() is overridden.
  - Added multiple constructors to GeminiClient: support for model strings, enums, and base URL configuration.
- Improved LLMSession context management:
  - Added max_tokens field with get_max_tokens() accessor.
  - Prunes conversation history using estimated token count per message.
  - Precise control over total_context_tokens and total_token_count.
- Example interactive_session.rs refactored to:
  - Demonstrate integration with both OpenAIClient, GrokClient, and GeminiClient.
  - Show token usage in real-time after each LLM response.
  - Test max_tokens pruning logic with visible metrics.
- Added model variants to GeminiClient enum:
  - Gemini25FlashPreview0520
  - Gemini25ProPreview0506
- Cleaned up and reorganized internal code:
  - Moved constructors and imports for clarity.
  - Removed redundant comments and unused stub code.
- Updated README example (interactive_session.md) with new usage patterns.

0.2.5
- Bumped tokio from 1.44.2 to 1.44.5
- Updated openai-rust2 from 1.5.8 to 1.5.9, with updated support for image generation models

0.2.4
- New enums for OpenAI client: gpt-4.1, gpt-4.1-mini, gpt-4.1-nano
- example in interactive_session.rs now uses gpt-4.1-mini

0.2.3
- Modified LLMSession to use Arc<dyn ClientWrapper> instead of generic T: ClientWrapper, enabling dynamic selection of client implementations (e.g., OpenAIClient, GrokClient, GeminiClient) at runtime.
- Updated LLMSession::new to accept Arc<dyn ClientWrapper>, removing Arc::new wrapping inside the constructor.
- Adjusted tests in gemini.rs and grok.rs to use Arc::new and non-generic LLMSession.
- Updated interactive_session.rs example to wrap client in Arc::new.
- Added init_logger function in lib.rs for thread-safe logger initialization using env_logger and Once.
- Replaced env_logger::try_init with crate::init_logger in gemini.rs and grok.rs tests for consistency.
- Updated GrokClient test to use Grok3MiniFastBeta enum variant.
- Updated LLMSession documentation to reflect Arc::new usage.
- Updated ClientWrapper trait to require Send + Sync, ensuring Arc<dyn ClientWrapper> is thread-safe and LLMSession can be used in async tasks (e.g., Tokio spawn).
- Enables safe dynamic client selection in multithreaded contexts
- All tests pass with the new implementation

0.2.2
- New Grok3 enums for the grokclient available
- Dependencies updated, cargo formatted

0.2.1
- Added new enums for O4Mini, O4MiniHigh and O3
- New enum for gpt-4.5-preview for the OpenAIClient

0.1.9 - feb.26.2025
- Update dependencies: tokio to 1.43.0, async-trait to 0.1.86, log to 0.4.26
- Refactor send_message in ClientWrapper to remove opt_url_path parameter
- Update GeminiClient to use openai_rust::Client and handle Gemini API directly
- Adjust OpenAIClient, GrokClient, LLMSession, and examples to new send_message signature

0.1.8 - feb.26.2025
- documentation updates

0.1.7 - feb.26.2025
- Update README.md to reflect support for Gemini
- Introduce Model enum in openai.rs for OpenAI models with model_to_string function
- Modify ClientWrapper trait to include optional URL path for API requests
- Update GeminiClient to use new ClientWrapper signature and set base URL to 'https://generativelanguage.googleapis.com/v1beta/'
- Adjust GrokClient to align with updated ClientWrapper signature
- Enhance OpenAIClient with Model enum support and optional URL paths in send_message
- Update LLMSession to pass optional URL path to client in send_message
- Revise examples/interactive_session.rs to use Model enum and new client methods
- Increment openai-rust2 dependency to version 1.5.8
- Fix minor formatting and improve error logging in clients

0.1.6 - feb.23.2025
- Introduced GrokClient in src/cloudllm/clients/grok.rs with support for multiple Grok models.
- Implemented the ClientWrapper trait for GrokClient to enable message sending via OpenAIClient.
- Added a test (test_grok_client) demonstrating basic usage and integration.
- Updated src/cloudllm/clients/mod.rs to include the new grok module.

0.1.5 - jan.23.2025
- Removed the original `openai-rust` dependency.
- Added `openai-rust2` as a new dependency, pointing to your custom fork with improvements.
- Added a new constructor `new_with_base_url` to allow specifying a custom base URL
- Ensured all modules are properly referenced and re-exported for future scalability.