updates for november release, prepping

Author: chrishayuk

README.md

@@ -207,6 +207,18 @@ Runs the same on macOS, Linux, and Windows — locally, serverside, and inside c
 | **LLM Providers** | OpenAI, Anthropic, Local models | Any LLM that outputs tool calls |
 | **MCP Transports** | HTTP Streamable, STDIO, SSE | All MCP 1.0 transports |
 | **MCP Servers** | Notion, SQLite, Atlassian, Echo, Custom | Any MCP-compliant server |
+| **MCP Specification** | 2025-11-25, 2025-06-18, 2025-03-26 | Full support via chuk-mcp 0.9 |
+
+**MCP Protocol Support:**
+- ✅ MCP Spec versions: 2025-11-25 (November), 2025-06-18, 2025-03-26
+- ✅ Transports: HTTP Streamable, STDIO, SSE
+- ✅ Core operations: tools/call, tools/list, resources/list, resources/read, prompts/list, prompts/get
+- ✅ Icon metadata for tools, resources, and prompts (2025-11-25)
+- ✅ Structured content in tool results (2025-06-18)
+- ✅ OAuth 2.1 with PKCE and automatic token refresh
+- ✅ Session persistence and reconnection handling
+- ⏳ Tasks (experimental in 2025-11-25) - awaiting chuk-mcp support
+- ⏳ Sampling with tool invocation - server-side feature
 
 **Tested Configurations:**
 - ✅ macOS 14+ (Apple Silicon & Intel)

src/chuk_tool_processor/mcp/register_mcp_tools.py

@@ -68,6 +68,10 @@ async def register_mcp_tools(
             "argument_schema": tool_def.get("inputSchema", {}),
         }
 
+        # Add icon if present (MCP spec 2025-11-25)
+        if "icon" in tool_def:
+            meta["icon"] = tool_def["icon"]
+
         try:
             # Create MCPTool wrapper with optional resilience configuration
             wrapper = MCPTool(

src/chuk_tool_processor/mcp/stream_manager.py

@@ -36,7 +36,7 @@ class StreamManager:
     Updated to support the latest transports:
     - STDIO (process-based)
     - SSE (Server-Sent Events) with headers support
-    - HTTP Streamable (modern replacement for SSE, spec 2025-03-26) with graceful headers handling
+    - HTTP Streamable (modern replacement for SSE, spec 2025-11-25) with graceful headers handling
     """
 
     def __init__(self, timeout_config: TimeoutConfig | None = None) -> None:
@@ -197,7 +197,7 @@ async def initialize(
                         params, server_timeout = await load_config(config_file, server_name)
                         # Use per-server timeout if specified, otherwise use global default
                         effective_timeout = server_timeout if server_timeout is not None else default_timeout
-                        logger.info(
+                        logger.debug(
                             f"Server '{server_name}' using timeout: {effective_timeout}s (per-server: {server_timeout}, default: {default_timeout})"
                         )
                         # Use initialization_timeout for connection_timeout since subprocess
@@ -250,6 +250,13 @@ async def initialize(
                             session_id = None
                             logger.debug("No URL configured for HTTP Streamable transport, using default: %s", http_url)
 
+                        # IMPORTANT: If transport already exists for this server, preserve its session ID
+                        if server_name in self.transports:
+                            existing_transport = self.transports[server_name]
+                            if hasattr(existing_transport, "session_id") and existing_transport.session_id:
+                                session_id = existing_transport.session_id
+                                logger.debug(f"Preserving session ID for {server_name}: {session_id}")
+
                         # Build HTTP transport (headers not supported yet)
                         transport_params = {
                             "url": http_url,

src/chuk_tool_processor/mcp/transport/http_streamable_transport.py

@@ -145,8 +145,8 @@ async def _test_connection_health(self) -> bool:
 
     async def initialize(self) -> bool:
         """Initialize with enhanced error handling and health monitoring."""
-        if self._initialized:
-            logger.warning("Transport already initialized")
+        if self._initialized and self._http_transport:
+            logger.debug("Transport already initialized, reusing existing connection")
             return True
 
         start_time = time.time()
@@ -164,11 +164,15 @@ async def initialize(self) -> bool:
 
             # Create StreamableHTTPParameters with minimal configuration
             # NOTE: Keep params minimal - extra params can break message routing
+            # IMPORTANT: Pass session_id if we have one from a previous connection
+            if self.session_id:
+                logger.debug(f"Creating transport with existing session ID: {self.session_id}")
             http_params = StreamableHTTPParameters(
                 url=self.url,
                 timeout=self.default_timeout,
                 headers=headers,
                 enable_streaming=True,
+                session_id=self.session_id,  # Reuse session ID if available
             )
 
             # Create and store transport (will be managed via async with in parent scope)
@@ -214,6 +218,16 @@ async def initialize(self) -> bool:
                 self._last_successful_ping = time.time()
                 self._consecutive_failures = 0
 
+                # CRITICAL: Extract and persist session ID from transport
+                # This allows stateful MCP servers to maintain user sessions across requests
+                if self._http_transport:
+                    extracted_session_id = self._http_transport.get_session_id()
+                    print(f"DEBUG: Extracted session ID from transport: {extracted_session_id}")
+                    if extracted_session_id and extracted_session_id != self.session_id:
+                        self.session_id = extracted_session_id
+                        print(f"✓ Session ID established: {self.session_id}")
+                        logger.info(f"Session ID established: {self.session_id}")
+
                 total_init_time = time.time() - start_time
                 if self.enable_metrics and self._metrics:
                     self._metrics.initialization_time = total_init_time
@@ -294,10 +308,14 @@ async def close(self) -> None:
 
     async def _cleanup(self) -> None:
         """Enhanced cleanup with state reset."""
+        # IMPORTANT: Preserve session_id across cleanup/reconnection
+        # Session IDs must persist for the lifetime of the StreamableTransport object
+        print(f"DEBUG: _cleanup() called on object {id(self)}, preserving session_id={self.session_id}")
         self._http_transport = None
         self._read_stream = None
         self._write_stream = None
         self._initialized = False
+        # NOTE: We do NOT reset self.session_id here - it should persist across reconnections
 
     async def send_ping(self) -> bool:
         """Enhanced ping with health monitoring (like SSE)."""
@@ -471,6 +489,14 @@ async def call_tool(
                 self._consecutive_failures = 0
                 self._last_successful_ping = time.time()  # Update health timestamp
 
+                # Extract and persist session ID after successful calls
+                # This ensures we maintain session state even if it changes mid-session
+                if self._http_transport:
+                    current_session_id = self._http_transport.get_session_id()
+                    if current_session_id and current_session_id != self.session_id:
+                        self.session_id = current_session_id
+                        logger.debug(f"Session ID updated: {self.session_id}")
+
             if self.enable_metrics:
                 self._update_metrics(response_time, not result.get("isError", False))
 

src/chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -175,7 +175,7 @@ async def _monitor_process_health(self) -> bool:
     async def initialize(self) -> bool:
         """Enhanced initialization with process monitoring."""
         if self._initialized:
-            logger.warning("Transport already initialized")
+            logger.debug("Transport already initialized")
             return True
 
         start_time = time.time()
@@ -252,7 +252,7 @@ async def _attempt_recovery(self) -> bool:
             self._metrics["recovery_attempts"] += 1
             self._metrics["process_restarts"] += 1
 
-        logger.warning("Attempting STDIO process recovery...")
+        logger.debug("Attempting STDIO process recovery...")
 
         try:
             # Force cleanup of existing process
@@ -374,7 +374,7 @@ def is_connected(self) -> bool:
 
         # Check for too many consecutive failures (like SSE)
         if self._consecutive_failures >= self._max_consecutive_failures:
-            logger.warning("Connection marked unhealthy after %d failures", self._consecutive_failures)
+            logger.debug("Connection marked unhealthy after %d failures", self._consecutive_failures)
             return False
 
         return True
@@ -467,7 +467,7 @@ async def call_tool(
 
             # Enhanced connection check with recovery attempt
             if not self.is_connected():
-                logger.warning("Connection unhealthy, attempting recovery...")
+                logger.debug("Connection unhealthy, attempting recovery...")
                 if not await self._attempt_recovery():
                     if self.enable_metrics:
                         self._update_metrics(time.time() - start_time, False)

src/chuk_tool_processor/models/tool_spec.py

@@ -75,6 +75,7 @@ class ToolSpec(BaseModel):
     license: str | None = Field(None, description="License (e.g., 'MIT', 'Apache-2.0')")
     documentation_url: str | None = Field(None, description="Link to full documentation")
     source_url: str | None = Field(None, description="Link to source code")
+    icon: str | None = Field(None, description="Icon URI or data URL for tool (MCP spec 2025-11-25)")
 
     # Execution hints
     estimated_duration_seconds: float | None = Field(

tests/mcp/transport/test_http_streamable.py

@@ -549,6 +549,7 @@ def test_init_with_session_id(self):
     async def test_initialize_already_initialized(self, transport):
         """Test initialization when already initialized."""
         transport._initialized = True
+        transport._http_transport = Mock()  # Mock the transport object
         result = await transport.initialize()
         assert result is True