android-midscene-automation 0.2.4 → 1.1.1

package/artemis-main/artemis/llm/reliability.py

@@ -0,0 +1,267 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Failure classification, retry policies, and circuit breaking for LLM calls.
+
+This is the single source of truth for how ARTEMIS reacts to a failed model
+call.  Every provider/transport exception is converted into a ``Failure``
+carrying explicit recovery decisions, and every retry loop in the codebase is
+expected to consult ``retry_policy_for`` instead of inventing its own rules.
+
+The taxonomy was promoted from ``artemis.agents.video_analyzer.reliability``
+(which now extends it with media-specific categories) so that the same
+classification and circuit-breaker quality applies to every agent call, not
+just the video pipeline.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+import random
+import threading
+import time
+from typing import Any
+
+
+class FailureCategory(StrEnum):
+    RATE_LIMIT = "rate_limit"
+    PROVIDER_UNAVAILABLE = "provider_unavailable"
+    TIMEOUT = "timeout"
+    CONNECTION = "connection"
+    AUTHENTICATION = "authentication"
+    BAD_REQUEST = "bad_request"
+    CANCELLED = "cancelled"
+    UNKNOWN = "unknown"
+
+
+#: Categories that count toward circuit-breaker state: transient provider-side
+#: trouble where hammering the endpoint makes things worse.
+TRANSIENT_CATEGORIES: frozenset[str] = frozenset(
+    {
+        FailureCategory.RATE_LIMIT.value,
+        FailureCategory.PROVIDER_UNAVAILABLE.value,
+        FailureCategory.TIMEOUT.value,
+        FailureCategory.CONNECTION.value,
+    }
+)
+
+
+@dataclass(frozen=True)
+class Failure:
+    category: FailureCategory
+    retryable: bool
+    should_fallback: bool
+
+
+def extract_status_code(error: BaseException) -> int | None:
+    """Best-effort extraction of an HTTP-ish status code from an exception."""
+    code = getattr(error, "code", None) or getattr(error, "status_code", None)
+    try:
+        return int(code) if code is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+_RATE_LIMIT_MARKERS = ("rate limit", "quota", "resource_exhausted")
+_UNAVAILABLE_MARKERS = ("unavailable", "overloaded", "high demand", "service unavailable")
+_AUTH_MARKERS = ("unauthorized", "forbidden", "api key", "credential")
+# "deadline exceeded"/"deadline_exceeded" cover google-genai SDK timeouts that
+# surface without an HTTP status code attached.
+_TIMEOUT_MARKERS = ("timed out", "timeout", "deadline exceeded", "deadline_exceeded")
+
+
+def classify_failure(error: BaseException) -> Failure:
+    """Convert a provider/transport exception into explicit recovery decisions."""
+    if isinstance(error, KeyboardInterrupt) or type(error).__name__ == "CancelledError":
+        return Failure(FailureCategory.CANCELLED, False, False)
+
+    code = extract_status_code(error)
+    message = str(error).lower()
+
+    if code == 429 or any(marker in message for marker in _RATE_LIMIT_MARKERS):
+        return Failure(FailureCategory.RATE_LIMIT, True, True)
+    if code in {500, 502, 503, 504} or any(marker in message for marker in _UNAVAILABLE_MARKERS):
+        return Failure(FailureCategory.PROVIDER_UNAVAILABLE, True, True)
+    if isinstance(error, TimeoutError) or any(marker in message for marker in _TIMEOUT_MARKERS):
+        return Failure(FailureCategory.TIMEOUT, True, True)
+    if isinstance(error, (ConnectionError, OSError)):
+        return Failure(FailureCategory.CONNECTION, True, True)
+    if code in {401, 403} or any(marker in message for marker in _AUTH_MARKERS):
+        # Not retryable against the same endpoint, but a fallback endpoint may
+        # use a different (working) credential.
+        return Failure(FailureCategory.AUTHENTICATION, False, True)
+    if code in {400, 404, 413, 415, 422}:
+        # Programmer/request errors: retrying is useless and falling back only
+        # hides the bug inside a different model's output.
+        return Failure(FailureCategory.BAD_REQUEST, False, False)
+    return Failure(FailureCategory.UNKNOWN, True, True)
+
+
+# ---------------------------------------------------------------------------
+# Typed terminal errors
+# ---------------------------------------------------------------------------
+
+
+class LLMCallError(Exception):
+    """Base class for terminal LLM call failures raised by the gateway."""
+
+    def __init__(self, message: str, *, failure: Failure, cause: BaseException | None = None):
+        super().__init__(message)
+        self.failure = failure
+        if cause is not None:
+            self.__cause__ = cause
+
+
+class LLMPermanentError(LLMCallError):
+    """A non-retryable failure (auth, bad request). Retrying cannot help."""
+
+
+class LLMExhaustedError(LLMCallError):
+    """Retryable failures exhausted every attempt and the pause deadline."""
+
+
+# ---------------------------------------------------------------------------
+# Retry policies
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class RetryPolicy:
+    """How many attempts a failure category deserves and how to space them."""
+
+    max_attempts: int
+    base_delay: float
+    max_delay: float
+
+    def delay_for(self, attempt: int) -> float:
+        """Backoff delay before retry number ``attempt`` (1-based)."""
+        delay = min(self.max_delay, self.base_delay * (2 ** max(0, attempt - 1)))
+        return delay + random.uniform(0.1, 0.5)
+
+
+_DEFAULT_RETRY_POLICIES: dict[FailureCategory, RetryPolicy] = {
+    FailureCategory.RATE_LIMIT: RetryPolicy(max_attempts=4, base_delay=10.0, max_delay=60.0),
+    FailureCategory.PROVIDER_UNAVAILABLE: RetryPolicy(
+        max_attempts=4, base_delay=5.0, max_delay=30.0
+    ),
+    FailureCategory.TIMEOUT: RetryPolicy(max_attempts=3, base_delay=2.0, max_delay=15.0),
+    FailureCategory.CONNECTION: RetryPolicy(max_attempts=3, base_delay=2.0, max_delay=15.0),
+    FailureCategory.UNKNOWN: RetryPolicy(max_attempts=2, base_delay=1.0, max_delay=5.0),
+    # Non-retryable categories get a single attempt by definition.
+    FailureCategory.AUTHENTICATION: RetryPolicy(max_attempts=1, base_delay=0.0, max_delay=0.0),
+    FailureCategory.BAD_REQUEST: RetryPolicy(max_attempts=1, base_delay=0.0, max_delay=0.0),
+    FailureCategory.CANCELLED: RetryPolicy(max_attempts=1, base_delay=0.0, max_delay=0.0),
+}
+
+
+def retry_policy_for(category: FailureCategory | str) -> RetryPolicy:
+    """Look up the retry policy for a failure category.
+
+    Accepts the generic ``FailureCategory`` or any string-valued category from
+    a domain extension (e.g. the video pipeline's ``VideoFailureCategory``).
+    Extension-only categories fall back to the UNKNOWN policy, so callers must
+    gate on ``failure.retryable`` before consulting attempt counts.
+    """
+    if not isinstance(category, FailureCategory):
+        try:
+            category = FailureCategory(str(category))
+        except ValueError:
+            category = FailureCategory.UNKNOWN
+    return _DEFAULT_RETRY_POLICIES.get(category, _DEFAULT_RETRY_POLICIES[FailureCategory.UNKNOWN])
+
+
+# ---------------------------------------------------------------------------
+# Circuit breaker
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class _CircuitState:
+    consecutive_failures: int = 0
+    open_until: float = 0.0
+    half_open_in_flight: bool = False
+
+
+class CircuitBreaker:
+    """Small circuit breaker keyed by provider/model identity.
+
+    Only transient categories (see ``TRANSIENT_CATEGORIES``) trip the breaker;
+    programmer errors and auth failures never open it.  ``failure`` may be any
+    object with a ``category`` attribute whose value matches this module's
+    category strings, so domain extensions (e.g. the video pipeline's failure
+    type) plug in without conversion.
+    """
+
+    def __init__(self, threshold: int = 3, cooldown_seconds: float = 60.0) -> None:
+        self.threshold = max(1, int(threshold))
+        self.cooldown_seconds = max(0.1, float(cooldown_seconds))
+        self._states: dict[str, _CircuitState] = {}
+        self._lock = threading.RLock()
+
+    def allow(self, key: str, *, now: float | None = None) -> bool:
+        current = time.time() if now is None else now
+        with self._lock:
+            state = self._states.get(key)
+            if state is None:
+                return True
+            if state.open_until:
+                if current < state.open_until or state.half_open_in_flight:
+                    return False
+                # Half-open: permit exactly one trial. Other concurrent calls
+                # continue to bypass the primary until it succeeds or fails.
+                state.half_open_in_flight = True
+                state.consecutive_failures = max(0, self.threshold - 1)
+                return True
+            return not state.half_open_in_flight
+
+    def open_remaining(self, key: str, *, now: float | None = None) -> float:
+        """Seconds until the circuit for ``key`` half-opens (0 if not open)."""
+        current = time.time() if now is None else now
+        with self._lock:
+            state = self._states.get(key)
+            if state is None or not state.open_until:
+                return 0.0
+            return max(0.0, state.open_until - current)
+
+    def record_success(self, key: str) -> None:
+        with self._lock:
+            self._states.pop(key, None)
+
+    def record_failure(self, key: str, failure: Any, *, now: float | None = None) -> None:
+        category = str(getattr(failure, "category", ""))
+        if category not in TRANSIENT_CATEGORIES:
+            with self._lock:
+                state = self._states.get(key)
+                if state is not None and state.half_open_in_flight:
+                    self._states.pop(key, None)
+            return
+        current = time.time() if now is None else now
+        with self._lock:
+            state = self._states.setdefault(key, _CircuitState())
+            state.half_open_in_flight = False
+            state.consecutive_failures += 1
+            if state.consecutive_failures >= self.threshold:
+                state.open_until = current + self.cooldown_seconds
+
+    def snapshot(self) -> dict[str, dict[str, Any]]:
+        with self._lock:
+            return {
+                key: {
+                    "consecutive_failures": state.consecutive_failures,
+                    "open_until": state.open_until,
+                    "half_open_in_flight": state.half_open_in_flight,
+                }
+                for key, state in self._states.items()
+            }

package/artemis-main/artemis/llm/router.py

@@ -0,0 +1,389 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Dynamic Multi-Provider Model Router for ARTEMIS.
+
+Provides role-based LLM/VLM dispatching, dynamic fallback chains,
+and unified provider configuration across Gemini, Vertex AI, OpenAI,
+Anthropic, OpenRouter, and local Ollama/vLLM endpoints.
+"""
+
+from enum import StrEnum
+import hashlib
+import os
+from typing import Any
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from pydantic import BaseModel, Field
+
+from artemis.config.settings import settings
+from artemis.llm.google.provider import supports_thinking_level
+from third_party.mobile_use.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ModelProvider(StrEnum):
+    GOOGLE = "google"
+    GEMINI = "google"
+    VERTEX_AI = "vertexai"
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    OPENROUTER = "openrouter"
+    XAI = "xai"
+    OLLAMA = "ollama"
+    VLLM = "vllm"
+    CUSTOM = "custom"
+
+    @classmethod
+    def from_string(cls, val: Any) -> "ModelProvider":
+        """Converts a string or enum into a canonical ModelProvider.
+
+        ``None``/empty means "use the default" (Google); an unrecognized
+        non-empty value raises instead of silently routing to Gemini with
+        the wrong credentials.
+        """
+        if isinstance(val, cls):
+            return val
+        if val is None:
+            return cls.GOOGLE
+        s = str(val).lower().replace("_", "").replace("-", "").strip()
+        if not s:
+            return cls.GOOGLE
+        mapping = {
+            "google": cls.GOOGLE,
+            "gemini": cls.GOOGLE,
+            "vertexai": cls.VERTEX_AI,
+            "vertex": cls.VERTEX_AI,
+            "openai": cls.OPENAI,
+            "anthropic": cls.ANTHROPIC,
+            "claude": cls.ANTHROPIC,
+            "openrouter": cls.OPENROUTER,
+            "xai": cls.XAI,
+            "grok": cls.XAI,
+            "ollama": cls.OLLAMA,
+            "vllm": cls.VLLM,
+            "custom": cls.CUSTOM,
+        }
+        provider = mapping.get(s)
+        if provider is None:
+            raise ValueError(
+                f"Unknown LLM provider {val!r}. Valid providers: {sorted(set(mapping))}"
+            )
+        return provider
+
+
+class ModelEndpoint(BaseModel):
+    """Configuration definition for an LLM/VLM model endpoint."""
+
+    provider: ModelProvider = Field(default=ModelProvider.GOOGLE, description="Model provider")
+    model_name: str = Field(default="gemini-2.5-flash", description="Model name identifier")
+    api_key: str | None = Field(default=None, description="API Key or secret")
+    api_base: str | None = Field(default=None, description="Custom API endpoint base URL")
+    temperature: float = Field(default=0.0, description="Sampling temperature")
+    max_tokens: int | None = Field(default=None, description="Maximum completion tokens")
+    timeout_seconds: float = Field(default=60.0, description="Request timeout in seconds")
+    is_multimodal: bool = Field(
+        default=True, description="Whether endpoint accepts image/video inputs"
+    )
+    reasoning_effort: str | None = Field(
+        default=None, description="Reasoning effort: 'low', 'medium', 'high'"
+    )
+    thinking_budget: int | None = Field(default=None, description="Thinking budget token count")
+    thinking_level: str | None = Field(
+        default=None, description="Thinking level: 'minimal', 'low', 'medium', 'high'"
+    )
+    include_thoughts: bool | None = Field(
+        default=None, description="Whether to include thought traces in response"
+    )
+    enable_grounding: bool = Field(
+        default=False,
+        description="Whether to enable Google Search grounding for Gemini endpoints",
+    )
+
+    def cache_key(self) -> tuple:
+        """Key the client cache by endpoint settings, hashing the API key."""
+        api_key_digest = (
+            hashlib.sha256(self.api_key.encode("utf-8")).hexdigest()[:16] if self.api_key else None
+        )
+        return (
+            self.provider.value,
+            self.model_name,
+            self.temperature,
+            self.max_tokens,
+            self.timeout_seconds,
+            self.thinking_budget,
+            self.thinking_level,
+            self.include_thoughts,
+            self.reasoning_effort,
+            self.enable_grounding,
+            self.api_base,
+            api_key_digest,
+        )
+
+
+def _patch_langchain_google_genai():
+    """Patches ChatGoogleGenerativeAI._process_tool_config to preserve and ensure include_server_side_tool_invocations."""
+    try:
+        from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
+        from google.genai.types import ToolConfig
+
+        if getattr(ChatGoogleGenerativeAI, "_is_artemis_patched", False):
+            return
+
+        original_process = ChatGoogleGenerativeAI._process_tool_config
+
+        def patched_process_tool_config(self, tool_choice, tool_config, formatted_tools):
+            config = original_process(self, tool_choice, tool_config, formatted_tools)
+
+            has_builtin = False
+            has_functions = False
+            if formatted_tools:
+                for tool in formatted_tools:
+                    tool_dict = tool if isinstance(tool, dict) else getattr(tool, "__dict__", {})
+                    if any(
+                        tool_dict.get(k) is not None
+                        for k in (
+                            "google_search",
+                            "code_execution",
+                            "google_maps",
+                            "google_search_retrieval",
+                        )
+                    ):
+                        has_builtin = True
+                    if tool_dict.get("function_declarations"):
+                        has_functions = True
+
+            if tool_config:
+                normalized = (
+                    ToolConfig.model_validate(tool_config)
+                    if isinstance(tool_config, dict)
+                    else tool_config
+                )
+                if getattr(normalized, "include_server_side_tool_invocations", None) is not None:
+                    if config is None:
+                        config = ToolConfig(
+                            include_server_side_tool_invocations=normalized.include_server_side_tool_invocations
+                        )
+                    else:
+                        config.include_server_side_tool_invocations = (
+                            normalized.include_server_side_tool_invocations
+                        )
+
+            if has_builtin and has_functions:
+                if config is None:
+                    config = ToolConfig(include_server_side_tool_invocations=True)
+                else:
+                    config.include_server_side_tool_invocations = True
+
+            return config
+
+        ChatGoogleGenerativeAI._process_tool_config = patched_process_tool_config
+        ChatGoogleGenerativeAI._is_artemis_patched = True
+    except Exception as e:
+        logger.warning(f"Could not patch ChatGoogleGenerativeAI._process_tool_config: {e}")
+
+
+class ModelFactory:
+    """Unified factory for instantiating and caching LangChain chat models across providers."""
+
+    _cache: dict[tuple, BaseChatModel] = {}
+
+    @classmethod
+    def get_model(cls, endpoint: ModelEndpoint) -> BaseChatModel:
+        key = endpoint.cache_key()
+        if key not in cls._cache:
+            cls._cache[key] = cls.create_model(endpoint)
+        return cls._cache[key]
+
+    @classmethod
+    def create_model(cls, endpoint: ModelEndpoint) -> BaseChatModel:
+        if os.environ.get("ARTEMIS_FAKE_LLM") == "1":
+            from artemis.llm.fake_model import FakeChatModel
+
+            delay = float(os.environ.get("ARTEMIS_FAKE_LLM_DELAY_S", "0") or 0)
+            logger.warning(
+                f"ARTEMIS_FAKE_LLM=1 — returning FakeChatModel (delay={delay}s) "
+                f"instead of {endpoint.provider}/{endpoint.model_name}"
+            )
+            return FakeChatModel(delay_s=delay)
+
+        provider = ModelProvider.from_string(endpoint.provider)
+
+        if provider == ModelProvider.GOOGLE:
+            _patch_langchain_google_genai()
+            from langchain_google_genai import (
+                ChatGoogleGenerativeAI,
+                HarmBlockThreshold,
+                HarmCategory,
+            )
+
+            api_key = (
+                endpoint.api_key
+                or (settings.GOOGLE_API_KEY.get_secret_value() if settings.GOOGLE_API_KEY else None)
+                or os.environ.get("GOOGLE_API_KEY")
+                or os.environ.get("GEMINI_API_KEY")
+            )
+            # Gemini 1.x/2.x only understand thinking_budget.
+            thinking_level = (
+                endpoint.thinking_level if supports_thinking_level(endpoint.model_name) else None
+            )
+
+            kwargs: dict[str, Any] = {
+                "model": endpoint.model_name,
+                "temperature": endpoint.temperature,
+                "max_output_tokens": endpoint.max_tokens,
+                "api_key": api_key,
+                "timeout": endpoint.timeout_seconds,
+                "thinking_budget": endpoint.thinking_budget,
+                "thinking_level": thinking_level,
+                "include_thoughts": endpoint.include_thoughts,
+                "safety_settings": {
+                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+                },
+            }
+            return ChatGoogleGenerativeAI(**{k: v for k, v in kwargs.items() if v is not None})
+
+        elif provider == ModelProvider.VERTEX_AI:
+            from langchain_google_vertexai import (
+                ChatVertexAI,
+                HarmBlockThreshold,
+                HarmCategory,
+            )
+
+            kwargs = {
+                "model_name": endpoint.model_name,
+                "temperature": endpoint.temperature,
+                "max_output_tokens": endpoint.max_tokens,
+                "timeout": endpoint.timeout_seconds,
+                "thinking_budget": endpoint.thinking_budget,
+                "safety_settings": {
+                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+                },
+            }
+            return ChatVertexAI(**{k: v for k, v in kwargs.items() if v is not None})
+
+        elif provider == ModelProvider.OPENAI:
+            from langchain_openai import ChatOpenAI
+
+            api_key = (
+                endpoint.api_key
+                or (settings.OPENAI_API_KEY.get_secret_value() if settings.OPENAI_API_KEY else None)
+                or os.environ.get("OPENAI_API_KEY", "EMPTY")
+            )
+            base_url = endpoint.api_base or (
+                str(settings.OPENAI_BASE_URL) if settings.OPENAI_BASE_URL else None
+            )
+            kwargs = {
+                "model": endpoint.model_name,
+                "temperature": endpoint.temperature,
+                "max_tokens": endpoint.max_tokens,
+                "api_key": api_key,
+                "base_url": base_url,
+                "timeout": endpoint.timeout_seconds,
+            }
+            if endpoint.reasoning_effort:
+                kwargs["reasoning_effort"] = endpoint.reasoning_effort
+            return ChatOpenAI(**{k: v for k, v in kwargs.items() if v is not None})
+
+        elif provider == ModelProvider.ANTHROPIC:
+            from langchain_anthropic import ChatAnthropic
+
+            api_key = (
+                endpoint.api_key
+                or (
+                    settings.ANTHROPIC_API_KEY.get_secret_value()
+                    if settings.ANTHROPIC_API_KEY
+                    else None
+                )
+                or os.environ.get("ANTHROPIC_API_KEY")
+            )
+            kwargs = {
+                "model": endpoint.model_name,
+                "temperature": endpoint.temperature,
+                "api_key": api_key,
+                "timeout": endpoint.timeout_seconds,
+            }
+            budget = endpoint.thinking_budget
+            if not budget and endpoint.reasoning_effort:
+                effort_map = {"low": 2048, "medium": 8192, "high": 32768}
+                budget = effort_map.get(endpoint.reasoning_effort.lower())
+            if budget:
+                kwargs["thinking"] = {"type": "enabled", "budget_tokens": budget}
+                kwargs["temperature"] = 1.0
+            return ChatAnthropic(**{k: v for k, v in kwargs.items() if v is not None})
+
+        elif provider == ModelProvider.OPENROUTER:
+            from langchain_openai import ChatOpenAI
+
+            api_key = (
+                endpoint.api_key
+                or (
+                    settings.OPEN_ROUTER_API_KEY.get_secret_value()
+                    if settings.OPEN_ROUTER_API_KEY
+                    else None
+                )
+                or os.environ.get("OPEN_ROUTER_API_KEY")
+            )
+            return ChatOpenAI(
+                model=endpoint.model_name,
+                temperature=endpoint.temperature,
+                api_key=api_key,
+                base_url=endpoint.api_base or "https://openrouter.ai/api/v1",
+                timeout=endpoint.timeout_seconds,
+            )
+
+        elif provider == ModelProvider.XAI:
+            from langchain_openai import ChatOpenAI
+
+            api_key = (
+                endpoint.api_key
+                or (settings.XAI_API_KEY.get_secret_value() if settings.XAI_API_KEY else None)
+                or os.environ.get("XAI_API_KEY")
+            )
+            return ChatOpenAI(
+                model=endpoint.model_name,
+                temperature=endpoint.temperature,
+                api_key=api_key,
+                base_url=endpoint.api_base or "https://api.x.ai/v1",
+                timeout=endpoint.timeout_seconds,
+            )
+
+        elif provider in (ModelProvider.OLLAMA, ModelProvider.VLLM, ModelProvider.CUSTOM):
+            from langchain_openai import ChatOpenAI
+
+            api_key = endpoint.api_key or os.environ.get("OPENAI_API_KEY", "EMPTY")
+            base_url = endpoint.api_base or os.environ.get(
+                "OPENAI_BASE_URL", "http://localhost:8000/v1"
+            )
+            kwargs = {
+                "model": endpoint.model_name,
+                "temperature": endpoint.temperature,
+                "max_tokens": endpoint.max_tokens,
+                "api_key": api_key,
+                "base_url": base_url,
+                "timeout": endpoint.timeout_seconds,
+            }
+            if endpoint.reasoning_effort:
+                kwargs["reasoning_effort"] = endpoint.reasoning_effort
+            return ChatOpenAI(**{k: v for k, v in kwargs.items() if v is not None})
+
+        else:
+            raise ValueError(f"Unsupported model provider: {provider}")

package/artemis-main/artemis/llm/schemas.py

@@ -0,0 +1,36 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Dynamic LLM Schema definitions."""
+
+from pydantic import BaseModel, Field
+
+
+class ModelParameters(BaseModel):
+    """Fine-grained generation hyperparameters."""
+
+    temperature: float = Field(default=0.0, ge=0.0, le=2.0)
+    top_p: float | None = Field(default=None, ge=0.0, le=1.0)
+    top_k: int | None = Field(default=None, ge=1)
+    max_output_tokens: int = Field(default=4096, ge=1)
+    seed: int | None = Field(default=None)
+
+
+class ThinkingBlock(BaseModel):
+    """Extracted internal chain-of-thought from thinking models."""
+
+    content: str = Field(..., description="Raw thought reasoning string")
+    is_native: bool = Field(
+        default=False, description="Whether thought was returned via native API field"
+    )