minitap-mobile-use 2.0.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

minitap/mobile_use/main.py

@@ -1,12 +1,11 @@
 import asyncio
 import os
-from typing import Optional
 
 import typer
 from adbutils import AdbClient
 from langchain.callbacks.base import Callbacks
 from rich.console import Console
-from typing_extensions import Annotated
+from typing import Annotated
 
 from minitap.mobile_use.config import (
     initialize_llm_config,
@@ -24,9 +23,9 @@ logger = get_logger(__name__)
 
 async def run_automation(
     goal: str,
-    test_name: Optional[str] = None,
+    test_name: str | None = None,
     traces_output_path_str: str = "traces",
-    output_description: Optional[str] = None,
+    output_description: str | None = None,
     graph_config_callbacks: Callbacks = [],
 ):
     llm_config = initialize_llm_config()
@@ -36,9 +35,9 @@ async def run_automation(
     if settings.ADB_HOST:
         config.with_adb_server(host=settings.ADB_HOST, port=settings.ADB_PORT)
     if settings.DEVICE_HARDWARE_BRIDGE_BASE_URL:
-        config.with_hw_bridge_base_url(url=settings.DEVICE_HARDWARE_BRIDGE_BASE_URL)
+        config.with_hw_bridge(url=settings.DEVICE_HARDWARE_BRIDGE_BASE_URL)
     if settings.DEVICE_SCREEN_API_BASE_URL:
-        config.with_screen_api_base_url(url=settings.DEVICE_SCREEN_API_BASE_URL)
+        config.with_screen_api(url=settings.DEVICE_SCREEN_API_BASE_URL)
     if graph_config_callbacks:
         config.with_graph_config_callbacks(graph_config_callbacks)
 
@@ -70,7 +69,7 @@ async def run_automation(
 def main(
     goal: Annotated[str, typer.Argument(help="The main goal for the agent to achieve.")],
     test_name: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             "--test-name",
             "-n",
@@ -86,7 +85,7 @@ def main(
         ),
     ] = "traces",
     output_description: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             "--output-description",
             "-o",

minitap/mobile_use/sdk/agent.py

@@ -6,7 +6,7 @@ import uuid
 from datetime import datetime
 from pathlib import Path
 from types import NoneType
-from typing import Optional, TypeVar, overload
+from typing import TypeVar, overload
 
 from adbutils import AdbClient
 from langchain_core.messages import AIMessage
@@ -61,7 +61,7 @@ from minitap.mobile_use.utils.recorder import log_agent_thought
 
 logger = get_logger(__name__)
 
-TOutput = TypeVar("TOutput", bound=Optional[BaseModel])
+TOutput = TypeVar("TOutput", bound=BaseModel | None)
 
 
 class Agent:
@@ -74,9 +74,9 @@ class Agent:
     _device_context: DeviceContext
     _screen_api_client: ScreenApiClient
     _hw_bridge_client: DeviceHardwareClient
-    _adb_client: Optional[AdbClient]
+    _adb_client: AdbClient | None
 
-    def __init__(self, config: Optional[AgentConfig] = None):
+    def __init__(self, config: AgentConfig | None = None):
         self._config = config or get_default_agent_config()
         self._tasks = []
         self._tmp_traces_dir = Path(tempfile.gettempdir()) / "mobile-use-traces"
@@ -153,9 +153,9 @@ class Agent:
         *,
         goal: str,
         output: type[TOutput],
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-    ) -> Optional[TOutput]: ...
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+    ) -> TOutput | None: ...
 
     @overload
     async def run_task(
@@ -163,9 +163,9 @@ class Agent:
         *,
         goal: str,
         output: str,
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-    ) -> Optional[str | dict]: ...
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+    ) -> str | dict | None: ...
 
     @overload
     async def run_task(
@@ -173,25 +173,25 @@ class Agent:
         *,
         goal: str,
         output=None,
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-    ) -> Optional[str]: ...
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+    ) -> str | None: ...
 
     @overload
-    async def run_task(self, *, request: TaskRequest[None]) -> Optional[str | dict]: ...
+    async def run_task(self, *, request: TaskRequest[None]) -> str | dict | None: ...
 
     @overload
-    async def run_task(self, *, request: TaskRequest[TOutput]) -> Optional[TOutput]: ...
+    async def run_task(self, *, request: TaskRequest[TOutput]) -> TOutput | None: ...
 
     async def run_task(
         self,
         *,
-        goal: Optional[str] = None,
-        output: Optional[type[TOutput] | str] = None,
-        profile: Optional[str | AgentProfile] = None,
-        name: Optional[str] = None,
-        request: Optional[TaskRequest[TOutput]] = None,
-    ) -> Optional[str | dict | TOutput]:
+        goal: str | None = None,
+        output: type[TOutput] | str | None = None,
+        profile: str | AgentProfile | None = None,
+        name: str | None = None,
+        request: TaskRequest[TOutput] | None = None,
+    ) -> str | dict | TOutput | None:
         if request is not None:
             return await self._run_task(request)
         if goal is None:
@@ -208,7 +208,7 @@ class Agent:
             task_request.with_name(name=name)
         return await self._run_task(task_request.build())
 
-    async def _run_task(self, request: TaskRequest[TOutput]) -> Optional[str | dict | TOutput]:
+    async def _run_task(self, request: TaskRequest[TOutput]) -> str | dict | TOutput | None:
         if not self._initialized:
             raise AgentNotInitializedError()
 
@@ -278,13 +278,12 @@ class Agent:
                         )
 
                 if stream_mode == "updates":
-                    for key, value in payload.items():  # type: ignore
+                    for _, value in payload.items():  # type: ignore node name, node output
                         if value and "agents_thoughts" in value:
                             new_thoughts = value["agents_thoughts"]
                             last_item = new_thoughts[-1] if new_thoughts else None
                             if last_item:
                                 log_agent_thought(
-                                    prefix=key,
                                     agent_thought=last_item,
                                 )
 
@@ -382,9 +381,9 @@ class Agent:
         task_name: str,
         ctx: MobileUseContext,
         request: TaskRequest[TOutput],
-        output_config: Optional[OutputConfig],
+        output_config: OutputConfig | None,
         state: State,
-    ) -> Optional[str | dict | TOutput]:
+    ) -> str | dict | TOutput | None:
         if output_config and output_config.needs_structured_format():
             logger.info(f"[{task_name}] Generating structured output...")
             try:

minitap/mobile_use/sdk/builders/agent_config_builder.py

@@ -3,7 +3,6 @@ Builder for AgentConfig objects using a fluent interface.
 """
 
 import copy
-from typing import Dict, List, Optional
 
 from langchain_core.callbacks.base import Callbacks
 
@@ -39,11 +38,11 @@ class AgentConfigBuilder:
 
     def __init__(self):
         """Initialize an empty AgentConfigBuilder."""
-        self._agent_profiles: Dict[str, AgentProfile] = {}
-        self._task_request_defaults: Optional[TaskRequestCommon] = None
-        self._default_profile: Optional[str | AgentProfile] = None
-        self._device_id: Optional[str] = None
-        self._device_platform: Optional[DevicePlatform] = None
+        self._agent_profiles: dict[str, AgentProfile] = {}
+        self._task_request_defaults: TaskRequestCommon | None = None
+        self._default_profile: str | AgentProfile | None = None
+        self._device_id: str | None = None
+        self._device_platform: DevicePlatform | None = None
         self._servers: ServerConfig = get_default_servers()
         self._graph_config_callbacks: Callbacks = None
 
@@ -58,7 +57,7 @@ class AgentConfigBuilder:
         profile.llm_config.validate_providers()
         return self
 
-    def add_profiles(self, profiles: List[AgentProfile]) -> "AgentConfigBuilder":
+    def add_profiles(self, profiles: list[AgentProfile]) -> "AgentConfigBuilder":
         """
         Add multiple agent profiles to the mobile-use agent.
 
@@ -106,7 +105,7 @@ class AgentConfigBuilder:
         self._task_request_defaults = copy.deepcopy(config)
         return self
 
-    def with_hw_bridge_base_url(self, url: str | ApiBaseUrl) -> "AgentConfigBuilder":
+    def with_hw_bridge(self, url: str | ApiBaseUrl) -> "AgentConfigBuilder":
         """
         Set the base URL for the device HW bridge API.
 
@@ -118,7 +117,7 @@ class AgentConfigBuilder:
         self._servers.hw_bridge_base_url = url
         return self
 
-    def with_screen_api_base_url(self, url: str | ApiBaseUrl) -> "AgentConfigBuilder":
+    def with_screen_api(self, url: str | ApiBaseUrl) -> "AgentConfigBuilder":
         """
         Set the base URL for the device screen API.
 
@@ -130,7 +129,7 @@ class AgentConfigBuilder:
         self._servers.screen_api_base_url = url
         return self
 
-    def with_adb_server(self, host: str, port: Optional[int] = None) -> "AgentConfigBuilder":
+    def with_adb_server(self, host: str, port: int | None = None) -> "AgentConfigBuilder":
         """
         Set the ADB server host and port.
 

minitap/mobile_use/sdk/builders/task_request_builder.py

@@ -3,7 +3,7 @@ Builder for TaskRequest objects using a fluent interface.
 """
 
 from pathlib import Path
-from typing import Generic, Optional, Self, TypeVar, cast
+from typing import Self, TypeVar, cast
 
 from pydantic import BaseModel
 
@@ -12,7 +12,7 @@ from minitap.mobile_use.sdk.types.agent import AgentProfile
 from minitap.mobile_use.sdk.types.task import TaskRequest, TaskRequestCommon
 
 
-TIn = TypeVar("TIn", bound=Optional[BaseModel])
+TIn = TypeVar("TIn", bound=BaseModel | None)
 TOut = TypeVar("TOut", bound=BaseModel)
 
 
@@ -25,8 +25,8 @@ class TaskRequestCommonBuilder(BaseModel):
         self._max_steps = RECURSION_LIMIT
         self._record_trace = False
         self._trace_path = Path("mobile-use-traces")
-        self._llm_output_path: Optional[Path] = None
-        self._thoughts_output_path: Optional[Path] = None
+        self._llm_output_path: Path | None = None
+        self._thoughts_output_path: Path | None = None
 
     def with_max_steps(self, max_steps: int) -> Self:
         """
@@ -38,7 +38,7 @@ class TaskRequestCommonBuilder(BaseModel):
         self._max_steps = max_steps
         return self
 
-    def with_trace_recording(self, enabled: bool = True, path: Optional[str] = None) -> Self:
+    def with_trace_recording(self, enabled: bool = True, path: str | None = None) -> Self:
         """
         Configure trace recording for the task.
 
@@ -92,7 +92,7 @@ class TaskRequestCommonBuilder(BaseModel):
         )
 
 
-class TaskRequestBuilder(TaskRequestCommonBuilder, Generic[TIn]):
+class TaskRequestBuilder[TIn](TaskRequestCommonBuilder):
     """
     Builder class providing a fluent interface for creating TaskRequest objects.
 
@@ -114,10 +114,10 @@ class TaskRequestBuilder(TaskRequestCommonBuilder, Generic[TIn]):
         """Initialize an empty TaskRequestBuilder."""
         super().__init__()
         self._goal = goal
-        self._profile: Optional[str | AgentProfile] = None
-        self._name: Optional[str] = None
+        self._profile: str | AgentProfile | None = None
+        self._name: str | None = None
         self._output_description = None
-        self._output_format: Optional[type[TIn]] = None
+        self._output_format: type[TIn] | None = None
 
     @classmethod
     def from_common(cls, goal: str, common: TaskRequestCommon):

minitap/mobile_use/sdk/examples/smart_notification_assistant.py

@@ -20,7 +20,6 @@ Run:
 import asyncio
 from datetime import datetime
 from enum import Enum
-from typing import List
 
 from pydantic import BaseModel, Field
 from minitap.mobile_use.config import LLM, LLMConfig, LLMConfigUtils, LLMWithFallback
@@ -52,7 +51,7 @@ class NotificationSummary(BaseModel):
 
     total_count: int = Field(..., description="Total number of notifications found")
     high_priority_count: int = Field(0, description="Count of high priority notifications")
-    notifications: List[Notification] = Field(
+    notifications: list[Notification] = Field(
         default_factory=list, description="List of individual notifications"
     )
 

minitap/mobile_use/sdk/types/agent.py

@@ -1,4 +1,4 @@
-from typing import Dict, Literal, Optional
+from typing import Literal
 from urllib.parse import urlparse
 
 from langchain_core.callbacks.base import Callbacks
@@ -15,7 +15,7 @@ class ApiBaseUrl(BaseModel):
 
     scheme: Literal["http", "https"]
     host: str
-    port: Optional[int] = None
+    port: int | None = None
 
     def __eq__(self, other):
         if not isinstance(other, ApiBaseUrl):
@@ -67,11 +67,11 @@ class AgentConfig(BaseModel):
         servers: Custom server configurations.
     """
 
-    agent_profiles: Dict[str, AgentProfile]
+    agent_profiles: dict[str, AgentProfile]
     task_request_defaults: TaskRequestCommon
     default_profile: AgentProfile
-    device_id: Optional[str] = None
-    device_platform: Optional[DevicePlatform] = None
+    device_id: str | None = None
+    device_platform: DevicePlatform | None = None
     servers: ServerConfig
     graph_config_callbacks: Callbacks = None
 

minitap/mobile_use/sdk/types/task.py

@@ -5,7 +5,8 @@ Task-related type definitions for the Mobile-use SDK.
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Generic, Optional, Type, TypeVar, overload
+from typing import Any, TypeVar, overload
+
 from pydantic import BaseModel, Field
 
 from minitap.mobile_use.config import LLMConfig, get_default_llm_config
@@ -36,8 +37,8 @@ class AgentProfile(BaseModel):
         self,
         *,
         name: str,
-        llm_config: Optional[LLMConfig] = None,
-        from_file: Optional[str] = None,
+        llm_config: LLMConfig | None = None,
+        from_file: str | None = None,
         **kwargs,
     ):
         kwargs["name"] = name
@@ -64,7 +65,7 @@ class TaskStatus(str, Enum):
 
 
 T = TypeVar("T", bound=BaseModel)
-TOutput = TypeVar("TOutput", bound=Optional[BaseModel])
+TOutput = TypeVar("TOutput", bound=BaseModel | None)
 
 
 class TaskRequestCommon(BaseModel):
@@ -75,11 +76,11 @@ class TaskRequestCommon(BaseModel):
     max_steps: int = RECURSION_LIMIT
     record_trace: bool = False
     trace_path: Path = Path("mobile-use-traces")
-    llm_output_path: Optional[Path] = None
-    thoughts_output_path: Optional[Path] = None
+    llm_output_path: Path | None = None
+    thoughts_output_path: Path | None = None
 
 
-class TaskRequest(TaskRequestCommon, Generic[TOutput]):
+class TaskRequest[TOutput](TaskRequestCommon):
     """
     Defines the format of a mobile automation task request.
 
@@ -98,10 +99,10 @@ class TaskRequest(TaskRequestCommon, Generic[TOutput]):
     """
 
     goal: str
-    profile: Optional[str] = None
-    task_name: Optional[str] = None
-    output_description: Optional[str] = None
-    output_format: Optional[type[TOutput]] = None
+    profile: str | None = None
+    task_name: str | None = None
+    output_description: str | None = None
+    output_format: type[TOutput] | None = None
 
 
 class TaskResult(BaseModel):
@@ -116,11 +117,11 @@ class TaskResult(BaseModel):
     """
 
     content: Any = None
-    error: Optional[str] = None
+    error: str | None = None
     execution_time_seconds: float
     steps_taken: int
 
-    def get_as_model(self, model_class: Type[T]) -> T:
+    def get_as_model(self, model_class: type[T]) -> T:
         """
         Parse the content into a Pydantic model instance.
 
@@ -158,14 +159,14 @@ class Task(BaseModel):
     status: TaskStatus
     request: TaskRequest
     created_at: datetime
-    ended_at: Optional[datetime] = None
-    result: Optional[TaskResult] = None
+    ended_at: datetime | None = None
+    result: TaskResult | None = None
 
     def finalize(
         self,
-        content: Optional[Any] = None,
-        state: Optional[dict] = None,
-        error: Optional[str] = None,
+        content: Any | None = None,
+        state: dict | None = None,
+        error: str | None = None,
         cancelled: bool = False,
     ):
         self.status = TaskStatus.COMPLETED if error is None else TaskStatus.FAILED

minitap/mobile_use/sdk/utils.py

@@ -2,11 +2,11 @@ import os
 from pathlib import Path
 
 from pydantic import ValidationError
+
 from minitap.mobile_use.config import LLMConfig, deep_merge_llm_config, get_default_llm_config
 from minitap.mobile_use.utils.file import load_jsonc
 from minitap.mobile_use.utils.logger import get_logger
 
-
 logger = get_logger(__name__)
 
 
@@ -16,7 +16,7 @@ def load_llm_config_override(path: Path) -> LLMConfig:
     override_config_dict = {}
     if os.path.exists(path):
         logger.info(f"Loading custom LLM config from {path.resolve()}...")
-        with open(path, "r") as f:
+        with open(path) as f:
             override_config_dict = load_jsonc(f)
     else:
         logger.warning("Custom LLM config not found - using the default config")
@@ -24,5 +24,6 @@ def load_llm_config_override(path: Path) -> LLMConfig:
     try:
         return deep_merge_llm_config(default_config, override_config_dict)
     except ValidationError as e:
-        logger.error(f"Invalid LLM config: {e}. Falling back to default config")
+        logger.error(f"Invalid LLM config: {e}")
+        logger.info("Falling back to default config")
         return default_config

minitap/mobile_use/servers/config.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from dotenv import load_dotenv
 from minitap.mobile_use.servers.device_hardware_bridge import DEVICE_HARDWARE_BRIDGE_PORT
 from minitap.mobile_use.utils.logger import get_logger
@@ -11,7 +10,7 @@ logger = get_logger(__name__)
 class ServerSettings(BaseSettings):
     DEVICE_HARDWARE_BRIDGE_BASE_URL: str = f"http://localhost:{DEVICE_HARDWARE_BRIDGE_PORT}"
     DEVICE_SCREEN_API_PORT: int = 9998
-    ADB_HOST: Optional[str] = None
+    ADB_HOST: str | None = None
 
     model_config = {"env_file": ".env", "extra": "ignore"}
 

minitap/mobile_use/servers/device_hardware_bridge.py

@@ -4,7 +4,6 @@ import subprocess
 import threading
 import time
 from enum import Enum
-from typing import Optional
 
 import requests
 from minitap.mobile_use.context import DevicePlatform
@@ -24,7 +23,7 @@ class BridgeStatus(Enum):
 
 
 class DeviceHardwareBridge:
-    def __init__(self, device_id: str, platform: DevicePlatform, adb_host: Optional[str] = None):
+    def __init__(self, device_id: str, platform: DevicePlatform, adb_host: str | None = None):
         self.process = None
         self.status = BridgeStatus.STOPPED
         self.thread = None
@@ -32,7 +31,7 @@ class DeviceHardwareBridge:
         self.lock = threading.Lock()
         self.device_id: str = device_id
         self.platform: DevicePlatform = platform
-        self.adb_host: Optional[str] = adb_host
+        self.adb_host: str | None = adb_host
 
     def _run_maestro_studio(self):
         try:
@@ -207,6 +206,6 @@ class DeviceHardwareBridge:
         with self.lock:
             return {"status": self.status.value, "output": self.output[-10:]}
 
-    def get_device_id(self) -> Optional[str]:
+    def get_device_id(self) -> str | None:
         with self.lock:
             return self.device_id

minitap/mobile_use/servers/start_servers.py

@@ -4,7 +4,7 @@ import signal
 import sys
 import time
 from enum import Enum
-from typing import Annotated, Optional
+from typing import Annotated
 
 import requests
 import typer
@@ -22,7 +22,7 @@ bridge_instance = None
 shutdown_requested = False
 
 
-def check_device_screen_api_health(base_url: Optional[str] = None, max_retries=30, delay=1):
+def check_device_screen_api_health(base_url: str | None = None, max_retries=30, delay=1):
     base_url = base_url or f"http://localhost:{server_settings.DEVICE_SCREEN_API_PORT}"
     health_url = f"{base_url}/health"
 
@@ -49,7 +49,7 @@ def check_device_screen_api_health(base_url: Optional[str] = None, max_retries=3
     return False
 
 
-def _start_device_screen_api_process() -> Optional[multiprocessing.Process]:
+def _start_device_screen_api_process() -> multiprocessing.Process | None:
     try:
         process = multiprocessing.Process(target=start_device_screen_api, daemon=True)
         process.start()
@@ -61,7 +61,7 @@ def _start_device_screen_api_process() -> Optional[multiprocessing.Process]:
 
 def start_device_hardware_bridge(
     device_id: str, platform: DevicePlatform
-) -> Optional[DeviceHardwareBridge]:
+) -> DeviceHardwareBridge | None:
     logger.info("Starting Device Hardware Bridge...")
 
     try:

minitap/mobile_use/servers/stop_servers.py

@@ -1,6 +1,5 @@
 import sys
 import time
-from typing import List
 
 import psutil
 import requests
@@ -12,7 +11,7 @@ from minitap.mobile_use.utils.logger import get_server_logger
 logger = get_server_logger()
 
 
-def find_processes_by_name(name: str) -> List[psutil.Process]:
+def find_processes_by_name(name: str) -> list[psutil.Process]:
     """Find all processes with the given name."""
     processes = []
     for proc in psutil.process_iter(["pid", "name", "cmdline"]):
@@ -26,7 +25,7 @@ def find_processes_by_name(name: str) -> List[psutil.Process]:
     return processes
 
 
-def find_processes_by_port(port: int) -> List[psutil.Process]:
+def find_processes_by_port(port: int) -> list[psutil.Process]:
     processes = []
     for proc in psutil.process_iter(["pid", "name"]):
         try:

minitap/mobile_use/services/llm.py

@@ -1,9 +1,12 @@
 import logging
-from typing import Awaitable, Callable, Literal, TypeVar
-from typing_extensions import overload
+from collections.abc import Awaitable, Callable
+from typing import Literal, TypeVar, overload
 
+from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_google_vertexai import ChatVertexAI
 from langchain_openai import ChatOpenAI
+
 from minitap.mobile_use.config import (
     AgentNode,
     AgentNodeWithFallback,
@@ -31,6 +34,19 @@ def get_google_llm(
     return client
 
 
+def get_vertex_llm(
+    model_name: str = "gemini-2.5-pro",
+    temperature: float = 0.7,
+) -> ChatVertexAI:
+    client = ChatVertexAI(
+        model_name=model_name,
+        max_tokens=None,
+        temperature=temperature,
+        max_retries=2,
+    )
+    return client
+
+
 def get_openai_llm(
     model_name: str = "o3",
     temperature: float = 1,
@@ -74,7 +90,7 @@ def get_llm(
     *,
     use_fallback: bool = False,
     temperature: float = 1,
-): ...
+) -> BaseChatModel: ...
 
 
 @overload
@@ -83,7 +99,7 @@ def get_llm(
     name: AgentNode,
     *,
     temperature: float = 1,
-): ...
+) -> BaseChatModel: ...
 
 
 @overload
@@ -93,7 +109,7 @@ def get_llm(
     *,
     is_utils: Literal[True],
     temperature: float = 1,
-): ...
+) -> BaseChatModel: ...
 
 
 def get_llm(
@@ -102,7 +118,7 @@ def get_llm(
     is_utils: bool = False,
     use_fallback: bool = False,
     temperature: float = 1,
-):
+) -> BaseChatModel:
     llm = (
         ctx.llm_config.get_utils(name)  # type: ignore
         if is_utils
@@ -117,6 +133,8 @@ def get_llm(
         return get_openai_llm(llm.model, temperature)
     elif llm.provider == "google":
         return get_google_llm(llm.model, temperature)
+    elif llm.provider == "vertexai":
+        return get_vertex_llm(llm.model, temperature)
     elif llm.provider == "openrouter":
         return get_openrouter_llm(llm.model, temperature)
     elif llm.provider == "xai":