Merge branch '1.x'

# Conflicts:
#	src/Transports/SseTransport.php

Author: klapaudius

CHANGELOG.md

@@ -1,3 +1,15 @@
+### Version 1.2.0
+
+- **Core Features:**
+  - Add real-time communication support through Streamable Http
+  - Add Streaming Tool Support
+  - Add TextToolResult, AudioToolResult, ImageToolResult and ResourceToolResult to properly manage tool returns
+  - Both SSE and StreamableHttp can be active that makes clients able to use the old protocol version
+- **Deprecations:**
+  - Configuration key `klp_mcp_server.server_provider` is replaced by `klp_mcp_server.server_providers` to maintain backward compatibility
+  for clients that does not support the `2025-03-26` protocol version yet.
+  - The ToolInterface is deprecated. Use StreamableToolInterface instead.
+
 ### Version 1.1.0
 
 - **Core Features:**

CLAUDE.md

@@ -0,0 +1,92 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Symfony bundle that enables developers to seamlessly add a Model Context Protocol (MCP) server to their Symfony applications. The main goal is to provide a production-ready implementation following the official MCP specifications at https://modelcontextprotocol.io/specification/2025-03-26.
+
+The bundle allows Symfony applications to expose tools and resources that can be consumed by Large Language Models (LLMs) through secure transport protocols (SSE and StreamableHTTP), avoiding the security risks of STDIO transport in enterprise environments.
+
+## Commands
+
+### Testing
+```bash
+# Run all tests
+vendor/bin/phpunit
+
+# Run a specific test file
+vendor/bin/phpunit tests/path/to/TestFile.php
+
+# Generate code coverage
+vendor/bin/phpunit --coverage-html build/coverage
+
+# Run PHPStan static analysis
+vendor/bin/phpstan analyse
+```
+
+### Development Tools
+```bash
+# Create a new MCP tool
+php bin/console make:mcp-tool MyCustomTool
+
+# Test a specific MCP tool
+php bin/console mcp:test-tool MyCustomTool
+
+# Test tool with specific input
+php bin/console mcp:test-tool MyCustomTool --input='{"param":"value"}'
+
+# List all available tools
+php bin/console mcp:test-tool --list
+```
+
+### MCP Inspector
+```bash
+# Run the MCP Inspector for visual testing
+npx @modelcontextprotocol/inspector node build/index.js
+```
+
+## Architecture Overview
+
+### Package Structure
+This is a Symfony bundle that implements the Model Context Protocol (MCP) server. It provides:
+
+- **Dual Transport Support**: Both SSE (Server-Sent Events) and StreamableHTTP protocols
+- **Tool System**: Extensible framework for creating MCP tools that LLMs can invoke
+- **Resource System**: Management of resources that can be exposed to LLM clients
+- **Progress Notifications**: Real-time progress updates for long-running operations
+
+### Key Components
+
+#### Transport Layer
+- **SSE Transport**: Uses Server-Sent Events with a pub/sub pattern via adapters (Cache or Redis)
+- **StreamableHTTP Transport**: Direct HTTP-based communication supporting both streaming and non-streaming responses
+- **Adapter System**: Abstraction layer allowing different message brokers (Cache, Redis)
+
+#### Tool System
+- **BaseToolInterface**: Core interface for all tools (deprecated in favor of StreamableToolInterface)
+- **StreamableToolInterface**: Modern interface supporting progress notifications
+- **ToolResultInterface**: Abstraction for different result types (Text, Image, Audio, Resource)
+- **ProgressNotifier**: System for sending real-time progress updates during tool execution
+
+#### Request Handlers
+- Located in `src/Server/Request/`: Handle different MCP protocol methods
+- Each handler implements specific MCP operations (initialize, tools/list, tools/call, etc.)
+
+#### Protocol Implementation
+- **MCPProtocol**: Core protocol implementation handling request/response flow
+- **RequestHandler/NotificationHandler**: Process different message types
+- **MCPServer**: Main server orchestrating all components
+
+### Configuration
+- Main config: `config/packages/klp_mcp_server.yaml`
+- Tools and resources are registered in configuration
+- Supports multiple adapters for SSE transport
+
+## Important Notes
+
+- **Cannot use** `symfony server:start` - requires proper web server (Nginx/Apache + PHP-FPM) for concurrent connections
+- Tools should implement `StreamableToolInterface` for modern features
+- Progress notifications only work with streaming tools (`isStreaming()` returns true)
+- All types should use `string|null` syntax instead of `?string` (null at the end)
+- Follow PSR-12 coding standards and include PHPDoc for all public methods

README.md

@@ -15,32 +15,34 @@
 
 ## Overview
 
-Symfony MCP Server is a powerful package designed to streamline the implementation of Model Context Protocol (MCP) servers in Symfony applications. This package **utilizes Server-Sent Events (SSE)** transport, providing a secure and controlled integration method.
+Symfony MCP Server is a powerful package designed to streamline the implementation of Model Context Protocol (MCP) servers in Symfony applications. This package **utilizes StreamableHTTP and/or Server-Sent Events (SSE)** transport, providing a secure and controlled integration methods.
 
-### Why SSE instead of STDIO?
+### Why not STDIO?
 
 While stdio is straightforward and widely used in MCP implementations, it has significant security implications for enterprise environments:
 
 - **Security Risk**: STDIO transport potentially exposes internal system details and API specifications
 - **Data Protection**: Organizations need to protect proprietary API endpoints and internal system architecture
-- **Control**: SSE offers better control over the communication channel between LLM clients and your application
+- **Control**: StreamableHTTP or SSE offers better control over the communication channel between LLM clients and your application
 
-By implementing the MCP server with SSE transport, enterprises can:
+By implementing the MCP server with StreamableHTTP or SSE transport, enterprises can:
 
 - Expose only the necessary tools and resources while keeping proprietary API details private
 - Maintain control over authentication and authorization processes
 
 Key benefits:
 
-- Seamless and rapid implementation of SSE in existing Symfony projects
+- Seamless and rapid implementation of StreamableHTTP and/or SSE in existing Symfony projects
 - Support for the latest Symfony and PHP versions
 - Efficient server communication and real-time data processing
 - Enhanced security for enterprise environments
 
 ## Key Features
 
-- Real-time communication support through Server-Sent Events (SSE) integration specified in the MCP 2024-11-05 version (Streamable HTTP from 2025-03-26 version is planned)
+- Real-time communication support through StreamableHTTP and/or Server-Sent Events (SSE) integration
 - Implementation of tools and resources compliant with Model Context Protocol specifications
+- Support of streaming tools with progres notifications
+- Support different types of tool results such as Text, Image, Audio, or Resource
 - Adapter-based design architecture with Pub/Sub messaging pattern
 
 ## Requirements
@@ -62,14 +64,15 @@ Key benefits:
         ping:
             enabled: true  # Read the warning section in the default configuration file before disable it
             interval: 30
-        server_provider: 'sse'
+        server_providers: ['streamable_http','sse']
         sse_adapter: 'cache'
         adapters:
             cache:
                 prefix: 'mcp_sse_'
                 ttl: 100
         tools:
             - KLP\KlpMcpServer\Services\ToolService\Examples\HelloWorldTool
+            - KLP\KlpMcpServer\Services\ToolService\Examples\StreamingDataTool
             - KLP\KlpMcpServer\Services\ToolService\Examples\VersionCheckTool
         resources:
             - KLP\KlpMcpServer\Services\ResourceService\Examples\HelloWorldResource
@@ -97,6 +100,7 @@ klp_mcp_server:
 
 - **Streaming Endpoint for MCP Clients**: `GET /{default_path}/sse`
 - **Request Submission Endpoint**: `POST /{default_path}/messages`
+- **Streamable HTTP Endpoint**: `GET|POST /{default_path}`
 
 ### Docker Setup (Optional)
 
@@ -127,9 +131,12 @@ This command:
 You can also manually create and register tools in `config/packages/klp_mcp_server.yaml`:
 
 ```php
-use KLP\KlpMcpServer\Services\ToolService\ToolInterface;
+use KLP\KlpMcpServer\Services\ProgressService\ProgressNotifierInterface;
+use KLP\KlpMcpServer\Services\ToolService\Annotation\ToolAnnotation;
+use KLP\KlpMcpServer\Services\ToolService\Result\ToolResultInterface;
+use KLP\KlpMcpServer\Services\ToolService\StreamableToolInterface;
 
-class MyCustomTool implements ToolInterface
+class MyCustomTool implements StreamableToolInterface
 {
     // Tool implementation
 }
@@ -155,6 +162,7 @@ This helps you rapidly develop and debug tools by:
 - Showing the tool's input schema and validating inputs
 - Executing the tool with your provided input
 - Displaying formatted results or detailed error information
+- Displaying progress notifications for streaming tool
 - Supporting complex input types including objects and arrays
 
 **For deep diving into tools creation please take a look at dedicated documentation [Here](https://github.com/klapaudius/symfony-mcp-server/blob/master/docs/building_tools.md)**
@@ -178,15 +186,19 @@ This will typically open a web interface at `localhost:6274`. To test your MCP s
 2. In the Inspector interface, enter your Symfony server's MCP SSE URL (e.g., `http://localhost:8000/mcp/sse`)  
 3. Connect and explore available tools visually
 
-The SSE URL follows the pattern: `http(s)://[your-web-server]/[default_path]/sse` where `default_path` is defined in your `config/packages/klp_mcp_server.yaml` file.
+|  MCP Specification version   | Connection Url pattern                           |
+|:----------------------------:|--------------------------------------------------|
+|       2024-11-05 (SSE)       | `http(s)://[your-web-server]/[default_path]/sse` |
+| 2025-03-26 (Streamable HTTP) | `http(s)://[your-web-server]/[default_path]`     |
+`default_path` is defined in your `config/packages/klp_mcp_server.yaml` file.
 
 ## Advanced Features
 
-### Pub/Sub Architecture with SSE Adapters
+### Pub/Sub Architecture with Adapters
 
 The package implements a publish/subscribe (pub/sub) messaging pattern through its adapter system:
 
-1. **Publisher (Server)**: When clients send requests to the `/messages` endpoint, the server processes these requests and publishes responses through the configured adapter.
+1. **Publisher (Server)**: When clients send requests (e.g. `/messages` endpoint for SSE connection), the server processes these requests and publishes responses through the configured adapter.
 
 2. **Message Broker (Adapter)**: The adapter maintains message queues for each client, identified by unique client IDs. This provides a reliable asynchronous communication layer.
 
@@ -282,8 +294,8 @@ We are committed to actively pursuing the following key initiatives to enhance t
 
 - **Core Features:**
   - ✅ Resources implementation compliant with MCP specification.
-  - Support for Streamable HTTP (as specified in MCP 2025-03-26 version).
-  - Prompts implementation compliant with MCP specification.
+  - ✅ Support for Streamable HTTP (as specified in MCP 2025-03-26 version).
+  - ⏳️ Prompts implementation compliant with MCP specification.
 - **Additional Adaptaters:**
   - Support for more Pub/Sub adapters (e.g., RabbitMQ).