alita-sdk 0.3.465__py3-none-any.whl → 0.3.497__py3-none-any.whl

alita_sdk/runtime/langchain/langraph_agent.py

@@ -12,6 +12,7 @@ from langchain_core.runnables import Runnable
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool, ToolException
 from langgraph.channels.ephemeral_value import EphemeralValue
+from langgraph.errors import GraphRecursionError
 from langgraph.graph import StateGraph
 from langgraph.graph.graph import END, START
 from langgraph.graph.state import CompiledStateGraph
@@ -171,12 +172,13 @@ Answer only with step name, no need to add descrip in case none of the steps are
 """
 
     def __init__(self, client, steps: str, description: str = "", decisional_inputs: Optional[list[str]] = [],
-                 default_output: str = 'END'):
+                 default_output: str = 'END', is_node: bool = False):
         self.client = client
         self.steps = ",".join([clean_string(step) for step in steps])
         self.description = description
         self.decisional_inputs = decisional_inputs
         self.default_output = default_output if default_output != 'END' else END
+        self.is_node = is_node
 
     def invoke(self, state: Annotated[BaseStore, InjectedStore()], config: Optional[RunnableConfig] = None) -> str:
         additional_info = ""
@@ -198,7 +200,8 @@ Answer only with step name, no need to add descrip in case none of the steps are
         dispatch_custom_event(
             "on_decision_edge", {"decisional_inputs": self.decisional_inputs, "state": state}, config=config
         )
-        return result
+        # support of legacy `decision` as part of node
+        return {"router_output": result} if self.is_node else result
 
 
 class TransitionalEdge(Runnable):
@@ -632,19 +635,31 @@ def create_graph(
                     output_variables=output_vars,
                     input_variables=node.get('input', ['messages']),
                     structured_output=node.get('structured_output', False),
+                    tool_execution_timeout=node.get('tool_execution_timeout', 900),
                     available_tools=available_tools,
                     tool_names=tool_names,
                     steps_limit=kwargs.get('steps_limit', 25)
                 ))
-            elif node_type == 'router':
-                # Add a RouterNode as an independent node
-                lg_builder.add_node(node_id, RouterNode(
-                    name=node_id,
-                    condition=node.get('condition', ''),
-                    routes=node.get('routes', []),
-                    default_output=node.get('default_output', 'END'),
-                    input_variables=node.get('input', ['messages'])
-                ))
+            elif node_type in ['router', 'decision']:
+                if node_type == 'router':
+                    # Add a RouterNode as an independent node
+                    lg_builder.add_node(node_id, RouterNode(
+                        name=node_id,
+                        condition=node.get('condition', ''),
+                        routes=node.get('routes', []),
+                        default_output=node.get('default_output', 'END'),
+                        input_variables=node.get('input', ['messages'])
+                    ))
+                elif node_type == 'decision':
+                    logger.info(f'Adding decision: {node["nodes"]}')
+                    lg_builder.add_node(node_id, DecisionEdge(
+                        client, node['nodes'],
+                        node.get('description', ""),
+                        decisional_inputs=node.get('decisional_inputs', ['messages']),
+                        default_output=node.get('default_output', 'END'),
+                        is_node=True
+                    ))
+
                 # Add a single conditional edge for all routes
                 lg_builder.add_conditional_edges(
                     node_id,
@@ -820,11 +835,19 @@ class LangGraphAgentRunnable(CompiledStateGraph):
         if not config.get("configurable", {}).get("thread_id", ""):
             config["configurable"] = {"thread_id": str(uuid4())}
         thread_id = config.get("configurable", {}).get("thread_id")
+        
+        # Check if checkpoint exists early for chat_history handling
+        checkpoint_exists = self.checkpointer and self.checkpointer.get_tuple(config)
+        
         # Handle chat history and current input properly
         if input.get('chat_history') and not input.get('messages'):
-            # Convert chat history dict messages to LangChain message objects
-            chat_history = input.pop('chat_history')
-            input['messages'] = [convert_dict_to_message(msg) for msg in chat_history]
+            if checkpoint_exists:
+                # Checkpoint already has conversation history - discard redundant chat_history
+                input.pop('chat_history', None)
+            else:
+                # No checkpoint - convert chat history dict messages to LangChain message objects
+                chat_history = input.pop('chat_history')
+                input['messages'] = [convert_dict_to_message(msg) for msg in chat_history]
 
         # handler for LLM node: if no input (Chat perspective), then take last human message
         # Track if input came from messages to handle content extraction properly
@@ -872,6 +895,16 @@ class LangGraphAgentRunnable(CompiledStateGraph):
                         else:
                             # All content was text, remove this message from the list
                             input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+                    else:
+                        # Message came from input['input'], not from input['messages']
+                        # If there are non-text parts (images, etc.), preserve them in messages
+                        if non_text_parts:
+                            # Initialize messages if it doesn't exist or is empty
+                            if not input.get('messages'):
+                                input['messages'] = []
+                            # Create a new message with only non-text content
+                            non_text_message = HumanMessage(content=non_text_parts)
+                            input['messages'].append(non_text_message)
                 
                 elif isinstance(current_content, str):
                     # on regenerate case
@@ -906,39 +939,98 @@ class LangGraphAgentRunnable(CompiledStateGraph):
             )
         
         logging.info(f"Input: {thread_id} - {input}")
-        if self.checkpointer and self.checkpointer.get_tuple(config):
-            self.update_state(config, input)
-            if config.pop("should_continue", False):
-                invoke_input = input
+        try:
+            if self.checkpointer and self.checkpointer.get_tuple(config):
+                if config.pop("should_continue", False):
+                    invoke_input = input
+                else:
+                    self.update_state(config, input)
+                    invoke_input = None
+                result = super().invoke(invoke_input, config=config, *args, **kwargs)
             else:
-                invoke_input = None
-            result = super().invoke(invoke_input, config=config, *args, **kwargs)
-        else:
-            result = super().invoke(input, config=config, *args, **kwargs)
+                result = super().invoke(input, config=config, *args, **kwargs)
+        except GraphRecursionError as e:
+            current_recursion_limit = config.get("recursion_limit", 0)
+            logger.warning("ToolExecutionLimitReached caught in LangGraphAgentRunnable: %s", e)
+            return self._handle_graph_recursion_error(
+                config=config,
+                thread_id=thread_id,
+                current_recursion_limit=current_recursion_limit,
+            )
+
         try:
-            if result.get(PRINTER_NODE_RS) == PRINTER_COMPLETED_STATE:
-                output = next((msg.content for msg in reversed(result['messages']) if not isinstance(msg, HumanMessage)),
-                              result['messages'][-1].content)
+            # Check if printer node output exists
+            printer_output = result.get(PRINTER_NODE_RS)
+            if printer_output == PRINTER_COMPLETED_STATE:
+                # Printer completed, extract last AI message
+                messages = result['messages']
+                output = next(
+                    (msg.content for msg in reversed(messages)
+                     if not isinstance(msg, HumanMessage)),
+                    messages[-1].content
+                )
+            elif printer_output is not None:
+                # Printer node has output (interrupted state)
+                output = printer_output
             else:
-                # used for printer node output - it will be reset by next `reset` node
-                output = result.get(PRINTER_NODE_RS)
-        except:
-            output = list(result.values())[-1]
+                # No printer node, extract last AI message from messages
+                messages = result.get('messages', [])
+                output = next(
+                    (msg.content for msg in reversed(messages)
+                     if not isinstance(msg, HumanMessage)),
+                    None
+                )
+        except Exception:
+            # Fallback: try to get last value or last message
+            output = list(result.values())[-1] if result else None
         config_state = self.get_state(config)
         is_execution_finished = not config_state.next
         if is_execution_finished:
             thread_id = None
 
+        final_output = f"Assistant run has been completed, but output is None.\nAdding last message if any: {messages[-1] if messages else []}" if is_execution_finished and output is None else output
+
         result_with_state = {
-            "output": output,
+            "output": final_output,
             "thread_id": thread_id,
             "execution_finished": is_execution_finished
         }
 
         # Include all state values in the result
         if hasattr(config_state, 'values') and config_state.values:
+            # except of key = 'output' which is already included
+            for key, value in config_state.values.items():
+                if key != 'output':
+                    result_with_state[key] = value
+
+        return result_with_state
+
+    def _handle_graph_recursion_error(
+            self,
+            config: RunnableConfig,
+            thread_id: str,
+            current_recursion_limit: int,
+    ) -> dict:
+        """Handle GraphRecursionError by returning a soft-boundary response."""
+        config_state = self.get_state(config)
+        is_execution_finished = False
+
+        friendly_output = (
+            f"Tool step limit {current_recursion_limit} reached for this run. You can continue by sending another "
+            "message or refining your request."
+        )
+
+        result_with_state: dict[str, Any] = {
+            "output": friendly_output,
+            "thread_id": thread_id,
+            "execution_finished": is_execution_finished,
+            "tool_execution_limit_reached": True,
+        }
+
+        if hasattr(config_state, "values") and config_state.values:
             for key, value in config_state.values.items():
-                result_with_state[key] = value
+                if key != "output":
+                    result_with_state[key] = value
 
         return result_with_state
 

alita_sdk/runtime/llms/preloaded.py

@@ -105,8 +105,7 @@ class PreloadedChatModel(BaseChatModel):  # pylint: disable=R0903
     model_name: str = ""
     max_tokens: Optional[int] = 256
     temperature: Optional[float] = 0.9
-    top_p: Optional[float] = 0.9
-    top_k: Optional[int] = 20
+    reasoning_effort: Optional[str] = None
     token_limit: Optional[int] = 1024
 
     _local_streams: Any = PrivateAttr()
@@ -252,8 +251,7 @@ class PreloadedChatModel(BaseChatModel):  # pylint: disable=R0903
             "return_full_text": False,
             "temperature": self.temperature,
             "do_sample": True,
-            "top_k": self.top_k,
-            "top_p": self.top_p,
+            "reasoning_effort": self.reasoning_effort
         }
         #
         try:
@@ -302,8 +300,6 @@ class PreloadedChatModel(BaseChatModel):  # pylint: disable=R0903
             "return_full_text": False,
             "temperature": self.temperature,
             "do_sample": True,
-            "top_k": self.top_k,
-            "top_p": self.top_p,
         }
         #
         while True:

alita_sdk/runtime/toolkits/__init__.py

@@ -6,6 +6,7 @@ This module provides various toolkit implementations for LangGraph agents.
 from .application import ApplicationToolkit
 from .artifact import ArtifactToolkit
 from .datasource import DatasourcesToolkit
+from .planning import PlanningToolkit
 from .prompt import PromptToolkit
 from .subgraph import SubgraphToolkit
 from .vectorstore import VectorStoreToolkit
@@ -16,6 +17,7 @@ __all__ = [
     "ApplicationToolkit",
     "ArtifactToolkit",
     "DatasourcesToolkit",
+    "PlanningToolkit",
     "PromptToolkit",
     "SubgraphToolkit",
     "VectorStoreToolkit",

alita_sdk/runtime/toolkits/application.py

@@ -28,7 +28,7 @@ class ApplicationToolkit(BaseToolkit):
         version_details = client.get_app_version_details(application_id, application_version_id)
         model_settings = {
             "max_tokens": version_details['llm_settings']['max_tokens'],
-            "top_p": version_details['llm_settings']['top_p'],
+            "reasoning_effort": version_details['llm_settings'].get('reasoning_effort'),
             "temperature": version_details['llm_settings']['temperature'],
         }
 

alita_sdk/runtime/toolkits/mcp.py

@@ -6,19 +6,18 @@ Following MCP specification: https://modelcontextprotocol.io/specification/2025-
 
 import logging
 import re
-import requests
 import asyncio
 from typing import List, Optional, Any, Dict, Literal, ClassVar, Union
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 from ..tools.mcp_server_tool import McpServerTool
 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_sse_client import McpSseClient
+from ..utils.mcp_client import McpClient
 from ..utils.mcp_oauth import (
     McpAuthorizationRequired,
     canonical_resource,
@@ -208,28 +207,32 @@ class McpToolkit(BaseToolkit):
                     }
                 )
             ),
-            timeout=(
-                Union[int, str], # TODO: remove one I will figure out why UI sends str
+            client_id=(
+                Optional[str],
                 Field(
-                    default=300,
-                    description="Request timeout in seconds (1-3600)"
+                    default=None,
+                    description="OAuth Client ID (if applicable)"
                 )
             ),
-            discovery_mode=(
-                Literal['static', 'dynamic', 'hybrid'],
+            client_secret=(
+                Optional[SecretStr],
                 Field(
-                    default="dynamic",
-                    description="Discovery mode",
-                    json_schema_extra={
-                        'tooltip': 'static: use registry, dynamic: live discovery, hybrid: try dynamic first'
-                    }
+                    default=None,
+                    description="OAuth Client Secret (if applicable)"
                 )
             ),
-            discovery_interval=(
-                Union[int, str],
+            scopes=(
+                Optional[List[str]],
+                Field(
+                    default=None,
+                    description="OAuth Scopes (if applicable)"
+                )
+            ),
+            timeout=(
+                Union[int, str], # TODO: remove one I will figure out why UI sends str
                 Field(
                     default=300,
-                    description="Discovery interval in seconds (60-3600, for periodic discovery)"
+                    description="Request timeout in seconds (1-3600)"
                 )
             ),
             selected_tools=(
@@ -259,7 +262,7 @@ class McpToolkit(BaseToolkit):
             __config__=ConfigDict(
                 json_schema_extra={
                     'metadata': {
-                        "label": "Remove MCP",
+                        "label": "Remote MCP",
                         "icon_url": None,
                         "categories": ["other"],
                         "extra_categories": ["remote tools", "sse", "http"],
@@ -275,8 +278,6 @@ class McpToolkit(BaseToolkit):
         url: str,
         headers: Optional[Dict[str, str]] = None,
         timeout: int = 60,
-        discovery_mode: str = "hybrid",
-        discovery_interval: int = 300,
         selected_tools: List[str] = None,
         enable_caching: bool = True,
         cache_ttl: int = 300,
@@ -297,8 +298,6 @@ class McpToolkit(BaseToolkit):
             url: MCP server HTTP URL
             headers: HTTP headers for authentication
             timeout: Request timeout in seconds
-            discovery_mode: Discovery mode ('static', 'dynamic', 'hybrid')
-            discovery_interval: Discovery interval in seconds (for periodic discovery)
             selected_tools: List of specific tools to enable (empty = all tools)
             enable_caching: Whether to enable caching
             cache_ttl: Cache TTL in seconds
@@ -317,7 +316,6 @@ class McpToolkit(BaseToolkit):
 
         # 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}")
@@ -363,8 +361,7 @@ class McpToolkit(BaseToolkit):
             connection_config=connection_config,
             timeout=timeout,
             selected_tools=selected_tools,
-            client=client,
-            discovery_mode=discovery_mode
+            client=client
         )
 
         return toolkit
@@ -376,8 +373,7 @@ class McpToolkit(BaseToolkit):
         connection_config: McpConnectionConfig,
         timeout: int,
         selected_tools: List[str],
-        client,
-        discovery_mode: str = "dynamic"
+        client
     ) -> List[BaseTool]:
         """
         Create tools from a single MCP server. Always performs live discovery when connection config is provided.
@@ -423,19 +419,23 @@ class McpToolkit(BaseToolkit):
 
             logger.info(f"Successfully created {len(tools)} MCP tools from toolkit '{toolkit_name}' via direct discovery")
 
+        except McpAuthorizationRequired:
+            # Authorization is required; surface upstream so the caller can prompt the user
+            logger.info(f"MCP toolkit '{toolkit_name}' requires OAuth authorization")
+            raise
         except Exception as e:
             logger.error(f"Direct discovery failed for MCP toolkit '{toolkit_name}': {e}", exc_info=True)
             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
+            
+            # For new MCP toolkits (no client), don't silently return empty - surface the error
+            # This helps users understand why tool discovery failed
+            if not client:
+                logger.warning(f"No fallback available for toolkit '{toolkit_name}' - re-raising discovery error")
                 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)
-            else:
-                logger.warning(f"No fallback available for toolkit '{toolkit_name}' - returning empty tools list")
+            
+            # Only fall back to static discovery for existing toolkits with a client
+            logger.info(f"Falling back to static discovery for toolkit '{toolkit_name}'")
+            tools = cls._create_tools_static(toolkit_name, selected_tools, timeout, client)
 
         # Don't add inspection tool to agent - it's only for internal use by toolkit
         # inspection_tool = cls._create_inspection_tool(
@@ -459,28 +459,34 @@ class McpToolkit(BaseToolkit):
         toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
-    ) -> List[Dict[str, Any]]:
+    ) -> tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Discover tools and prompts from MCP server using SSE client.
-        Returns list of tool/prompt dictionaries with name, description, and inputSchema.
-        Prompts are converted to tools that can be invoked.
+        
+        Returns:
+            Tuple of (tool_list, server_session_id) - session_id may be server-provided
         """
-        session_id = connection_config.session_id
+        initial_session_id = connection_config.session_id
         
-        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")
+        if not initial_session_id:
+            logger.warning(f"[MCP Session] No session_id provided for '{toolkit_name}' - will generate one")
         
         # Run async discovery in sync context
         try:
-            all_tools = asyncio.run(
+            all_tools, server_session_id = asyncio.run(
                 cls._discover_tools_async(
                     toolkit_name=toolkit_name,
                     connection_config=connection_config,
                     timeout=timeout
                 )
             )
-            return all_tools, session_id
+            # Return tools and the session_id (server-provided or generated)
+            logger.info(f"[MCP Session] Final session_id for '{toolkit_name}': {server_session_id}")
+            return all_tools, server_session_id
+        except McpAuthorizationRequired:
+            # Re-raise auth required exceptions directly
+            logger.info(f"[MCP SSE] Authorization required for '{toolkit_name}'")
+            raise
         except Exception as e:
             logger.error(f"[MCP SSE] Discovery failed for '{toolkit_name}': {e}")
             raise
@@ -491,9 +497,12 @@ class McpToolkit(BaseToolkit):
         toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
-    ) -> List[Dict[str, Any]]:
+    ) -> tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Async implementation of tool discovery using SSE client.
+        
+        Returns:
+            Tuple of (tool_list, server_session_id)
         """
         all_tools = []
         session_id = connection_config.session_id
@@ -505,65 +514,74 @@ class McpToolkit(BaseToolkit):
             session_id = str(uuid.uuid4())
             logger.info(f"[MCP SSE] Generated temporary session_id for OAuth: {session_id}")
         
-        logger.info(f"[MCP SSE] Discovering from {connection_config.url} with session {session_id}")
+        logger.info(f"[MCP] Discovering from {connection_config.url} with session {session_id}")
         
         # Prepare headers
         headers = {}
         if connection_config.headers:
             headers.update(connection_config.headers)
         
-        # Create SSE client
-        client = McpSseClient(
+        # Create unified MCP client (auto-detects SSE vs Streamable HTTP)
+        client = McpClient(
             url=connection_config.url,
             session_id=session_id,
             headers=headers,
             timeout=timeout
         )
         
-        # Initialize MCP session
-        await client.initialize()
-        logger.info(f"[MCP SSE] Session initialized for '{toolkit_name}'")
-        
-        # Discover tools
-        tools = await client.list_tools()
-        all_tools.extend(tools)
-        logger.info(f"[MCP SSE] Discovered {len(tools)} tools from '{toolkit_name}'")
-        
-        # Discover prompts
-        try:
-            prompts = await client.list_prompts()
-            # Convert prompts to tool format
-            for prompt in prompts:
-                prompt_tool = {
-                    "name": f"prompt_{prompt.get('name', 'unnamed')}",
-                    "description": prompt.get('description', f"Execute prompt: {prompt.get('name')}"),
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "arguments": {
-                                "type": "object",
-                                "description": "Arguments for the prompt template",
-                                "properties": {
-                                    arg.get("name"): {
-                                        "type": "string",
-                                        "description": arg.get("description", ""),
-                                        "required": arg.get("required", False)
+        server_session_id = None
+        async with client:
+            # Initialize MCP session
+            await client.initialize()
+            logger.info(f"[MCP] Session initialized for '{toolkit_name}' (transport={client.detected_transport})")
+            
+            # Capture server-provided session_id (from mcp-session-id header)
+            server_session_id = client.server_session_id
+            if server_session_id:
+                logger.info(f"[MCP] Server provided session_id: {server_session_id}")
+            
+            # Discover tools
+            tools = await client.list_tools()
+            all_tools.extend(tools)
+            logger.info(f"[MCP] Discovered {len(tools)} tools from '{toolkit_name}'")
+            
+            # Discover prompts
+            try:
+                prompts = await client.list_prompts()
+                # Convert prompts to tool format
+                for prompt in prompts:
+                    prompt_tool = {
+                        "name": f"prompt_{prompt.get('name', 'unnamed')}",
+                        "description": prompt.get('description', f"Execute prompt: {prompt.get('name')}"),
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "arguments": {
+                                    "type": "object",
+                                    "description": "Arguments for the prompt template",
+                                    "properties": {
+                                        arg.get("name"): {
+                                            "type": "string",
+                                            "description": arg.get("description", ""),
+                                            "required": arg.get("required", False)
+                                        }
+                                        for arg in prompt.get("arguments", [])
                                     }
-                                    for arg in prompt.get("arguments", [])
                                 }
                             }
-                        }
-                    },
-                    "_mcp_type": "prompt",
-                    "_mcp_prompt_name": prompt.get('name')
-                }
-                all_tools.append(prompt_tool)
-            logger.info(f"[MCP SSE] Discovered {len(prompts)} prompts from '{toolkit_name}'")
-        except Exception as e:
-            logger.warning(f"[MCP SSE] Failed to discover prompts: {e}")
+                        },
+                        "_mcp_type": "prompt",
+                        "_mcp_prompt_name": prompt.get('name')
+                    }
+                    all_tools.append(prompt_tool)
+                logger.info(f"[MCP] Discovered {len(prompts)} prompts from '{toolkit_name}'")
+            except Exception as e:
+                logger.warning(f"[MCP] Failed to discover prompts: {e}")
         
-        logger.info(f"[MCP SSE] Total discovered {len(all_tools)} items from '{toolkit_name}'")
-        return all_tools
+        logger.info(f"[MCP] Total discovered {len(all_tools)} items from '{toolkit_name}'")
+        # Return tools and server-provided session_id (use server's if available, else the one we sent)
+        final_session_id = server_session_id or session_id
+        return all_tools, final_session_id
 
     @classmethod
     def _create_tool_from_dict(
@@ -858,8 +876,6 @@ def get_tools(tool_config: dict, alita_client, llm=None, memory_store=None) -> L
         url=url,
         headers=headers,
         timeout=safe_int(settings.get('timeout'), 60),
-        discovery_mode=settings.get('discovery_mode', 'dynamic'),
-        discovery_interval=safe_int(settings.get('discovery_interval'), 300),
         selected_tools=settings.get('selected_tools', []),
         enable_caching=settings.get('enable_caching', True),
         cache_ttl=safe_int(settings.get('cache_ttl'), 300),