alita-sdk 0.3.435__py3-none-any.whl → 0.3.449__py3-none-any.whl

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:
@@ -342,13 +342,16 @@ class AlitaClient:
             app_type = "react"
         elif app_type == 'autogen':
             app_type = "react"
+        
+        # LangChainAssistant constructor calls get_tools() which may raise McpAuthorizationRequired
+        # The exception will propagate naturally to the indexer worker's outer handler
         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 +571,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 +608,20 @@ 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()
+        
+        # LangChainAssistant constructor calls get_tools() which may raise McpAuthorizationRequired
+        # The exception will propagate naturally to the indexer worker's outer handler
+        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,
@@ -746,7 +762,23 @@ class AlitaClient:
                 }
 
             # Instantiate the toolkit with client and LLM support
-            tools = instantiate_toolkit_with_client(toolkit_config, llm, self)
+            try:
+                tools = instantiate_toolkit_with_client(toolkit_config, llm, self)
+            except Exception as toolkit_error:
+                # Re-raise McpAuthorizationRequired to allow proper handling upstream
+                from ..utils.mcp_oauth import McpAuthorizationRequired
+                if isinstance(toolkit_error, McpAuthorizationRequired):
+                    raise
+                # For other errors, return error response
+                return {
+                    "success": False,
+                    "error": f"Failed to instantiate toolkit '{toolkit_config.get('toolkit_name')}': {str(toolkit_error)}",
+                    "tool_name": tool_name,
+                    "toolkit_config": toolkit_config_parsed_json,
+                    "llm_model": llm_model,
+                    "events_dispatched": events_dispatched,
+                    "execution_time_seconds": 0.0
+                }
 
             if not tools:
                 return {

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/runtime/models/mcp_models.py

@@ -19,6 +19,10 @@ class McpConnectionConfig(BaseModel):
         default=None,
         description="HTTP headers for the connection (JSON object)"
     )
+    session_id: Optional[str] = Field(
+        default=None,
+        description="MCP session ID for stateful SSE servers (managed by client)"
+    )
 
     @validator('url')
     def validate_url(cls, v):