patch

Author: tripolskypetr

docs/design/01_Overview.md

@@ -19,23 +19,23 @@ The agent-swarm-kit follows a layered architecture centered around a dependency
 
 ### High-Level System Flow
 
-![Mermaid Diagram](./diagrams\1_Overview_0.svg)
+![Mermaid Diagram](./diagrams/1_Overview_0.svg)
 
 ## Core Components
 
 ### Agent Execution Engine
 
 The `ClientAgent` class serves as the core execution engine for individual agents, handling message processing, tool calls, and AI model interactions:
 
-![Mermaid Diagram](./diagrams\1_Overview_2.svg)
+![Mermaid Diagram](./diagrams/1_Overview_2.svg)
 
 The `ClientAgent` implements sophisticated execution patterns including tool call validation, model recovery strategies, and event-driven communication through subjects for handling agent state changes, tool outputs, and error conditions.
 
 ### Session Management
 
 The session layer manages client connections and message flow through the swarm system:
 
-![Mermaid Diagram](./diagrams\1_Overview_3.svg)
+![Mermaid Diagram](./diagrams/1_Overview_3.svg)
 
 The `ClientSession` enforces policy validation for both input and output messages, coordinates with the swarm for agent execution, and provides event-driven messaging capabilities for real-time client communication.
 
@@ -55,7 +55,7 @@ The swarm maintains a navigation stack that allows agents to call each other and
 
 The system processes messages through a well-defined pipeline that ensures proper validation, execution, and output handling:
 
-![Mermaid Diagram](./diagrams\1_Overview_4.svg)
+![Mermaid Diagram](./diagrams/1_Overview_4.svg)
 
 This flow demonstrates the coordination between layers and the sophisticated tool execution pipeline that handles both simple completions and complex multi-tool workflows.
 

docs/design/02_Getting_Started.md

@@ -23,7 +23,7 @@ The library provides a dependency injection-based architecture where agents, too
 
 Agent-swarm-kit uses a layered service architecture built around a central dependency injection container. The system orchestrates multiple AI agents that can communicate, share tools, and maintain conversation history.
 
-![Mermaid Diagram](./diagrams\2_Getting_Started_0.svg)
+![Mermaid Diagram](./diagrams/2_Getting_Started_0.svg)
 
 ## Core Concepts
 
@@ -43,7 +43,7 @@ Sessions manage client connections, conversation history, and agent state for in
 
 The typical workflow involves four steps: define components, assemble swarm, create session, and process messages.
 
-![Mermaid Diagram](./diagrams\2_Getting_Started_1.svg)
+![Mermaid Diagram](./diagrams/2_Getting_Started_1.svg)
 
 ## Quick Start Example
 

docs/design/03_Core_Components.md

@@ -15,7 +15,7 @@ The agent execution engine consists of two primary components: `ClientAgent` for
 
 `ClientAgent` is the core execution engine that processes incoming messages, executes tool calls, and generates AI completions. It implements the `IAgent` interface and serves as the primary orchestrator for agent behavior.
 
-![Mermaid Diagram](./diagrams\3_Core_Components_0.svg)
+![Mermaid Diagram](./diagrams/3_Core_Components_0.svg)
 
 **Key responsibilities:**
 - **Message Execution**: Processes user and tool messages through `execute()` method
@@ -30,7 +30,7 @@ The `ClientAgent` uses a queued execution model to prevent overlapping operation
 
 `ClientHistory` manages conversation history for agents, providing filtered message arrays optimized for AI completion contexts and maintaining message persistence.
 
-![Mermaid Diagram](./diagrams\3_Core_Components_1.svg)
+![Mermaid Diagram](./diagrams/3_Core_Components_1.svg)
 
 **Key features:**
 - **Message Filtering**: Applies agent-specific filters to scope relevant messages
@@ -47,7 +47,7 @@ The history system supports both raw message access and agent-optimized arrays t
 
 `ClientSession` orchestrates communication between clients, agents, and swarms while enforcing policies and managing message flows. It implements the `ISession` interface and serves as the primary coordination layer.
 
-![Mermaid Diagram](./diagrams\3_Core_Components_2.svg)
+![Mermaid Diagram](./diagrams/3_Core_Components_2.svg)
 
 **Core capabilities:**
 - **Message Execution**: Coordinates agent execution with policy validation
@@ -66,7 +66,7 @@ The service infrastructure provides the foundation for component lifecycle manag
 
 Connection services manage the instantiation and lifecycle of core components using memoization for efficient reuse.
 
-![Mermaid Diagram](./diagrams\3_Core_Components_3.svg)
+![Mermaid Diagram](./diagrams/3_Core_Components_3.svg)
 
 **Service responsibilities:**
 - **AgentConnectionService**: Creates and manages `ClientAgent` instances with tool and completion dependencies
@@ -80,7 +80,7 @@ Each connection service uses `memoize` from functools-kit to cache instances by
 
 Public services provide the external API layer with context management and method scoping around connection services.
 
-![Mermaid Diagram](./diagrams\3_Core_Components_4.svg)
+![Mermaid Diagram](./diagrams/3_Core_Components_4.svg)
 
 **Public service features:**
 - **Context Scoping**: Wraps all operations with `MethodContextService.runInContext()` for proper context management
@@ -95,7 +95,7 @@ The public services layer provides a clean separation between external API and i
 
 The core components work together through a well-defined integration pattern that ensures proper message flow, state management, and error handling.
 
-![Mermaid Diagram](./diagrams\3_Core_Components_5.svg)
+![Mermaid Diagram](./diagrams/3_Core_Components_5.svg)
 
 **Integration patterns:**
 - **Layered Delegation**: Public services delegate to connection services which manage component instances

docs/design/04_Client_Agent.md

@@ -15,15 +15,15 @@ The `ClientAgent` implements the `IAgent` interface and serves as the primary ex
 
 ### ClientAgent Class Structure
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_0.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_0.svg)
 
 ## Execution Lifecycle
 
 The `ClientAgent` follows a structured execution lifecycle with queued processing to prevent overlapping executions. The system supports both stateful execution (via `execute`) and stateless completion (via `run`).
 
 ### Execution Flow Diagram
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_1.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_1.svg)
 
 ### Queued Execution Pattern
 
@@ -42,7 +42,7 @@ The `ClientAgent` handles tool execution through a sophisticated orchestration s
 
 ### Tool Resolution and Execution
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_2.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_2.svg)
 
 ### Tool Abort Controller
 
@@ -71,7 +71,7 @@ The `ClientAgent` integrates closely with the history system to maintain convers
 
 ### Message Flow and History Integration
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_3.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_3.svg)
 
 ### History Filtering and Context Management
 
@@ -88,7 +88,7 @@ The `ClientAgent` implements a robust error recovery system through the `_resurr
 
 ### Resurrection Strategies
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_4.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_4.svg)
 
 ### Error Types and Handling
 
@@ -107,7 +107,7 @@ The `ClientAgent` uses `Subject` instances from `functools-kit` for asynchronous
 
 ### Subject-Based Coordination System
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_5.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_5.svg)
 
 ### Asynchronous Tool Execution
 
@@ -132,7 +132,7 @@ The `ClientAgent` integrates with multiple services through dependency injection
 
 ### Service Dependencies
 
-![Mermaid Diagram](./diagrams\4_Client_Agent_6.svg)
+![Mermaid Diagram](./diagrams/4_Client_Agent_6.svg)
 
 ### Lifecycle Management
 

docs/design/05_Swarm_Management.md

@@ -15,27 +15,27 @@ A swarm is a collection of agents organized under a single orchestration unit th
 
 ### Swarm Component Structure
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_0.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_0.svg)
 
 ### Swarm Schema and Configuration
 
 Swarms are defined using the `ISwarmSchema` interface, which specifies the agent collection, default agent, and behavioral configuration:
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_1.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_1.svg)
 
 ## Agent Navigation and Routing
 
 The swarm manages navigation between agents through a navigation stack and active agent tracking. This allows for complex conversation flows where different agents handle different aspects of a conversation.
 
 ### Navigation Stack Management
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_2.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_2.svg)
 
 ### Agent Resolution and Error Handling
 
 The swarm uses a `NoopAgent` fallback mechanism when requested agents are not found in the swarm configuration:
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_3.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_3.svg)
 
 The `NoopAgent` class provides a safety mechanism that logs attempts to use non-existent agents while delegating operations to the default agent.
 
@@ -45,46 +45,46 @@ The swarm maintains an active agent that handles incoming messages and executes
 
 ### Active Agent Resolution
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_4.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_4.svg)
 
 ## Message Flow and Output Handling
 
 Swarms coordinate message flow between agents and manage output emission to external consumers through a subject-based event system.
 
 ### Message Execution Flow
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_5.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_5.svg)
 
 ### Output Subject Management
 
 The `ClientSwarm` uses Subject patterns for asynchronous output handling and coordination:
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_6.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_6.svg)
 
 ## Integration with Service Layer
 
 Swarms integrate with the service architecture through connection services, validation services, and schema services to provide a complete orchestration platform.
 
 ### Service Layer Integration
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_7.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_7.svg)
 
 ### Persistence and State Management
 
 Swarms support persistence of navigation state and active agent information:
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_8.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_8.svg)
 
 ## Configuration and Lifecycle
 
 Swarms are configured through schema definitions and managed through service lifecycle patterns including initialization, memoization, and disposal.
 
 ### Swarm Lifecycle Management
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_9.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_9.svg)
 
 ### Validation and Error Recovery
 
 Swarms include validation mechanisms for agent availability and navigation consistency:
 
-![Mermaid Diagram](./diagrams\5_Swarm_Management_10.svg)
+![Mermaid Diagram](./diagrams/5_Swarm_Management_10.svg)

docs/design/06_Session_and_Chat_Management.md

@@ -13,31 +13,31 @@ For information about individual agent execution within sessions, see [Client Ag
 
 Chat management provides a high-level abstraction over sessions with automatic lifecycle management, inactivity detection, and cleanup. The `ChatUtils` class manages multiple `ChatInstance` objects, each wrapping a session with timeout handling and callback support.
 
-![Mermaid Diagram](./diagrams\6_Session_and_Chat_Management_0.svg)
+![Mermaid Diagram](./diagrams/6_Session_and_Chat_Management_0.svg)
 
 The chat layer handles client lifecycle automatically through `beginChat`, `sendMessage`, and `dispose` operations, with configurable callbacks for monitoring chat events and custom chat adapters.
 
 ## Chat Instance Lifecycle
 
 Chat instances manage their lifecycle automatically with inactivity detection and cleanup. The `ChatInstance` class wraps sessions with timeout handling, callback support, and automatic disposal based on activity patterns.
 
-![Mermaid Diagram](./diagrams\6_Session_and_Chat_Management_2.svg)
+![Mermaid Diagram](./diagrams/6_Session_and_Chat_Management_2.svg)
 
 The lifecycle includes automatic cleanup through `INACTIVITY_CHECK` (60 seconds) and `INACTIVITY_TIMEOUT` (15 minutes) constants, with callback hooks for monitoring chat state changes.
 
 ## Session Lifecycle
 
 Sessions follow a managed lifecycle from creation through disposal, with automatic resource tracking and cleanup. The `SessionConnectionService` uses memoization to cache session instances, while validation services track active sessions for proper resource management.
 
-![Mermaid Diagram](./diagrams\6_Session_and_Chat_Management_3.svg)
+![Mermaid Diagram](./diagrams/6_Session_and_Chat_Management_3.svg)
 
 The lifecycle includes initialization callbacks, active message processing, and disposal with proper cleanup. Session validation services ensure that resources are properly tracked and prevent memory leaks in long-running applications.
 
 ## Message Processing Flow
 
 Sessions handle bidirectional message flow with policy validation, agent execution, and event emission. The `emit` method sends messages to clients via swarms, while `execute` processes incoming messages through agents and returns responses.
 
-![Mermaid Diagram](./diagrams\6_Session_and_Chat_Management_4.svg)
+![Mermaid Diagram](./diagrams/6_Session_and_Chat_Management_4.svg)
 
 All message flows include policy validation checkpoints. When validation fails, sessions automatically substitute ban messages and log policy violations through the event system.
 
@@ -89,7 +89,7 @@ The session schema extends `ISwarmSessionCallbacks` to provide lifecycle hooks f
 
 Sessions coordinate agent execution through swarms, managing the handoff between session-level message processing and agent-level tool execution. The `execute` method delegates to swarm agents while maintaining session context and policy enforcement.
 
-![Mermaid Diagram](./diagrams\6_Session_and_Chat_Management_5.svg)
+![Mermaid Diagram](./diagrams/6_Session_and_Chat_Management_5.svg)
 
 Sessions maintain execution context across agent transitions, ensuring proper client identification and session state preservation during complex multi-agent workflows.
 
@@ -117,6 +117,6 @@ Event types include `"emit"`, `"execute"`, `"connect"`, and `"dispose"` with ses
 
 Sessions implement comprehensive resource management with automatic cleanup, validation tracking, and memoization clearing. The disposal process ensures proper resource release and prevents memory leaks in long-running applications.
 
-![Mermaid Diagram](./diagrams\6_Session_and_Chat_Management_6.svg)
+![Mermaid Diagram](./diagrams/6_Session_and_Chat_Management_6.svg)
 
 The disposal process includes validation service cleanup, callback execution, and memoization clearing to ensure complete resource release. Sessions automatically handle cleanup of associated agents, histories, and event subscriptions.

docs/design/07_Model_Context_Protocol_MCP.md

@@ -15,7 +15,7 @@ The MCP system follows a layered architecture that separates tool definition, co
 
 ### MCP System Architecture
 
-![Mermaid Diagram](./diagrams\7_Model_Context_Protocol_MCP_0.svg)
+![Mermaid Diagram](./diagrams/7_Model_Context_Protocol_MCP_0.svg)
 
 ## Core Components
 
@@ -71,7 +71,7 @@ The `ClientMCP` class provides the primary implementation of the MCP protocol wi
 
 ### MCP Implementation Flow
 
-![Mermaid Diagram](./diagrams\7_Model_Context_Protocol_MCP_1.svg)
+![Mermaid Diagram](./diagrams/7_Model_Context_Protocol_MCP_1.svg)
 
 The `ClientMCP` constructor initializes the MCP with parameters and triggers the `onInit` callback. Tools are fetched and cached using a memoized function keyed by client ID.
 
@@ -118,7 +118,7 @@ The `MCPPublicService` provides a context-aware public API that wraps MCP operat
 
 ### Tool Call Processing
 
-![Mermaid Diagram](./diagrams\7_Model_Context_Protocol_MCP_2.svg)
+![Mermaid Diagram](./diagrams/7_Model_Context_Protocol_MCP_2.svg)
 
 When a tool returns a string output, it's automatically committed to the agent using `commitToolOutput`. If the tool call is marked as the last in a sequence (`dto.isLast`), the agent execution continues. Error handling stops tool execution and flushes the agent buffer.