letta-nightly 0.8.4.dev20250615104252__py3-none-any.whl → 0.8.4.dev20250616104355__py3-none-any.whl

letta/services/mcp/base_client.py

@@ -24,11 +24,22 @@ class AsyncBaseMCPClient:
             await self._initialize_connection(self.server_config)
             await self.session.initialize()
             self.initialized = True
+        except ConnectionError as e:
+            logger.error(f"MCP connection failed: {str(e)}")
+            raise e
         except Exception as e:
             logger.error(
-                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
+                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}. Error: {str(e)}"
             )
-            raise e
+            if hasattr(self.server_config, "server_url") and self.server_config.server_url:
+                server_info = f"server URL '{self.server_config.server_url}'"
+            elif hasattr(self.server_config, "command") and self.server_config.command:
+                server_info = f"command '{self.server_config.command}'"
+            else:
+                server_info = f"server '{self.server_config.server_name}'"
+            raise ConnectionError(
+                f"Failed to connect to MCP {server_info}. Please check your configuration and ensure the server is accessible."
+            ) from e
 
     async def _initialize_connection(self, server_config: BaseServerConfig) -> None:
         raise NotImplementedError("Subclasses must implement _initialize_connection")

letta/services/mcp/sse_client.py

@@ -14,7 +14,14 @@ logger = get_logger(__name__)
 # TODO: Get rid of Async prefix on this class name once we deprecate old sync code
 class AsyncSSEMCPClient(AsyncBaseMCPClient):
     async def _initialize_connection(self, server_config: SSEServerConfig) -> None:
-        sse_cm = sse_client(url=server_config.server_url)
+        headers = {}
+        if server_config.custom_headers:
+            headers.update(server_config.custom_headers)
+
+        if server_config.auth_header and server_config.auth_token:
+            headers[server_config.auth_header] = server_config.auth_token
+
+        sse_cm = sse_client(url=server_config.server_url, headers=headers if headers else None)
         sse_transport = await self.exit_stack.enter_async_context(sse_cm)
         self.stdio, self.write = sse_transport
 

letta/services/mcp/streamable_http_client.py

@@ -0,0 +1,56 @@
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+from letta.functions.mcp_client.types import BaseServerConfig, StreamableHTTPServerConfig
+from letta.log import get_logger
+from letta.services.mcp.base_client import AsyncBaseMCPClient
+
+logger = get_logger(__name__)
+
+
+class AsyncStreamableHTTPMCPClient(AsyncBaseMCPClient):
+    async def _initialize_connection(self, server_config: BaseServerConfig) -> None:
+        if not isinstance(server_config, StreamableHTTPServerConfig):
+            raise ValueError("Expected StreamableHTTPServerConfig")
+
+        try:
+            # Prepare headers for authentication
+            headers = {}
+            if server_config.custom_headers:
+                headers.update(server_config.custom_headers)
+
+            # Add auth header if specified
+            if server_config.auth_header and server_config.auth_token:
+                headers[server_config.auth_header] = server_config.auth_token
+
+            # Use streamablehttp_client context manager with headers if provided
+            if headers:
+                streamable_http_cm = streamablehttp_client(server_config.server_url, headers=headers)
+            else:
+                streamable_http_cm = streamablehttp_client(server_config.server_url)
+            read_stream, write_stream, _ = await self.exit_stack.enter_async_context(streamable_http_cm)
+
+            # Create and enter the ClientSession context manager
+            session_cm = ClientSession(read_stream, write_stream)
+            self.session = await self.exit_stack.enter_async_context(session_cm)
+        except Exception as e:
+            # Provide more helpful error messages for specific error types
+            if "404" in str(e) or "Not Found" in str(e):
+                raise ConnectionError(
+                    f"MCP server not found at URL: {server_config.server_url}. "
+                    "Please verify the URL is correct and the server supports the MCP protocol."
+                ) from e
+            elif "Connection" in str(e) or "connect" in str(e).lower():
+                raise ConnectionError(
+                    f"Failed to connect to MCP server at: {server_config.server_url}. "
+                    "Please check that the server is running and accessible."
+                ) from e
+            elif "JSON" in str(e) and "validation" in str(e):
+                raise ConnectionError(
+                    f"MCP server at {server_config.server_url} is not returning valid JSON-RPC responses. "
+                    "The server may not be a proper MCP server or may be returning empty/invalid JSON. "
+                    "Please verify this is an MCP-compatible server endpoint."
+                ) from e
+            else:
+                # Re-raise other exceptions with additional context
+                raise ConnectionError(f"Failed to initialize streamable HTTP connection to {server_config.server_url}: {str(e)}") from e

letta/services/mcp_manager.py

@@ -3,17 +3,18 @@ import os
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import letta.constants as constants
-from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig
+from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.mcp_server import MCPServer as MCPServerModel
-from letta.schemas.mcp import MCPServer, UpdateMCPServer, UpdateSSEMCPServer, UpdateStdioMCPServer
+from letta.schemas.mcp import MCPServer, UpdateMCPServer, UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.services.mcp.sse_client import MCP_CONFIG_TOPLEVEL_KEY, AsyncSSEMCPClient
 from letta.services.mcp.stdio_client import AsyncStdioMCPClient
+from letta.services.mcp.streamable_http_client import AsyncStreamableHTTPMCPClient
 from letta.services.tool_manager import ToolManager
 from letta.utils import enforce_types, printd
 
@@ -31,7 +32,6 @@ class MCPManager:
     @enforce_types
     async def list_mcp_server_tools(self, mcp_server_name: str, actor: PydanticUser) -> List[MCPTool]:
         """Get a list of all tools for a specific MCP server."""
-        print("mcp_server_name", mcp_server_name)
         mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
         mcp_config = await self.get_mcp_server_by_id_async(mcp_server_id, actor=actor)
         server_config = mcp_config.to_config()
@@ -40,12 +40,16 @@ class MCPManager:
             mcp_client = AsyncSSEMCPClient(server_config=server_config)
         elif mcp_config.server_type == MCPServerType.STDIO:
             mcp_client = AsyncStdioMCPClient(server_config=server_config)
+        elif mcp_config.server_type == MCPServerType.STREAMABLE_HTTP:
+            mcp_client = AsyncStreamableHTTPMCPClient(server_config=server_config)
+        else:
+            raise ValueError(f"Unsupported MCP server type: {mcp_config.server_type}")
         await mcp_client.connect_to_server()
 
         # list tools
         tools = await mcp_client.list_tools()
-        # TODO: change to pydantic tools
 
+        # TODO: change to pydantic tools
         await mcp_client.cleanup()
 
         return tools
@@ -55,7 +59,6 @@ class MCPManager:
         self, mcp_server_name: str, tool_name: str, tool_args: Optional[Dict[str, Any]], actor: PydanticUser
     ) -> Tuple[str, bool]:
         """Call a specific tool from a specific MCP server."""
-
         from letta.settings import tool_settings
 
         if not tool_settings.mcp_read_from_config:
@@ -75,6 +78,10 @@ class MCPManager:
             mcp_client = AsyncSSEMCPClient(server_config=server_config)
         elif isinstance(server_config, StdioServerConfig):
             mcp_client = AsyncStdioMCPClient(server_config=server_config)
+        elif isinstance(server_config, StreamableHTTPServerConfig):
+            mcp_client = AsyncStreamableHTTPMCPClient(server_config=server_config)
+        else:
+            raise ValueError(f"Unsupported server config type: {type(server_config)}")
         await mcp_client.connect_to_server()
 
         # call tool
@@ -114,7 +121,6 @@ class MCPManager:
     async def create_or_update_mcp_server(self, pydantic_mcp_server: MCPServer, actor: PydanticUser) -> MCPServer:
         """Create a new tool based on the ToolCreate schema."""
         mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name=pydantic_mcp_server.server_name, actor=actor)
-        print("FOUND SERVER", mcp_server_id, pydantic_mcp_server.server_name)
         if mcp_server_id:
             # Put to dict and remove fields that should not be reset
             update_data = pydantic_mcp_server.model_dump(exclude_unset=True, exclude_none=True)
@@ -122,11 +128,16 @@ class MCPManager:
             # If there's anything to update (can only update the configs, not the name)
             if update_data:
                 if pydantic_mcp_server.server_type == MCPServerType.SSE:
-                    update_request = UpdateSSEMCPServer(server_url=pydantic_mcp_server.server_url)
+                    update_request = UpdateSSEMCPServer(server_url=pydantic_mcp_server.server_url, token=pydantic_mcp_server.token)
                 elif pydantic_mcp_server.server_type == MCPServerType.STDIO:
                     update_request = UpdateStdioMCPServer(stdio_config=pydantic_mcp_server.stdio_config)
+                elif pydantic_mcp_server.server_type == MCPServerType.STREAMABLE_HTTP:
+                    update_request = UpdateStreamableHTTPMCPServer(
+                        server_url=pydantic_mcp_server.server_url, token=pydantic_mcp_server.token
+                    )
+                else:
+                    raise ValueError(f"Unsupported server type: {pydantic_mcp_server.server_type}")
                 mcp_server = await self.update_mcp_server_by_id(mcp_server_id, update_request, actor)
-                print("RETURN", mcp_server)
             else:
                 printd(
                     f"`create_or_update_mcp_server` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={pydantic_mcp_server.server_name}, but found existing mcp server with nothing to update."
@@ -229,7 +240,7 @@ class MCPManager:
             except NoResultFound:
                 raise ValueError(f"MCP server with id {mcp_server_id} not found.")
 
-    def read_mcp_config(self) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
+    def read_mcp_config(self) -> dict[str, Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig]]:
         mcp_server_list = {}
 
         # Attempt to read from ~/.letta/mcp_config.json
@@ -260,6 +271,9 @@ class MCPManager:
                                 server_params = SSEServerConfig(
                                     server_name=server_name,
                                     server_url=server_params_raw["url"],
+                                    auth_header=server_params_raw.get("auth_header", None),
+                                    auth_token=server_params_raw.get("auth_token", None),
+                                    headers=server_params_raw.get("headers", None),
                                 )
                                 mcp_server_list[server_name] = server_params
                             except Exception as e:

letta/services/message_manager.py

@@ -603,10 +603,11 @@ class MessageManager:
 
     @enforce_types
     @trace_method
-    async def delete_all_messages_for_agent_async(self, agent_id: str, actor: PydanticUser) -> int:
+    async def delete_all_messages_for_agent_async(self, agent_id: str, actor: PydanticUser, exclude_ids: Optional[List[str]] = None) -> int:
         """
         Efficiently deletes all messages associated with a given agent_id,
         while enforcing permission checks and avoiding any ORM‑level loads.
+        Optionally excludes specific message IDs from deletion.
         """
         async with db_registry.async_session() as session:
             # 1) verify the agent exists and the actor has access
@@ -616,10 +617,36 @@ class MessageManager:
             stmt = (
                 delete(MessageModel).where(MessageModel.agent_id == agent_id).where(MessageModel.organization_id == actor.organization_id)
             )
+
+            # 3) exclude specific message IDs if provided
+            if exclude_ids:
+                stmt = stmt.where(~MessageModel.id.in_(exclude_ids))
+
+            result = await session.execute(stmt)
+
+            # 4) commit once
+            await session.commit()
+
+            # 5) return the number of rows deleted
+            return result.rowcount
+
+    @enforce_types
+    @trace_method
+    async def delete_messages_by_ids_async(self, message_ids: List[str], actor: PydanticUser) -> int:
+        """
+        Efficiently deletes messages by their specific IDs,
+        while enforcing permission checks.
+        """
+        if not message_ids:
+            return 0
+
+        async with db_registry.async_session() as session:
+            # issue a CORE DELETE against the mapped class for specific message IDs
+            stmt = delete(MessageModel).where(MessageModel.id.in_(message_ids)).where(MessageModel.organization_id == actor.organization_id)
             result = await session.execute(stmt)
 
-            # 3) commit once
+            # commit once
             await session.commit()
 
-            # 4) return the number of rows deleted
+            # return the number of rows deleted
             return result.rowcount

letta/services/tool_executor/files_tool_executor.py

@@ -126,15 +126,14 @@ class LettaFileToolExecutor(ToolExecutor):
         await self.files_agents_manager.update_file_agent_by_id(
             agent_id=agent_state.id, file_id=file_id, actor=self.actor, is_open=True, visible_content=visible_content
         )
-
-        return "Success"
+        return f"Successfully opened file {file_name}, lines {start} to {end} are now visible in memory block <{file_name}>"
 
     async def close_file(self, agent_state: AgentState, file_name: str) -> str:
         """Stub for close_file tool."""
         await self.files_agents_manager.update_file_agent_by_name(
             agent_id=agent_state.id, file_name=file_name, actor=self.actor, is_open=False
         )
-        return "Success"
+        return f"Successfully closed file {file_name}, use function calls to re-open file"
 
     def _validate_regex_pattern(self, pattern: str) -> None:
         """Validate regex pattern to prevent catastrophic backtracking."""

letta/services/tool_sandbox/e2b_sandbox.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
+from e2b.sandbox.commands.command_handle import CommandExitException
 from e2b_code_interpreter import AsyncSandbox
 
 from letta.log import get_logger
@@ -189,14 +190,63 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
                         "package": package,
                     },
                 )
-                await sbx.commands.run(f"pip install {package}")
+                try:
+                    await sbx.commands.run(f"pip install {package}")
+                    log_event(
+                        "e2b_pip_install_finished",
+                        {
+                            "sandbox_id": sbx.sandbox_id,
+                            "package": package,
+                        },
+                    )
+                except CommandExitException as e:
+                    error_msg = f"Failed to install sandbox pip requirement '{package}' in E2B sandbox. This may be due to package version incompatibility with the E2B environment. Error: {e}"
+                    logger.error(error_msg)
+                    log_event(
+                        "e2b_pip_install_failed",
+                        {
+                            "sandbox_id": sbx.sandbox_id,
+                            "package": package,
+                            "error": str(e),
+                        },
+                    )
+                    raise RuntimeError(error_msg) from e
+
+        # Install tool-specific pip requirements
+        if self.tool and self.tool.pip_requirements:
+            for pip_requirement in self.tool.pip_requirements:
+                package_str = str(pip_requirement)
                 log_event(
-                    "e2b_pip_install_finished",
+                    "tool_pip_install_started",
                     {
                         "sandbox_id": sbx.sandbox_id,
-                        "package": package,
+                        "package": package_str,
+                        "tool_name": self.tool.name,
                     },
                 )
+                try:
+                    await sbx.commands.run(f"pip install {package_str}")
+                    log_event(
+                        "tool_pip_install_finished",
+                        {
+                            "sandbox_id": sbx.sandbox_id,
+                            "package": package_str,
+                            "tool_name": self.tool.name,
+                        },
+                    )
+                except CommandExitException as e:
+                    error_msg = f"Failed to install tool pip requirement '{package_str}' for tool '{self.tool.name}' in E2B sandbox. This may be due to package version incompatibility with the E2B environment. Consider updating the package version or removing the version constraint. Error: {e}"
+                    logger.error(error_msg)
+                    log_event(
+                        "tool_pip_install_failed",
+                        {
+                            "sandbox_id": sbx.sandbox_id,
+                            "package": package_str,
+                            "tool_name": self.tool.name,
+                            "error": str(e),
+                        },
+                    )
+                    raise RuntimeError(error_msg) from e
 
         return sbx
 

letta/services/tool_sandbox/local_sandbox.py

@@ -175,7 +175,9 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             log_event(name="finish create_venv_for_local_sandbox")
 
         log_event(name="start install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
-        await asyncio.to_thread(install_pip_requirements_for_sandbox, local_configs, upgrade=True, user_install_if_no_venv=False, env=env)
+        await asyncio.to_thread(
+            install_pip_requirements_for_sandbox, local_configs, upgrade=True, user_install_if_no_venv=False, env=env, tool=self.tool
+        )
         log_event(name="finish install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
 
     @trace_method

letta/services/user_manager.py

@@ -3,6 +3,9 @@ from typing import List, Optional
 from sqlalchemy import select, text
 
 from letta.constants import DEFAULT_ORG_ID
+from letta.data_sources.redis_client import get_redis_client
+from letta.helpers.decorators import async_redis_cache
+from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
@@ -13,6 +16,8 @@ from letta.server.db import db_registry
 from letta.utils import enforce_types
 from letta.settings import settings
 
+logger = get_logger(__name__)
+
 
 class UserManager:
     """Manager class to handle business logic related to Users."""
@@ -59,6 +64,7 @@ class UserManager:
                 # If it doesn't exist, make it
                 actor = UserModel(id=self.DEFAULT_USER_ID, name=self.DEFAULT_USER_NAME, organization_id=org_id)
                 await actor.create_async(session)
+                await self._invalidate_actor_cache(self.DEFAULT_USER_ID)
 
             return actor.to_pydantic()
 
@@ -78,6 +84,7 @@ class UserManager:
         async with db_registry.async_session() as session:
             new_user = UserModel(**pydantic_user.model_dump(to_orm=True))
             await new_user.create_async(session)
+            await self._invalidate_actor_cache(new_user.id)
             return new_user.to_pydantic()
 
     @enforce_types
@@ -112,6 +119,7 @@ class UserManager:
 
             # Commit the updated user
             await existing_user.update_async(session)
+            await self._invalidate_actor_cache(user_update.id)
             return existing_user.to_pydantic()
 
     @enforce_types
@@ -133,6 +141,7 @@ class UserManager:
             # Delete from user table
             user = await UserModel.read_async(db_session=session, identifier=user_id)
             await user.hard_delete_async(session)
+            await self._invalidate_actor_cache(user_id)
 
     @enforce_types
     @trace_method
@@ -144,6 +153,7 @@ class UserManager:
 
     @enforce_types
     @trace_method
+    @async_redis_cache(key_func=lambda self, actor_id: f"actor_id:{actor_id}", model_class=PydanticUser)
     async def get_actor_by_id_async(self, actor_id: str) -> PydanticUser:
         """Fetch a user by ID asynchronously."""
         async with db_registry.async_session() as session:
@@ -228,3 +238,15 @@ class UserManager:
                 limit=limit,
             )
             return [user.to_pydantic() for user in users]
+
+    async def _invalidate_actor_cache(self, actor_id: str) -> bool:
+        """Invalidates the actor cache on CRUD operations.
+        TODO (cliandy): see notes on redis cache decorator
+        """
+        try:
+            redis_client = await get_redis_client()
+            cache_key = self.get_actor_by_id_async.cache_key_func(self, actor_id)
+            return (await redis_client.delete(cache_key)) > 0
+        except Exception as e:
+            logger.error(f"Failed to invalidate cache: {e}")
+            return False

letta/settings.py

@@ -205,6 +205,9 @@ class Settings(BaseSettings):
 
     # telemetry logging
     otel_exporter_otlp_endpoint: Optional[str] = None  # otel default: "http://localhost:4317"
+    otel_preferred_temporality: Optional[int] = Field(
+        default=1, ge=0, le=2, description="Exported metric temporality. {0: UNSPECIFIED, 1: DELTA, 2: CUMULATIVE}"
+    )
     disable_tracing: bool = False
     llm_api_logging: bool = True
 

{letta_nightly-0.8.4.dev20250615104252.dist-info → letta_nightly-0.8.4.dev20250616104355.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.4.dev20250615104252
+Version: 0.8.4.dev20250616104355
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -20,7 +20,6 @@ Provides-Extra: experimental
 Provides-Extra: external-tools
 Provides-Extra: google
 Provides-Extra: postgres
-Provides-Extra: qdrant
 Provides-Extra: redis
 Provides-Extra: server
 Provides-Extra: tests
@@ -56,13 +55,13 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.153,<0.2.0)
+Requires-Dist: letta_client (>=0.1.155,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
 Requires-Dist: marshmallow-sqlalchemy (>=1.4.1,<2.0.0)
 Requires-Dist: matplotlib (>=3.10.1,<4.0.0)
-Requires-Dist: mcp (>=1.3.0,<2.0.0)
+Requires-Dist: mcp[cli] (>=1.9.4,<2.0.0)
 Requires-Dist: mistralai (>=1.8.1,<2.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
@@ -89,7 +88,6 @@ Requires-Dist: python-box (>=7.1.1,<8.0.0)
 Requires-Dist: python-multipart (>=0.0.19,<0.0.20)
 Requires-Dist: pytz (>=2023.3.post1,<2024.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
-Requires-Dist: qdrant-client (>=1.9.1,<2.0.0) ; extra == "qdrant"
 Requires-Dist: questionary (>=2.0.1,<3.0.0)
 Requires-Dist: redis (>=6.2.0,<7.0.0) ; extra == "redis" or extra == "all"
 Requires-Dist: rich (>=13.9.4,<14.0.0)
@@ -99,9 +97,10 @@ Requires-Dist: sqlalchemy-json (>=0.7.0,<0.8.0)
 Requires-Dist: sqlalchemy-utils (>=0.41.2,<0.42.0)
 Requires-Dist: sqlalchemy[asyncio] (>=2.0.41,<3.0.0)
 Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
+Requires-Dist: structlog (>=25.4.0,<26.0.0)
 Requires-Dist: tavily-python (>=0.7.2,<0.8.0)
 Requires-Dist: tqdm (>=4.66.1,<5.0.0)
-Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Requires-Dist: typer (>=0.15.2,<0.16.0)
 Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server" or extra == "desktop" or extra == "all"
 Requires-Dist: uvloop (>=0.21.0,<0.22.0) ; extra == "experimental" or extra == "all"
 Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests" or extra == "desktop" or extra == "all"