alita-sdk 0.3.447__tar.gz → 0.3.448__tar.gz

{alita_sdk-0.3.447 → alita_sdk-0.3.448}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.447
+Version: 0.3.448
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.447 → alita_sdk-0.3.448}/alita_sdk/runtime/toolkits/mcp.py

@@ -402,12 +402,9 @@ class McpToolkit(BaseToolkit):
                 ]
 
             # Create BaseTool instances from discovered metadata
-            # Use session_id from discovery (which may have been created if server requires it)
-            # If discovery returned a session_id, it means a new session was created
-            # Log it so UI can capture and store it
+            # Use session_id from frontend (passed via connection_config)
             if session_id:
-                logger.info(f"[MCP Session] Using session from discovery: {session_id}")
-                logger.info(f"[MCP Session] Session created - server: {canonical_resource(connection_config.url)}, session_id: {session_id}")
+                logger.info(f"[MCP Session] Using session_id from frontend: {session_id}")
             
             for tool_metadata in tool_metadata_list:
                 server_tool = cls._create_tool_from_dict(
@@ -468,47 +465,22 @@ class McpToolkit(BaseToolkit):
         """
         all_tools = []
         
-        # Check if we have a session_id from UI (passed via connection_config)
-        # If not, we'll try discovery without session first, and create one if needed
+        # Use session_id from UI (passed via connection_config)
+        # For SSE-based MCP servers, frontend generates a UUID and sends it with the OAuth token
         session_id = connection_config.session_id
         
-        # Discover regular tools - if server requires session and we don't have one, this will fail
-        # and we'll catch it below to initialize a session
-        try:
-            tools_data = cls._discover_mcp_endpoint(
-                endpoint="tools/list",
-                toolkit_name=toolkit_name,
-                connection_config=connection_config,
-                timeout=timeout,
-                session_id=session_id
-            )
-        except Exception as discovery_error:
-            # Check if error is due to missing session
-            if "Missing sessionId" in str(discovery_error) and not session_id:
-                logger.info(f"[MCP Session] Server requires session for discovery, initializing...")
-                # Try to initialize session if we have OAuth headers
-                session_id = cls._initialize_mcp_session(
-                    toolkit_name=toolkit_name,
-                    connection_config=connection_config,
-                    timeout=timeout,
-                    extra_headers=connection_config.headers  # Use headers from connection_config
-                )
-                
-                if session_id:
-                    logger.info(f"[MCP Session] Created session for discovery: {session_id}")
-                    # Retry discovery with session
-                    tools_data = cls._discover_mcp_endpoint(
-                        endpoint="tools/list",
-                        toolkit_name=toolkit_name,
-                        connection_config=connection_config,
-                        timeout=timeout,
-                        session_id=session_id
-                    )
-                else:
-                    logger.error(f"[MCP Session] Failed to create session for discovery")
-                    raise discovery_error
-            else:
-                raise
+        if not session_id:
+            logger.warning(f"[MCP Session] No session_id provided for '{toolkit_name}' - server may require it")
+            logger.warning(f"[MCP Session] Frontend should generate a UUID and include it with mcp_tokens")
+        
+        # Discover regular tools
+        tools_data = cls._discover_mcp_endpoint(
+            endpoint="tools/list",
+            toolkit_name=toolkit_name,
+            connection_config=connection_config,
+            timeout=timeout,
+            session_id=session_id
+        )
         all_tools.extend(tools_data)
         logger.info(f"Discovered {len(tools_data)} tools from MCP toolkit '{toolkit_name}'")
         
@@ -554,106 +526,6 @@ class McpToolkit(BaseToolkit):
         logger.info(f"Total discovered {len(all_tools)} tools+prompts from MCP toolkit '{toolkit_name}'")
         return all_tools, session_id
 
-    @classmethod
-    def _initialize_mcp_session(
-        cls,
-        toolkit_name: str,
-        connection_config: McpConnectionConfig,
-        timeout: int,
-        extra_headers: Optional[Dict[str, str]] = None
-    ) -> Optional[str]:
-        """
-        Initialize an MCP session for stateful SSE servers.
-        Returns sessionId if successful, None if server doesn't require sessions.
-        
-        Note: This session should be stored by the caller (e.g., UI sessionStorage)
-        and passed back for subsequent requests. Sessions should NOT be cached
-        on the backend for security reasons (multi-tenant environment).
-        
-        Args:
-            toolkit_name: Name of the toolkit
-            connection_config: MCP connection configuration
-            timeout: Request timeout in seconds
-            extra_headers: Additional headers (e.g., Authorization) to include
-        """
-        import time
-
-        mcp_request = {
-            "jsonrpc": "2.0",
-            "id": f"initialize_{int(time.time())}",
-            "method": "initialize",
-            "params": {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {
-                    "roots": {"listChanged": True},
-                    "sampling": {}
-                },
-                "clientInfo": {
-                    "name": "Alita MCP Client",
-                    "version": "1.0.0"
-                }
-            }
-        }
-
-        headers = {
-            "Content-Type": "application/json",
-            "Accept": "application/json, text/event-stream"
-        }
-        if connection_config.headers:
-            headers.update(connection_config.headers)
-        if extra_headers:
-            headers.update(extra_headers)
-            logger.debug(f"[MCP Session] Added extra headers: {list(extra_headers.keys())}")
-
-        try:
-            logger.info(f"[MCP Session] Attempting to initialize session for {connection_config.url}")
-            logger.debug(f"[MCP Session] Initialize request: {mcp_request}")
-            response = requests.post(
-                connection_config.url,
-                json=mcp_request,
-                headers=headers,
-                timeout=timeout
-            )
-
-            logger.info(f"[MCP Session] Initialize response status: {response.status_code}")
-            if response.status_code == 200:
-                # Parse the response to extract sessionId
-                content_type = response.headers.get('Content-Type', '')
-                logger.debug(f"[MCP Session] Response Content-Type: {content_type}")
-                
-                if 'text/event-stream' in content_type:
-                    data = cls._parse_sse_response(response.text)
-                elif 'application/json' in content_type:
-                    data = response.json()
-                else:
-                    logger.warning(f"[MCP Session] Unexpected Content-Type during initialize: {content_type}")
-                    logger.debug(f"[MCP Session] Response text: {response.text[:500]}")
-                    return None
-
-                logger.debug(f"[MCP Session] Parsed response: {data}")
-                
-                # Extract sessionId from response
-                result = data.get("result", {})
-                session_id = result.get("sessionId")
-                if session_id:
-                    logger.info(f"[MCP Session] ✓ Session initialized for '{toolkit_name}': {session_id}")
-                    logger.info(f"[MCP Session] This sessionId should be stored by the caller and sent back for subsequent requests")
-                    return session_id
-                else:
-                    logger.info(f"[MCP Session] No sessionId in initialize response for '{toolkit_name}' - server may not require sessions")
-                    logger.debug(f"[MCP Session] Full result: {result}")
-                    return None
-            else:
-                logger.warning(f"[MCP Session] Initialize returned {response.status_code} for '{toolkit_name}' - server may not support sessions")
-                logger.debug(f"[MCP Session] Response: {response.text[:500]}")
-                return None
-
-        except Exception as e:
-            logger.warning(f"[MCP Session] Failed to initialize MCP session for '{toolkit_name}': {e} - proceeding without session")
-            import traceback
-            logger.debug(f"[MCP Session] Traceback: {traceback.format_exc()}")
-            return None
-
     @classmethod
     def _discover_mcp_endpoint(
         cls,

{alita_sdk-0.3.447 → alita_sdk-0.3.448}/alita_sdk/runtime/tools/mcp_remote_tool.py

@@ -188,49 +188,11 @@ class McpRemoteTool(McpServerTool):
                         error_text = await response.text()
                         
                         # Check if this is a "Missing sessionId" error
-                        if response.status == 404 and "sessionId" in error_text and not self.session_id:
-                            logger.info(f"[MCP Session] Server requires session but none provided - attempting to initialize")
-                            # Try to initialize session with current auth headers
-                            from ..toolkits.mcp import McpToolkit
-                            from ..models.mcp_models import McpConnectionConfig
-                            
-                            connection_config = McpConnectionConfig(
-                                url=self.server_url,
-                                headers=self.server_headers
-                            )
-                            
-                            # Initialize session with auth headers
-                            session_id = McpToolkit._initialize_mcp_session(
-                                toolkit_name=self.server,
-                                connection_config=connection_config,
-                                timeout=self.tool_timeout_sec,
-                                extra_headers=headers  # Include Authorization header
-                            )
-                            
-                            if session_id:
-                                # Retry the request with session
-                                self.session_id = session_id
-                                # Update metadata so callbacks can access session info
-                                self._update_metadata_with_session()
-                                separator = '&' if '?' in self.server_url else '?'
-                                retry_url = f"{self.server_url}{separator}sessionId={session_id}"
-                                logger.info(f"[MCP Session] Retrying tool call with new session: {session_id}")
-                                logger.info(f"[MCP Session] Created session - server: {canonical_resource(self.server_url)}, session_id: {session_id}")
-                                
-                                async with session.post(retry_url, json=mcp_request, headers=headers) as retry_response:
-                                    if retry_response.status != 200:
-                                        retry_error = await retry_response.text()
-                                        raise Exception(f"HTTP {retry_response.status} (after session init): {retry_error}")
-                                    
-                                    # Process successful retry response
-                                    content_type = retry_response.headers.get('Content-Type', '')
-                                    if 'text/event-stream' in content_type:
-                                        text = await retry_response.text()
-                                        data = self._parse_sse(text)
-                                    else:
-                                        data = await retry_response.json()
-                            else:
-                                raise Exception(f"HTTP {response.status}: {error_text} (session initialization failed)")
+                        if response.status == 404 and "sessionId" in error_text:
+                            logger.error(f"[MCP Session] Server requires session but none provided")
+                            logger.error(f"[MCP Session] Frontend must generate a UUID and send it with mcp_tokens")
+                            logger.error(f"[MCP Session] Example: mcp_tokens = {{'server_url': {{'access_token': '...', 'session_id': crypto.randomUUID()}}}}")
+                            raise Exception(f"HTTP {response.status}: {error_text} - sessionId required but not provided by frontend")
                         else:
                             raise Exception(f"HTTP {response.status}: {error_text}")
                     

{alita_sdk-0.3.447 → alita_sdk-0.3.448}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.447
+Version: 0.3.448
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.447 → alita_sdk-0.3.448}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.447"
+version = "0.3.448"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"