alita-sdk 0.3.437__tar.gz → 0.3.439__tar.gz

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.437
+Version: 0.3.439
 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.437 → alita_sdk-0.3.439}/alita_sdk/runtime/clients/client.py

@@ -303,7 +303,7 @@ class AlitaClient:
                     app_type=None, memory=None, runtime='langchain',
                     application_variables: Optional[dict] = None,
                     version_details: Optional[dict] = None, store: Optional[BaseStore] = None,
-                    llm: Optional[ChatOpenAI] = None):
+                    llm: Optional[ChatOpenAI] = None, mcp_tokens: Optional[dict] = None):
         if tools is None:
             tools = []
         if chat_history is None:
@@ -344,11 +344,11 @@ class AlitaClient:
             app_type = "react"
         if runtime == 'nonrunnable':
             return LangChainAssistant(self, data, llm, chat_history, app_type,
-                                      tools=tools, memory=memory, store=store)
+                                      tools=tools, memory=memory, store=store, mcp_tokens=mcp_tokens)
         if runtime == 'langchain':
             return LangChainAssistant(self, data, llm,
                                       chat_history, app_type,
-                                      tools=tools, memory=memory, store=store).runnable()
+                                      tools=tools, memory=memory, store=store, mcp_tokens=mcp_tokens).runnable()
         elif runtime == 'llama':
             raise NotImplementedError("LLama runtime is not supported")
 
@@ -568,7 +568,8 @@ class AlitaClient:
     def predict_agent(self, llm: ChatOpenAI, instructions: str = "You are a helpful assistant.",
                       tools: Optional[list] = None, chat_history: Optional[List[Any]] = None,
                       memory=None, runtime='langchain', variables: Optional[list] = None,
-                      store: Optional[BaseStore] = None, debug_mode: Optional[bool] = False):
+                      store: Optional[BaseStore] = None, debug_mode: Optional[bool] = False,
+                      mcp_tokens: Optional[dict] = None):
         """
         Create a predict-type agent with minimal configuration.
 
@@ -604,8 +605,17 @@ class AlitaClient:
             'tools': tools,  # Tool configs that will be processed by get_tools()
             'variables': variables
         }
-        return LangChainAssistant(self, agent_data, llm,
-                                  chat_history, "predict", memory=memory, store=store, debug_mode=debug_mode).runnable()
+        return LangChainAssistant(
+            self,
+            agent_data,
+            llm,
+            chat_history,
+            "predict",
+            memory=memory,
+            store=store,
+            debug_mode=debug_mode,
+            mcp_tokens=mcp_tokens
+        ).runnable()
 
     def test_toolkit_tool(self, toolkit_config: dict, tool_name: str, tool_params: dict = None,
                           runtime_config: dict = None, llm_model: str = None,

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/alita_sdk/runtime/langchain/assistant.py

@@ -31,7 +31,8 @@ class Assistant:
                  tools: Optional[list] = [],
                  memory: Optional[Any] = None,
                  store: Optional[BaseStore] = None,
-                 debug_mode: Optional[bool] = False):
+                 debug_mode: Optional[bool] = False,
+                 mcp_tokens: Optional[dict] = None):
 
         self.app_type = app_type
         self.memory = memory
@@ -89,7 +90,14 @@ class Assistant:
             for internal_tool_name in meta.get("internal_tools"):
                 version_tools.append({"type": "internal_tool", "name": internal_tool_name})
 
-        self.tools = get_tools(version_tools, alita_client=alita, llm=self.client, memory_store=self.store, debug_mode=debug_mode)
+        self.tools = get_tools(
+            version_tools,
+            alita_client=alita,
+            llm=self.client,
+            memory_store=self.store,
+            debug_mode=debug_mode,
+            mcp_tokens=mcp_tokens
+        )
         if tools:
             self.tools += tools
         # Handle prompt setup

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/alita_sdk/runtime/toolkits/mcp.py

@@ -7,7 +7,7 @@ Following MCP specification: https://modelcontextprotocol.io/specification/2025-
 import logging
 import re
 import requests
-from typing import List, Optional, Any, Dict, Literal, ClassVar
+from typing import List, Optional, Any, Dict, Literal, ClassVar, Union
 
 from langchain_core.tools import BaseToolkit, BaseTool
 from pydantic import BaseModel, ConfigDict, Field
@@ -17,6 +17,12 @@ from ..tools.mcp_remote_tool import McpRemoteTool
 from ..tools.mcp_inspect_tool import McpInspectTool
 from ...tools.utils import TOOLKIT_SPLITTER, clean_string
 from ..models.mcp_models import McpConnectionConfig
+from ..utils.mcp_oauth import (
+    McpAuthorizationRequired,
+    canonical_resource,
+    extract_resource_metadata_url,
+    fetch_resource_metadata,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -200,11 +206,10 @@ class McpToolkit(BaseToolkit):
                 )
             ),
             timeout=(
-                int,
+                Union[int, str], # TODO: remove one I will figure out why UI sends str
                 Field(
-                    default=60,
-                    ge=1, le=300,
-                    description="Request timeout in seconds"
+                    default=300,
+                    description="Request timeout in seconds (1-3600)"
                 )
             ),
             discovery_mode=(
@@ -218,11 +223,10 @@ class McpToolkit(BaseToolkit):
                 )
             ),
             discovery_interval=(
-                int,
+                Union[int, str],
                 Field(
                     default=300,
-                    ge=60, le=3600,
-                    description="Discovery interval in seconds (for periodic discovery)"
+                    description="Discovery interval in seconds (60-3600, for periodic discovery)"
                 )
             ),
             selected_tools=(
@@ -243,11 +247,10 @@ class McpToolkit(BaseToolkit):
                 )
             ),
             cache_ttl=(
-                int,
+                Union[int, str],
                 Field(
                     default=300,
-                    ge=60, le=3600,
-                    description="Cache TTL in seconds"
+                    description="Cache TTL in seconds (60-3600)"
                 )
             ),
             __config__=ConfigDict(
@@ -309,6 +312,11 @@ class McpToolkit(BaseToolkit):
         if not toolkit_name:
             raise ValueError("toolkit_name is required")
 
+        # Convert numeric parameters that may come as strings from UI
+        timeout = safe_int(timeout, 60)
+        discovery_interval = safe_int(discovery_interval, 300)
+        cache_ttl = safe_int(cache_ttl, 300)
+
         logger.info(f"Creating MCP toolkit: {toolkit_name}")
 
         # Parse headers if they're provided as a JSON string
@@ -407,6 +415,9 @@ class McpToolkit(BaseToolkit):
             logger.error(f"Discovery error details - URL: {connection_config.url}, Timeout: {timeout}s")
 
             # Fallback to static mode if available and not already static
+            if isinstance(e, McpAuthorizationRequired):
+                # Authorization is required; surface upstream so the caller can prompt the user
+                raise
             if client and discovery_mode != "static":
                 logger.info(f"Falling back to static discovery for toolkit '{toolkit_name}'")
                 tools = cls._create_tools_static(toolkit_name, selected_tools, timeout, client)
@@ -532,6 +543,19 @@ class McpToolkit(BaseToolkit):
                 timeout=timeout
             )
 
+            auth_header = response.headers.get('WWW-Authenticate', '')
+            if response.status_code == 401:
+                resource_metadata_url = extract_resource_metadata_url(auth_header)
+                metadata = fetch_resource_metadata(resource_metadata_url, timeout=timeout) if resource_metadata_url else None
+                raise McpAuthorizationRequired(
+                    message=f"MCP server {connection_config.url} requires OAuth authorization",
+                    server_url=canonical_resource(connection_config.url),
+                    resource_metadata_url=resource_metadata_url,
+                    www_authenticate=auth_header,
+                    resource_metadata=metadata,
+                    status=response.status_code,
+                )
+
             if response.status_code != 200:
                 logger.error(f"MCP server returned non-200 status: {response.status_code}")
                 raise Exception(f"HTTP {response.status_code}: {response.text}")
@@ -916,4 +940,4 @@ def get_all_discovered_servers():
     """Get status of all discovered servers."""
     from ..clients.mcp_discovery import get_discovery_service
     service = get_discovery_service()
-    return service.get_server_health()
+    return service.get_server_health()

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/alita_sdk/runtime/toolkits/tools.py

@@ -19,6 +19,7 @@ from ..tools.image_generation import ImageGenerationToolkit
 # Import community tools
 from ...community import get_toolkits as community_toolkits, get_tools as community_tools
 from ...tools.memory import MemoryToolkit
+from ..utils.mcp_oauth import canonical_resource
 from ...tools.utils import TOOLKIT_SPLITTER
 
 logger = logging.getLogger(__name__)
@@ -37,7 +38,7 @@ def get_toolkits():
     return core_toolkits + community_toolkits() + alita_toolkits()
 
 
-def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = None, debug_mode: Optional[bool] = False) -> list:
+def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = None, debug_mode: Optional[bool] = False, mcp_tokens: Optional[dict] = None) -> list:
     prompts = []
     tools = []
 
@@ -109,10 +110,20 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     toolkit_name=tool.get('toolkit_name', ''),
                     **tool['settings']).get_tools())
             elif tool['type'] == 'mcp':
+                settings = dict(tool['settings'])
+                url = settings.get('url')
+                headers = settings.get('headers')
+                token = None
+                if mcp_tokens and url:
+                    token = mcp_tokens.get(canonical_resource(url))
+                if token:
+                    merged_headers = dict(headers) if headers else {}
+                    merged_headers.setdefault('Authorization', f'Bearer {token}')
+                    settings['headers'] = merged_headers
                 tools.extend(McpToolkit.get_toolkit(
                     toolkit_name=tool.get('toolkit_name', ''),
                     client=alita_client,
-                    **tool['settings']).get_tools())
+                    **settings).get_tools())
         except Exception as e:
             logger.error(f"Error initializing toolkit for tool '{tool.get('name', 'unknown')}': {e}", exc_info=True)
             if debug_mode:

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/alita_sdk/runtime/tools/mcp_remote_tool.py

@@ -13,6 +13,12 @@ from typing import Any, Dict, Optional
 
 from .mcp_server_tool import McpServerTool
 from pydantic import Field
+from ..utils.mcp_oauth import (
+    McpAuthorizationRequired,
+    canonical_resource,
+    extract_resource_metadata_url,
+    fetch_resource_metadata_async,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -48,6 +54,9 @@ class McpRemoteTool(McpServerTool):
             with ThreadPoolExecutor() as executor:
                 future = executor.submit(self._run_in_new_loop, kwargs)
                 return future.result(timeout=self.tool_timeout_sec)
+        except McpAuthorizationRequired:
+            # Bubble up so LangChain can surface a tool error with useful metadata
+            raise
         except Exception as e:
             logger.error(f"Error executing remote MCP tool '{self.name}': {e}")
             return f"Error executing tool: {e}"
@@ -110,6 +119,25 @@ class McpRemoteTool(McpServerTool):
                 logger.debug(f"Request: {json.dumps(mcp_request, indent=2)}")
                 
                 async with session.post(self.server_url, json=mcp_request, headers=headers) as response:
+                    auth_header = response.headers.get('WWW-Authenticate') or response.headers.get('Www-Authenticate')
+                    if response.status == 401:
+                        resource_metadata_url = extract_resource_metadata_url(auth_header)
+                        metadata = None
+                        if resource_metadata_url:
+                            metadata = await fetch_resource_metadata_async(
+                                resource_metadata_url,
+                                session=session,
+                                timeout=self.tool_timeout_sec,
+                            )
+                        raise McpAuthorizationRequired(
+                            message=f"MCP server {self.server_url} requires OAuth authorization",
+                            server_url=canonical_resource(self.server_url),
+                            resource_metadata_url=resource_metadata_url,
+                            www_authenticate=auth_header,
+                            resource_metadata=metadata,
+                            status=response.status,
+                        )
+
                     if response.status != 200:
                         error_text = await response.text()
                         raise Exception(f"HTTP {response.status}: {error_text}")

alita_sdk-0.3.439/alita_sdk/runtime/utils/mcp_oauth.py

@@ -0,0 +1,103 @@
+import json
+import logging
+import re
+from typing import Any, Dict, Optional
+from urllib.parse import urlparse
+
+import requests
+from langchain_core.tools import ToolException
+
+logger = logging.getLogger(__name__)
+
+
+class McpAuthorizationRequired(ToolException):
+    """Raised when an MCP server requires OAuth authorization before use."""
+
+    def __init__(
+        self,
+        message: str,
+        server_url: str,
+        resource_metadata_url: Optional[str] = None,
+        www_authenticate: Optional[str] = None,
+        resource_metadata: Optional[Dict[str, Any]] = None,
+        status: Optional[int] = None,
+    ):
+        super().__init__(message)
+        self.server_url = server_url
+        self.resource_metadata_url = resource_metadata_url
+        self.www_authenticate = www_authenticate
+        self.resource_metadata = resource_metadata
+        self.status = status
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "message": str(self),
+            "server_url": self.server_url,
+            "resource_metadata_url": self.resource_metadata_url,
+            "www_authenticate": self.www_authenticate,
+            "resource_metadata": self.resource_metadata,
+            "status": self.status,
+        }
+
+
+def extract_resource_metadata_url(www_authenticate: Optional[str]) -> Optional[str]:
+    """Pull the resource_metadata URL from a WWW-Authenticate header if present."""
+    if not www_authenticate:
+        return None
+
+    # RFC9728 returns `resource_metadata="<url>"` inside the header value
+    match = re.search(r'resource_metadata\s*=\s*\"?([^\", ]+)\"?', www_authenticate)
+    if match:
+        return match.group(1)
+    return None
+
+
+def fetch_resource_metadata(resource_metadata_url: str, timeout: int = 10) -> Optional[Dict[str, Any]]:
+    """Fetch and parse the protected resource metadata document."""
+    try:
+        resp = requests.get(resource_metadata_url, timeout=timeout)
+        resp.raise_for_status()
+        return resp.json()
+    except Exception as exc:  # broad catch – we want to surface auth requirement even if this fails
+        logger.warning("Failed to fetch resource metadata from %s: %s", resource_metadata_url, exc)
+        return None
+
+
+async def fetch_resource_metadata_async(resource_metadata_url: str, session=None, timeout: int = 10) -> Optional[Dict[str, Any]]:
+    """Async variant for fetching protected resource metadata."""
+    try:
+        import aiohttp
+
+        client_timeout = aiohttp.ClientTimeout(total=timeout)
+        if session:
+            async with session.get(resource_metadata_url, timeout=client_timeout) as resp:
+                text = await resp.text()
+        else:
+            async with aiohttp.ClientSession(timeout=client_timeout) as local_session:
+                async with local_session.get(resource_metadata_url) as resp:
+                    text = await resp.text()
+
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            logger.warning("Resource metadata at %s is not valid JSON: %s", resource_metadata_url, text[:200])
+            return None
+    except Exception as exc:
+        logger.warning("Failed to fetch resource metadata from %s: %s", resource_metadata_url, exc)
+        return None
+
+
+def canonical_resource(server_url: str) -> str:
+    """Produce a canonical resource identifier for the MCP server."""
+    parsed = urlparse(server_url)
+    # Normalize scheme/host casing per RFC guidance
+    normalized = parsed._replace(
+        scheme=parsed.scheme.lower(),
+        netloc=parsed.netloc.lower(),
+    )
+    resource = normalized.geturl()
+
+    # Prefer form without trailing slash unless path is meaningful
+    if resource.endswith("/") and parsed.path in ("", "/"):
+        resource = resource[:-1]
+    return resource

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.437
+Version: 0.3.439
 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.437 → alita_sdk-0.3.439}/alita_sdk.egg-info/SOURCES.txt

@@ -144,6 +144,7 @@ alita_sdk/runtime/utils/__init__.py
 alita_sdk/runtime/utils/constants.py
 alita_sdk/runtime/utils/evaluate.py
 alita_sdk/runtime/utils/logging.py
+alita_sdk/runtime/utils/mcp_oauth.py
 alita_sdk/runtime/utils/save_dataframe.py
 alita_sdk/runtime/utils/streamlit.py
 alita_sdk/runtime/utils/toolkit_runtime.py

{alita_sdk-0.3.437 → alita_sdk-0.3.439}/pyproject.toml

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