model api_base, litellm finalizing

agent.py

@@ -206,6 +206,7 @@ class AgentContext:
 class ModelConfig:
     provider: models.ModelProvider
     name: str
+    api_base: str = ""
     ctx_length: int = 0
     limit_requests: int = 0
     limit_input: int = 0
@@ -581,23 +582,29 @@ class Agent:
         return models.get_chat_model(
             self.config.chat_model.provider,
             self.config.chat_model.name,
-            **self.config.chat_model.kwargs,
+            **self._get_model_kwargs(self.config.chat_model),
         )
 
     def get_utility_model(self):
         return models.get_chat_model(
             self.config.utility_model.provider,
             self.config.utility_model.name,
-            **self.config.utility_model.kwargs,
+            **self._get_model_kwargs(self.config.utility_model),
         )
 
     def get_embedding_model(self):
         return models.get_embedding_model(
             self.config.embeddings_model.provider,
             self.config.embeddings_model.name,
-            **self.config.embeddings_model.kwargs,
+            **self._get_model_kwargs(self.config.embeddings_model),
         )
 
+    def _get_model_kwargs(self, model_config: ModelConfig):
+        kwargs = model_config.kwargs.copy() or {}
+        if model_config.api_base and "api_base" not in kwargs:
+            kwargs["api_base"] = model_config.api_base
+        return kwargs
+
     async def call_utility_model(
         self,
         system: str,

initialize.py

@@ -29,6 +29,7 @@ def initialize_agent():
     chat_llm = ModelConfig(
         provider=models.ModelProvider[current_settings["chat_model_provider"]],
         name=current_settings["chat_model_name"],
+        api_base=current_settings["chat_model_api_base"],
         ctx_length=current_settings["chat_model_ctx_length"],
         vision=current_settings["chat_model_vision"],
         limit_requests=current_settings["chat_model_rl_requests"],
@@ -41,6 +42,7 @@ def initialize_agent():
     utility_llm = ModelConfig(
         provider=models.ModelProvider[current_settings["util_model_provider"]],
         name=current_settings["util_model_name"],
+        api_base=current_settings["util_model_api_base"],
         ctx_length=current_settings["util_model_ctx_length"],
         limit_requests=current_settings["util_model_rl_requests"],
         limit_input=current_settings["util_model_rl_input"],
@@ -51,6 +53,7 @@ def initialize_agent():
     embedding_llm = ModelConfig(
         provider=models.ModelProvider[current_settings["embed_model_provider"]],
         name=current_settings["embed_model_name"],
+        api_base=current_settings["embed_model_api_base"],
         limit_requests=current_settings["embed_model_rl_requests"],
         kwargs=_normalize_model_kwargs(current_settings["embed_model_kwargs"]),
     )
@@ -58,6 +61,7 @@ def initialize_agent():
     browser_llm = ModelConfig(
         provider=models.ModelProvider[current_settings["browser_model_provider"]],
         name=current_settings["browser_model_name"],
+        api_base=current_settings["browser_model_api_base"],
         vision=current_settings["browser_model_vision"],
         kwargs=_normalize_model_kwargs(current_settings["browser_model_kwargs"]),
     )

models.py

@@ -59,19 +59,18 @@ class ModelType(Enum):
 
 class ModelProvider(Enum):
     ANTHROPIC = "Anthropic"
-    CHUTES = "Chutes"
     DEEPSEEK = "DeepSeek"
-    GOOGLE = "Google"
+    GEMINI = "Google"
     GROQ = "Groq"
     HUGGINGFACE = "HuggingFace"
-    LMSTUDIO = "LM Studio"
-    MISTRALAI = "Mistral AI"
+    LM_STUDIO = "LM Studio"
+    MISTRAL = "Mistral AI"
     OLLAMA = "Ollama"
     OPENAI = "OpenAI"
     AZURE = "OpenAI Azure"
     OPENROUTER = "OpenRouter"
     SAMBANOVA = "Sambanova"
-    OTHER = "Other"
+    OTHER = "Other OpenAI compatible"
 
 
 class ChatChunk(TypedDict):
@@ -84,42 +83,6 @@ class ChatChunk(TypedDict):
 rate_limiters: dict[str, RateLimiter] = {}
 
 
-def configure_litellm_environment():
-    env_mappings = {
-        "API_KEY_OPENAI": "OPENAI_API_KEY",
-        "API_KEY_ANTHROPIC": "ANTHROPIC_API_KEY",
-        "API_KEY_GROQ": "GROQ_API_KEY",
-        "API_KEY_GOOGLE": "GOOGLE_API_KEY",
-        "API_KEY_MISTRAL": "MISTRAL_API_KEY",
-        "API_KEY_OLLAMA": "OLLAMA_API_KEY",
-        "API_KEY_HUGGINGFACE": "HUGGINGFACE_API_KEY",
-        "API_KEY_OPENAI_AZURE": "AZURE_AI_API_KEY",
-        "API_KEY_DEEPSEEK": "DEEPSEEK_API_KEY",
-        "API_KEY_SAMBANOVA": "SAMBANOVA_API_KEY",
-        "API_KEY_GOOGLE": "GEMINI_API_KEY",
-    }
-    base_url_mappings = {
-        "OPENAI_BASE_URL": "OPENAI_API_BASE",
-        "ANTHROPIC_BASE_URL": "ANTHROPIC_API_BASE",
-        "GROQ_BASE_URL": "GROQ_API_BASE",
-        "GOOGLE_BASE_URL": "GOOGLE_API_BASE",
-        "MISTRAL_BASE_URL": "MISTRAL_API_BASE",
-        "OLLAMA_BASE_URL": "OLLAMA_API_BASE",
-        "HUGGINGFACE_BASE_URL": "HUGGINGFACE_API_BASE",
-        "AZURE_BASE_URL": "AZURE_AI_API_BASE",
-        "DEEPSEEK_BASE_URL": "DEEPSEEK_API_BASE",
-        "SAMBANOVA_BASE_URL": "SAMBANOVA_API_BASE",
-    }
-    for a0, llm in env_mappings.items():
-        val = dotenv.get_dotenv_value(a0)
-        if val and not os.getenv(llm):
-            os.environ[llm] = val
-    for a0_base, llm_base in base_url_mappings.items():
-        val = dotenv.get_dotenv_value(a0_base)
-        if val and not os.getenv(llm_base):
-            os.environ[llm_base] = val
-
-
 def get_api_key(service: str) -> str:
     return (
         dotenv.get_dotenv_value(f"API_KEY_{service.upper()}")
@@ -140,26 +103,6 @@ def get_rate_limiter(
     return limiter
 
 
-def _parse_chunk(chunk: Any) -> ChatChunk:
-    delta = chunk["choices"][0].get("delta", {})
-    message = chunk["choices"][0].get("model_extra", {}).get("message", {})
-    response_delta = (
-        delta.get("content", "")
-        if isinstance(delta, dict)
-        else getattr(delta, "content", "")
-    ) or (
-        message.get("content", "")
-        if isinstance(message, dict)
-        else getattr(message, "content", "")
-    )
-    reasoning_delta = (
-        delta.get("reasoning_content", "")
-        if isinstance(delta, dict)
-        else getattr(delta, "reasoning_content", "")
-    )
-    return ChatChunk(reasoning_delta=reasoning_delta, response_delta=response_delta)
-
-
 class LiteLLMChatWrapper(SimpleChatModel):
     model_name: str
     provider: str
@@ -284,7 +227,7 @@ class LiteLLMChatWrapper(SimpleChatModel):
         self,
         system_message="",
         user_message="",
-        messages: List[BaseMessage]|None = None,
+        messages: List[BaseMessage] | None = None,
         response_callback: Callable[[str, str], Awaitable[None]] | None = None,
         reasoning_callback: Callable[[str, str], Awaitable[None]] | None = None,
         tokens_callback: Callable[[str, int], Awaitable[None]] | None = None,
@@ -424,66 +367,86 @@ def _get_litellm_chat(
     provider_name: str = "",
     **kwargs: Any,
 ):
-    provider_name = provider_name.lower()
-
-    configure_litellm_environment()
-    # Use original provider name for API key lookup, fallback to mapped provider name
+    # use api key from kwargs or env
     api_key = kwargs.pop("api_key", None) or get_api_key(provider_name)
 
-    # litellm will pick up base_url from env. We just need to control the api_key.
-    # base_url = dotenv.get_dotenv_value(f"{provider_name.upper()}_BASE_URL")
-
-    # If a base_url is set, ensure api_key is not passed to litellm
-    # > remove, this can be handled by api_key=None
-    # if base_url:
-    #     if "api_key" in kwargs:
-    #         del kwargs["api_key"]
-    # Only pass API key if no base_url is set and key is not a placeholder
+    # Only pass API key if key is not a placeholder
     if api_key and api_key not in ("None", "NA"):
         kwargs["api_key"] = api_key
 
-    # for openrouter add app reference
-    if provider_name == "openrouter":
-        kwargs["extra_headers"] = {
-            "HTTP-Referer": "https://agent-zero.ai",
-            "X-Title": "Agent Zero",
-        }
-
-    return cls(model=model_name, provider=provider_name, **kwargs)
+    provider_name, model_name, kwargs = _adjust_call_args(
+        provider_name, model_name, kwargs
+    )
+    return cls(provider=provider_name, model=model_name, **kwargs)
 
 
-def get_litellm_embedding(model_name: str, provider: str, **kwargs: Any):
+def _get_litellm_embedding(model_name: str, provider_name: str, **kwargs: Any):
     # Check if this is a local sentence-transformers model
-    if provider == "huggingface" and model_name.startswith("sentence-transformers/"):
+    if provider_name == "huggingface" and model_name.startswith(
+        "sentence-transformers/"
+    ):
         # Use local sentence-transformers instead of LiteLLM for local models
-        return LocalSentenceTransformerWrapper(provider=provider, model=model_name, **kwargs)
-
-    configure_litellm_environment()
-    # Use original provider name for API key lookup, fallback to mapped provider name
-    api_key = kwargs.pop("api_key", None) or get_api_key(provider)
+        provider_name, model_name, kwargs = _adjust_call_args(
+            provider_name, model_name, kwargs
+        )
+        return LocalSentenceTransformerWrapper(
+            provider=provider_name, model=model_name, **kwargs
+        )
 
-    # litellm will pick up base_url from env. We just need to control the api_key.
-    # base_url = dotenv.get_dotenv_value(f"{provider.upper()}_BASE_URL")
+    # use api key from kwargs or env
+    api_key = kwargs.pop("api_key", None) or get_api_key(provider_name)
 
-    # If a base_url is set, ensure api_key is not passed to litellm
-    # > remove, this can be handled by api_key=None
-    # if base_url:
-    #     if "api_key" in kwargs:
-    #         del kwargs["api_key"]
-    # Only pass API key if no base_url is set and key is not a placeholder
+    # Only pass API key if key is not a placeholder
     if api_key and api_key not in ("None", "NA"):
         kwargs["api_key"] = api_key
 
-    return LiteLLMEmbeddingWrapper(model=model_name, provider=provider, **kwargs)
+    provider_name, model_name, kwargs = _adjust_call_args(
+        provider_name, model_name, kwargs
+    )
+    return LiteLLMEmbeddingWrapper(model=model_name, provider=provider_name, **kwargs)
+
+
+def _parse_chunk(chunk: Any) -> ChatChunk:
+    delta = chunk["choices"][0].get("delta", {})
+    message = chunk["choices"][0].get("model_extra", {}).get("message", {})
+    response_delta = (
+        delta.get("content", "")
+        if isinstance(delta, dict)
+        else getattr(delta, "content", "")
+    ) or (
+        message.get("content", "")
+        if isinstance(message, dict)
+        else getattr(message, "content", "")
+    )
+    reasoning_delta = (
+        delta.get("reasoning_content", "")
+        if isinstance(delta, dict)
+        else getattr(delta, "reasoning_content", "")
+    )
+    return ChatChunk(reasoning_delta=reasoning_delta, response_delta=response_delta)
+
+
+def _adjust_call_args(provider_name: str, model_name: str, kwargs: dict):
+    # for openrouter add app reference
+    if provider_name == "openrouter":
+        kwargs["extra_headers"] = {
+            "HTTP-Referer": "https://agent-zero.ai",
+            "X-Title": "Agent Zero",
+        }
+
+    # remap other to openai for litellm
+    if provider_name == "other":
+        provider_name = "openai"
+
+    return provider_name, model_name, kwargs
 
 
 def get_model(type: ModelType, provider: ModelProvider, name: str, **kwargs: Any):
     provider_name = provider.name.lower()
-    kwargs = _normalize_chat_kwargs(provider, kwargs)
     if type == ModelType.CHAT:
         return _get_litellm_chat(LiteLLMChatWrapper, name, provider_name, **kwargs)
     elif type == ModelType.EMBEDDING:
-        return get_litellm_embedding(name, provider_name, **kwargs)
+        return _get_litellm_embedding(name, provider_name, **kwargs)
     else:
         raise ValueError(f"Unsupported model type: {type}")
 
@@ -491,8 +454,7 @@ def get_model(type: ModelType, provider: ModelProvider, name: str, **kwargs: Any
 def get_chat_model(
     provider: ModelProvider, name: str, **kwargs: Any
 ) -> LiteLLMChatWrapper:
-    provider_name = _get_litellm_provider(provider)
-    kwargs = _normalize_chat_kwargs(provider, kwargs)
+    provider_name = provider.name.lower()
     model = _get_litellm_chat(LiteLLMChatWrapper, name, provider_name, **kwargs)
     return model
 
@@ -501,7 +463,6 @@ def get_browser_model(
     provider: ModelProvider, name: str, **kwargs: Any
 ) -> BrowserCompatibleChatWrapper:
     provider_name = provider.name.lower()
-    kwargs = _normalize_chat_kwargs(provider, kwargs)
     model = _get_litellm_chat(
         BrowserCompatibleChatWrapper, name, provider_name, **kwargs
     )
@@ -512,30 +473,5 @@ def get_embedding_model(
     provider: ModelProvider, name: str, **kwargs: Any
 ) -> LiteLLMEmbeddingWrapper | LocalSentenceTransformerWrapper:
     provider_name = provider.name.lower()
-    kwargs = _normalize_embedding_kwargs(kwargs)
-    model = get_litellm_embedding(name, provider_name, **kwargs)
+    model = _get_litellm_embedding(name, provider_name, **kwargs)
     return model
-
-
-def _normalize_chat_kwargs(provider: ModelProvider, kwargs: Any) -> Any:
-    # this prevents using openai api key for other providers
-    if provider == ModelProvider.OTHER:
-        if "api_key" not in kwargs:
-            kwargs["api_key"] = "None"
-    return kwargs
-
-
-def _normalize_embedding_kwargs(kwargs: Any) -> Any:
-    return kwargs
-
-
-def _get_litellm_provider(provider: ModelProvider) -> str:
-    name = provider.name.lower()
-
-    # exceptions
-    if name == "google":
-        name = "gemini"
-    elif name == "other":
-        name = "openai"
-
-    return name

python/helpers/settings.py

@@ -17,6 +17,7 @@ class Settings(TypedDict):
 
     chat_model_provider: str
     chat_model_name: str
+    chat_model_api_base: str
     chat_model_kwargs: dict[str, str]
     chat_model_ctx_length: int
     chat_model_ctx_history: float
@@ -27,6 +28,7 @@ class Settings(TypedDict):
 
     util_model_provider: str
     util_model_name: str
+    util_model_api_base: str
     util_model_kwargs: dict[str, str]
     util_model_ctx_length: int
     util_model_ctx_input: float
@@ -36,12 +38,14 @@ class Settings(TypedDict):
 
     embed_model_provider: str
     embed_model_name: str
+    embed_model_api_base: str
     embed_model_kwargs: dict[str, str]
     embed_model_rl_requests: int
     embed_model_rl_input: int
 
     browser_model_provider: str
     browser_model_name: str
+    browser_model_api_base: str
     browser_model_vision: bool
     browser_model_kwargs: dict[str, str]
 
@@ -141,6 +145,16 @@ def convert_out(settings: Settings) -> SettingsOutput:
         }
     )
 
+    chat_model_fields.append(
+        {
+            "id": "chat_model_api_base",
+            "title": "Chat model API base URL",
+            "description": "API base URL for main chat model. Leave empty for default. Only relevant for Azure, local and custom (other) providers.",
+            "type": "text",
+            "value": settings["chat_model_api_base"],
+        }
+    )
+
     chat_model_fields.append(
         {
             "id": "chat_model_ctx_length",
@@ -208,8 +222,7 @@ def convert_out(settings: Settings) -> SettingsOutput:
         {
             "id": "chat_model_kwargs",
             "title": "Chat model additional parameters",
-            "description": """Any other parameters supported by the model. Format is KEY=VALUE on individual lines, just like .env file.
-            For OpenAI compatible providers not listed here, select 'other' and specify api_base=https://... and api_key=... as additional parameters.""",
+            "description": "Any other parameters supported by <a href='https://docs.litellm.ai/docs/set_keys' target='_blank'>LiteLLM</a>. Format is KEY=VALUE on individual lines, just like .env file.",
             "type": "textarea",
             "value": _dict_to_env(settings["chat_model_kwargs"]),
         }
@@ -245,6 +258,16 @@ def convert_out(settings: Settings) -> SettingsOutput:
         }
     )
 
+    util_model_fields.append(
+        {
+            "id": "util_model_api_base",
+            "title": "Utility model API base URL",
+            "description": "API base URL for utility model. Leave empty for default. Only relevant for Azure, local and custom (other) providers.",
+            "type": "text",
+            "value": settings["util_model_api_base"],
+        }
+    )
+
     util_model_fields.append(
         {
             "id": "util_model_rl_requests",
@@ -279,8 +302,7 @@ def convert_out(settings: Settings) -> SettingsOutput:
         {
             "id": "util_model_kwargs",
             "title": "Utility model additional parameters",
-           "description": """Any other parameters supported by the model. Format is KEY=VALUE on individual lines, just like .env file.
-            For OpenAI compatible providers not listed here, select 'other' and specify api_base=https://... and api_key=... as additional parameters.""",
+            "description": "Any other parameters supported by <a href='https://docs.litellm.ai/docs/set_keys' target='_blank'>LiteLLM</a>. Format is KEY=VALUE on individual lines, just like .env file.",
             "type": "textarea",
             "value": _dict_to_env(settings["util_model_kwargs"]),
         }
@@ -316,6 +338,16 @@ def convert_out(settings: Settings) -> SettingsOutput:
         }
     )
 
+    embed_model_fields.append(
+        {
+            "id": "embed_model_api_base",
+            "title": "Embedding model API base URL",
+            "description": "API base URL for embedding model. Leave empty for default. Only relevant for Azure, local and custom (other) providers.",
+            "type": "text",
+            "value": settings["embed_model_api_base"],
+        }
+    )
+
     embed_model_fields.append(
         {
             "id": "embed_model_rl_requests",
@@ -340,8 +372,7 @@ def convert_out(settings: Settings) -> SettingsOutput:
         {
             "id": "embed_model_kwargs",
             "title": "Embedding model additional parameters",
-            "description": """Any other parameters supported by the model. Format is KEY=VALUE on individual lines, just like .env file.
-            For OpenAI compatible providers not listed here, select 'other' and specify api_base=https://... and api_key=... as additional parameters.""",
+            "description": "Any other parameters supported by <a href='https://docs.litellm.ai/docs/set_keys' target='_blank'>LiteLLM</a>. Format is KEY=VALUE on individual lines, just like .env file.",
             "type": "textarea",
             "value": _dict_to_env(settings["embed_model_kwargs"]),
         }
@@ -391,7 +422,7 @@ def convert_out(settings: Settings) -> SettingsOutput:
         {
             "id": "browser_model_kwargs",
             "title": "Web Browser model additional parameters",
-            "description": "Any other parameters supported by the model. Format is KEY=VALUE on individual lines, just like .env file.",
+            "description": "Any other parameters supported by <a href='https://docs.litellm.ai/docs/set_keys' target='_blank'>LiteLLM</a>. Format is KEY=VALUE on individual lines, just like .env file.",
             "type": "textarea",
             "value": _dict_to_env(settings["browser_model_kwargs"]),
         }
@@ -472,26 +503,9 @@ def convert_out(settings: Settings) -> SettingsOutput:
 
     # api keys model section
     api_keys_fields: list[SettingsField] = []
-    api_keys_fields.append(_get_api_key_field(settings, "openai", "OpenAI API Key"))
-    api_keys_fields.append(
-        _get_api_key_field(settings, "anthropic", "Anthropic API Key")
-    )
-    api_keys_fields.append(_get_api_key_field(settings, "chutes", "Chutes API Key"))
-    api_keys_fields.append(_get_api_key_field(settings, "deepseek", "DeepSeek API Key"))
-    api_keys_fields.append(_get_api_key_field(settings, "google", "Google API Key"))
-    api_keys_fields.append(_get_api_key_field(settings, "groq", "Groq API Key"))
-    api_keys_fields.append(
-        _get_api_key_field(settings, "huggingface", "HuggingFace API Key")
-    )
-    api_keys_fields.append(
-        _get_api_key_field(settings, "mistralai", "MistralAI API Key")
-    )
-    api_keys_fields.append(
-        _get_api_key_field(settings, "openrouter", "OpenRouter API Key")
-    )
-    api_keys_fields.append(
-        _get_api_key_field(settings, "sambanova", "Sambanova API Key")
-    )
+
+    for provider in ModelProvider:
+        api_keys_fields.append(_get_api_key_field(settings, provider.name.lower(), provider.value))
 
     api_keys_section: SettingsSection = {
         "id": "api_keys",
@@ -965,6 +979,7 @@ def get_default_settings() -> Settings:
         version=_get_version(),
         chat_model_provider=ModelProvider.OPENROUTER.name,
         chat_model_name="openai/gpt-4.1",
+        chat_model_api_base="",
         chat_model_kwargs={"temperature": "0"},
         chat_model_ctx_length=100000,
         chat_model_ctx_history=0.7,
@@ -974,6 +989,7 @@ def get_default_settings() -> Settings:
         chat_model_rl_output=0,
         util_model_provider=ModelProvider.OPENROUTER.name,
         util_model_name="openai/gpt-4.1-nano",
+        util_model_api_base="",
         util_model_ctx_length=100000,
         util_model_ctx_input=0.7,
         util_model_kwargs={"temperature": "0"},
@@ -982,11 +998,13 @@ def get_default_settings() -> Settings:
         util_model_rl_output=0,
         embed_model_provider=ModelProvider.HUGGINGFACE.name,
         embed_model_name="sentence-transformers/all-MiniLM-L6-v2",
+        embed_model_api_base="",
         embed_model_kwargs={},
         embed_model_rl_requests=0,
         embed_model_rl_input=0,
         browser_model_provider=ModelProvider.OPENROUTER.name,
         browser_model_name="openai/gpt-4.1",
+        browser_model_api_base="",
         browser_model_vision=True,
         browser_model_kwargs={"temperature": "0"},
         api_keys={},

python/tools/browser_agent.py

@@ -57,7 +57,13 @@ class State:
                 viewport={"width": 1024, "height": 2048},
                 args=["--headless=new"],
                 # Use a unique user data directory to avoid conflicts
-                user_data_dir=str(Path.home() / ".config" / "browseruse" / "profiles" / f"agent_{self.agent.context.id}"),
+                user_data_dir=str(
+                    Path.home()
+                    / ".config"
+                    / "browseruse"
+                    / "profiles"
+                    / f"agent_{self.agent.context.id}"
+                ),
             )
         )
 
@@ -119,11 +125,10 @@ class State:
             )
             return result
 
-
         model = models.get_browser_model(
             provider=self.agent.config.browser_model.provider,
             name=self.agent.config.browser_model.name,
-            **self.agent.config.browser_model.kwargs,
+            **self.agent._get_model_kwargs(self.agent.config.browser_model),
         )
 
         try:
@@ -140,7 +145,9 @@ class State:
                 # available_file_paths=[],
             )
         except Exception as e:
-            raise Exception(f"Browser agent initialization failed. This might be due to model compatibility issues. Error: {e}") from e
+            raise Exception(
+                f"Browser agent initialization failed. This might be due to model compatibility issues. Error: {e}"
+            ) from e
 
         self.iter_no = get_iter_no(self.agent)
 
@@ -298,13 +305,17 @@ class BrowserAgent(Tool):
                 f"Task reached step limit without completion. Last page: {current_url}. "
                 f"The browser agent may need clearer instructions on when to finish."
             )
-        
+
         # update the log (without screenshot path here, user can click)
         self.log.update(answer=answer_text)
 
         # add screenshot to the answer if we have it
-        if self.log.kvps and "screenshot" in self.log.kvps and self.log.kvps['screenshot']:
-            path = self.log.kvps['screenshot'].split('//', 1)[-1].split('&', 1)[0]
+        if (
+            self.log.kvps
+            and "screenshot" in self.log.kvps
+            and self.log.kvps["screenshot"]
+        ):
+            path = self.log.kvps["screenshot"].split("//", 1)[-1].split("&", 1)[0]
             answer_text += f"\n\nScreenshot: {path}"
 
         # respond (with screenshot path)
@@ -416,7 +427,9 @@ def get_use_agent_log(use_agent: browser_use.Agent | None):
                 if item.success:
                     short_log.append(f"✅ Done")
                 else:
-                    short_log.append(f"❌ Error: {item.error or item.extracted_content or 'Unknown error'}")
+                    short_log.append(
+                        f"❌ Error: {item.error or item.extracted_content or 'Unknown error'}"
+                    )
 
             # progress messages
             else: