autobyteus 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

autobyteus/tools/usage/tool_schema_provider.py

@@ -0,0 +1,51 @@
+# file: autobyteus/autobyteus/tools/usage/tool_schema_provider.py
+"""
+Provider-aware tool schema builder for API tool calls.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Iterable, List, Dict, Optional
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.registry import default_tool_registry
+from autobyteus.tools.usage.formatters.anthropic_json_schema_formatter import AnthropicJsonSchemaFormatter
+from autobyteus.tools.usage.formatters.gemini_json_schema_formatter import GeminiJsonSchemaFormatter
+from autobyteus.tools.usage.formatters.openai_json_schema_formatter import OpenAiJsonSchemaFormatter
+from autobyteus.tools.registry.tool_definition import ToolDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class ToolSchemaProvider:
+    """Builds API tool schemas for a provider."""
+
+    def __init__(self, registry=default_tool_registry):
+        self._registry = registry
+
+    def build_schema(
+        self,
+        tool_names: Iterable[str],
+        provider: Optional[LLMProvider],
+    ) -> List[Dict]:
+        tool_definitions: List[ToolDefinition] = []
+        for name in tool_names:
+            tool_def = self._registry.get_tool_definition(name)
+            if tool_def:
+                tool_definitions.append(tool_def)
+            else:
+                logger.warning("Tool '%s' not found in registry.", name)
+
+        if not tool_definitions:
+            return []
+
+        formatter = self._select_formatter(provider)
+        return [formatter.provide(td) for td in tool_definitions]
+
+    @staticmethod
+    def _select_formatter(provider: Optional[LLMProvider]):
+        if provider == LLMProvider.ANTHROPIC:
+            return AnthropicJsonSchemaFormatter()
+        if provider == LLMProvider.GEMINI:
+            return GeminiJsonSchemaFormatter()
+        return OpenAiJsonSchemaFormatter()

autobyteus/tools/web/__init__.py

@@ -0,0 +1,4 @@
+
+from .read_url_tool import ReadUrl
+
+__all__ = ["ReadUrl"]

autobyteus/tools/web/read_url_tool.py

@@ -0,0 +1,80 @@
+import logging
+import aiohttp
+from typing import Optional, TYPE_CHECKING
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.html_cleaner import clean, CleaningMode
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+class ReadUrl(BaseTool):
+    """
+    Lightweight URL content reader that fetches web page content using aiohttp.
+    Optimized for fast, efficient reading of static content by extracting pure text.
+    """
+    CATEGORY = ToolCategory.WEB
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "read_url"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Reads the content of a specific URL using a lightweight HTTP client. "
+            "Faster and more efficient than using a browser tool for static pages. "
+            "Returns cleaned text content optimized for reading."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        schema = ParameterSchema()
+        schema.add_parameter(ParameterDefinition(
+            name="url",
+            param_type=ParameterType.STRING,
+            description="The URL of the webpage to read.",
+            required=True
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="output_format",
+            param_type=ParameterType.STRING,
+            description="The desired output format: 'text' (default) or 'html'. 'text' returns cleaned text content, 'html' returns cleaned HTML.",
+            required=False,
+            default_value="text",
+            enum_values=["text", "html"]
+        ))
+        return schema
+
+    async def _execute(self, context: 'AgentContext', url: str, output_format: str = "text") -> str:
+        logger.info(f"Executing read_url for agent {context.agent_id} with URL: '{url}'")
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                # aiohttp handles redirects by default (up to 10)
+                async with session.get(url, timeout=30) as response:
+                    if response.status != 200:
+                        error_msg = f"Failed to fetch content from {url}. Status code: {response.status}"
+                        logger.error(error_msg)
+                        return error_msg
+                    
+                    html_content = await response.text()
+            
+            # Use appropriate cleaning mode based on requested format
+            mode = CleaningMode.TEXT_CONTENT_FOCUSED if output_format == "text" else CleaningMode.THOROUGH
+            cleaned_content = clean(html_content, mode=mode)
+            
+            if not cleaned_content.strip():
+                return f"Successfully fetched content from {url}, but the cleaned result was empty."
+                
+            return cleaned_content
+
+        except aiohttp.ClientError as e:
+            logger.error(f"Network error reading URL '{url}': {e}", exc_info=True)
+            return f"Error reading URL '{url}': Network error ({str(e)})"
+        except Exception as e:
+            logger.error(f"Unexpected error reading URL '{url}': {e}", exc_info=True)
+            return f"Error reading URL '{url}': {str(e)}"

autobyteus/utils/diff_utils.py

@@ -0,0 +1,271 @@
+"""
+Unified diff utilities for applying patches to text content.
+"""
+import re
+import logging
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+_HUNK_HEADER_RE = re.compile(r"^@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \+(?P<new_start>\d+)(?:,(?P<new_count>\d+))? @@")
+_GIT_HEADER_PREFIXES = (
+    "diff --git ",
+    "index ",
+    "new file mode ",
+    "deleted file mode ",
+    "old mode ",
+    "new mode ",
+    "similarity index ",
+    "dissimilarity index ",
+    "rename from ",
+    "rename to ",
+    "copy from ",
+    "copy to ",
+    "binary files ",
+)
+
+
+class PatchApplicationError(ValueError):
+    """Raised when a unified diff patch cannot be applied to the target content."""
+
+
+def apply_unified_diff(
+    original_lines: List[str], 
+    patch: str, 
+    fuzz_factor: int = 0, 
+    ignore_whitespace: bool = False
+) -> List[str]:
+    """Applies a unified diff patch to the provided original lines and returns the patched lines.
+    
+    Args:
+        original_lines: List of strings representing the original content lines (with line endings preserved).
+        patch: Unified diff patch string describing the edits to apply.
+        fuzz_factor: Number of lines to search up/down if exact line number match fails.
+        ignore_whitespace: If True, ignores leading/trailing whitespace when matching context.
+        
+    Returns:
+        List of strings representing the patched content lines.
+        
+    Raises:
+        PatchApplicationError: If the patch content cannot be applied cleanly.
+    """
+    if not patch or not patch.strip():
+        raise PatchApplicationError("Patch content is empty; nothing to apply.")
+
+    patched_lines: List[str] = []
+    orig_idx = 0
+    patch_lines = patch.splitlines(keepends=True)
+    line_idx = 0
+
+    def lines_match(l1: str, l2: str, *, allow_eof_newline_mismatch: bool = False) -> bool:
+        if ignore_whitespace:
+            return l1.strip() == l2.strip()
+        if l1 == l2:
+            return True
+        if allow_eof_newline_mismatch:
+            return l1.rstrip('\n') == l2.rstrip('\n')
+        return False
+
+    while line_idx < len(patch_lines):
+        line = patch_lines[line_idx]
+
+        if line.startswith('---') or line.startswith('+++'):
+            logger.debug("apply_unified_diff: skipping diff header line '%s'.", line.strip())
+            line_idx += 1
+            continue
+        stripped_line = line.lstrip().lower()
+        if any(stripped_line.startswith(prefix) for prefix in _GIT_HEADER_PREFIXES):
+            logger.debug("apply_unified_diff: skipping git diff header line '%s'.", line.strip())
+            line_idx += 1
+            continue
+
+        if not line.startswith('@@'):
+            stripped = line.strip()
+            if stripped == '':
+                # Handle empty lines between hunks or at start as noise, but
+                # legacy behavior might have been to append them?
+                # The previous loop skipped them if start of file (implicit in while loop start?), 
+                # but inside the hunk loop it appended them.
+                # Here we are searching for hunk headers.
+                line_idx += 1
+                continue
+            raise PatchApplicationError(f"Unexpected content outside of hunk header: '{stripped}'.")
+
+        match = _HUNK_HEADER_RE.match(line)
+        if not match:
+            raise PatchApplicationError(f"Malformed hunk header: '{line.strip()}'.")
+
+        old_start = int(match.group('old_start'))
+        old_count = int(match.group('old_count') or '1')
+        new_start = int(match.group('new_start'))
+        new_count = int(match.group('new_count') or '1')
+        logger.debug("apply_unified_diff: processing hunk old_start=%s old_count=%s new_start=%s new_count=%s.",
+                     old_start, old_count, new_start, new_count)
+        
+        line_idx += 1 # Move past header
+        
+        # Capture the hunk body
+        hunk_body = []
+        while line_idx < len(patch_lines):
+            h_line = patch_lines[line_idx]
+            if h_line.startswith('@@'):
+                break
+            hunk_body.append(h_line)
+            line_idx += 1
+            
+        # Extract expected original content from hunk
+        # We process the hunk body to confirm what we expect to see in original_lines
+        refined_expected_orig = []
+        h_i = 0
+        while h_i < len(hunk_body):
+            h_line = hunk_body[h_i]
+            if h_line.startswith(' ') or h_line.startswith('-'):
+                content = h_line[1:]
+                # Check next line for '\ No newline...' to handle EOF correctly during match
+                if h_i + 1 < len(hunk_body) and hunk_body[h_i+1].startswith('\\ No newline'):
+                    content = content.rstrip('\n')
+                elif h_i + 1 == len(hunk_body) and not content.endswith('\n'):
+                     # Last line of patch might legitimately not have newline? 
+                     # Usually lines have newlines. If it's a file without newline at end, diff shows \ No newline.
+                     pass
+                refined_expected_orig.append(content)
+            elif h_line.startswith('+'):
+                pass
+            elif h_line.startswith('\\'):
+                pass 
+            elif h_line.strip() == '':
+                 # Treat bare empty line as non-match content (noise/insert)?
+                 # Previous code appended it to output but didn't check against input.
+                 # So we do NOT add to refined_expected_orig.
+                 pass
+            else:
+                 raise PatchApplicationError(f"Unsupported patch line: '{h_line.strip()}'.")
+            h_i += 1
+
+        expected_count = len(refined_expected_orig)
+
+        # Fuzzy Search for Match
+        # Ideally target is old_start - 1 (converting 1-based old_start to 0-based index)
+        target_idx_base = old_start - 1 if old_start > 0 else 0
+        
+        found_idx = -1
+        
+        # Generate search offsets: 0, -1, 1, -2, 2, ...
+        offsets = [0]
+        for f in range(1, fuzz_factor + 1):
+            offsets.append(-f)
+            offsets.append(f)
+            
+        for offset in offsets:
+            candidate_idx = target_idx_base + offset
+            
+            # Constraints:
+            # 1. Must proceed forward from where we left off (orig_idx)
+            # 2. Must not go beyond EOF (handled by slicing)
+            if candidate_idx < orig_idx:
+                continue 
+            
+            # Check if this candidate location matches expected_orig
+            # We need to verify that original_lines[candidate_idx : candidate_idx + expected_count] matches refined_expected_orig
+            
+            if candidate_idx + expected_count > len(original_lines):
+                # Ensure we don't go out of bounds (though partial match at EOF might be a thing? No, hunk must match fully)
+                continue
+
+            match_success = True
+            for k in range(expected_count):
+                # Note: lines_match handles whitespace if needed.
+                is_eof_line = (
+                    candidate_idx + expected_count == len(original_lines)
+                    and k == expected_count - 1
+                )
+                if not lines_match(
+                    original_lines[candidate_idx + k],
+                    refined_expected_orig[k],
+                    allow_eof_newline_mismatch=is_eof_line,
+                ):
+                    match_success = False
+                    break
+            
+            if match_success:
+                found_idx = candidate_idx
+                break
+                
+        if found_idx == -1:
+             raise PatchApplicationError(f"Could not find context for hunk starting at {old_start} (fuzz={fuzz_factor}).")
+             
+        # Apply changes
+        
+        # 1. Copy lines from orig_idx to found_idx (these are the lines BEFORE the hunk that we skipped over/accepted)
+        patched_lines.extend(original_lines[orig_idx:found_idx])
+        
+        # 2. Process hunk body to generate new lines
+        h_i = 0
+        while h_i < len(hunk_body):
+            h_line = hunk_body[h_i]
+            if h_line.startswith(' ') or h_line.startswith('-'):
+                # Valid context or removal - we skip them in output (they are either preserved via context or removed)
+                # If context (' '), we should actually append the ORIGINAL line to allow for fuzziness?
+                # Standard patch behavior: if fuzz matches, we output the *hunk's* version of the line? 
+                # OR we output the *original* file's version?
+                # `patch` man page says: "patch takes the context from the diff file"
+                # Wait, if we fuzzy matched, likely we want to keep what was in the file unless the patch explicitly changes it.
+                # However, typically ' ' lines are just copied.
+                # If we use `patched_lines.append(original_lines[found_idx + handled_count])`, that preserves the file's indentation/whitespace.
+                # If we use `h_line[1:]`, we enforce the patch's indentation.
+                # Requirement: "Ignore Whitespace... Allow context comparisons to ignore...".
+                # If the patch "autocorrects" indentation in context lines, we probably want to KEEP the file's original indentation 
+                # for context lines, so we don't accidentally "fix" them if we aren't touching them.
+                # Unified diff: ' ' means "unchanged". So we should emit the *original* line.
+                
+                if h_line.startswith(' '):
+                    # Find which original line this corresponds to.
+                    # We are iterating h_i through hunk_body.
+                    # We need to track our position in the matched original block.
+                    # Let's track `current_match_offset`
+                    pass 
+            elif h_line.startswith('+'):
+                pass
+            h_i += 1
+            
+        # Let's redo step 2 cleanly to handle the ' ' vs '-' vs '+' and the '\ No newline' logic.
+        
+        matched_orig_offset = 0 # Offset into the matched block of original_lines [found_idx : found_idx+expected_count]
+        
+        h_i = 0
+        while h_i < len(hunk_body):
+            h_line = hunk_body[h_i]
+            
+            if h_line.startswith(' '):
+                # Context line: preserve original content from file
+                if found_idx + matched_orig_offset < len(original_lines):
+                    patched_lines.append(original_lines[found_idx + matched_orig_offset])
+                matched_orig_offset += 1
+                
+            elif h_line.startswith('-'):
+                # Removal: skip original content
+                matched_orig_offset += 1
+                
+            elif h_line.startswith('+'):
+                # Addition: add content from patch
+                content = h_line[1:]
+                if h_i + 1 < len(hunk_body) and hunk_body[h_i+1].startswith('\\ No newline'):
+                    content = content.rstrip('\n')
+                patched_lines.append(content)
+                
+            elif h_line.strip() == '':
+                 # "Empty" line in patch. Legacy behavior: append to output. 
+                 # Does not consume original.
+                 patched_lines.append(h_line)
+                 
+            elif h_line.startswith('\\'):
+                 # No newline marker, handled by lookahead in + case. 
+                 # For - and space, we used original lines so their newline status is preserved automatically!
+                 pass
+                 
+            h_i += 1
+            
+        orig_idx = found_idx + expected_count
+
+    patched_lines.extend(original_lines[orig_idx:])
+    return patched_lines

autobyteus/utils/download_utils.py

@@ -0,0 +1,109 @@
+import logging
+import aiohttp
+import base64
+import shutil
+import os
+import ssl
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+SSL_VERIFY_ENV_VAR = "AUTOBYTEUS_DOWNLOAD_VERIFY_SSL"
+SSL_CERT_FILE_ENV_VAR = "AUTOBYTEUS_DOWNLOAD_SSL_CERT_FILE"
+
+
+def _resolve_ssl_param() -> bool | ssl.SSLContext:
+    """
+    Resolve SSL verification behavior for downloads.
+
+    - If AUTOBYTEUS_DOWNLOAD_SSL_CERT_FILE is set, use it as CA file.
+    - Else if AUTOBYTEUS_DOWNLOAD_VERIFY_SSL is truthy, verify using system CAs.
+    - Else (default), disable verification to allow self-signed certs.
+    """
+    cert_path = os.getenv(SSL_CERT_FILE_ENV_VAR)
+    if cert_path:
+        cert_file = Path(cert_path)
+        if not cert_file.is_file():
+            raise IOError(f"SSL cert file not found: {cert_file}")
+        return ssl.create_default_context(cafile=str(cert_file))
+
+    verify_env = os.getenv(SSL_VERIFY_ENV_VAR)
+    if verify_env and verify_env.strip().lower() in {"1", "true", "yes", "on"}:
+        return True
+    return False
+
+
+async def download_file_from_url(url: str, file_path: Path) -> None:
+    """
+    Asynchronously downloads a file from a URL, decodes a data URI, or copies a local file 
+    to a specified file path.
+    
+    Features:
+    - Supports http/https URLs, data: URIs (base64), and local file paths.
+    - Creates parent directories if they don't exist.
+    - Uses streaming for HTTP URLs to handle large files efficiently.
+    - Guarantees cleanup of partial files on failure.
+    
+    Args:
+        url: The source URL, data URI, or local path.
+        file_path: The specific local path (including filename) to save to.
+        
+    Raises:
+        IOError: If download, decoding, or copying fails.
+    """
+    # Ensure parent directory exists
+    try:
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        logger.error(f"Failed to create directory structure for {file_path}: {e}")
+        raise IOError(f"Filesystem error: {e}")
+
+    try:
+        if url.startswith("data:"):
+            # Handle Data URI
+            try:
+                header, encoded = url.split(",", 1)
+                data = base64.b64decode(encoded)
+                with open(file_path, "wb") as f:
+                    f.write(data)
+                logger.info(f"Successfully decoded and saved data URI to: {file_path}")
+                return
+            except Exception as e:
+                logger.error(f"Failed to decode data URI: {e}")
+                raise IOError(f"Invalid data URI format: {e}")
+
+        if os.path.exists(url) and os.path.isfile(url):
+            # Handle Local File Path (Copy)
+            try:
+                shutil.copy(url, file_path)
+                logger.info(f"Successfully copied local file from {url} to {file_path}")
+                return
+            except Exception as e:
+                logger.error(f"Failed to copy local file from {url} to {file_path}: {e}")
+                raise IOError(f"File copy error: {e}")
+
+        # Handle HTTP URL
+        ssl_param = _resolve_ssl_param()
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, ssl=ssl_param) as response:
+                if response.status != 200:
+                    raise IOError(f"Failed to download from {url}: HTTP {response.status}")
+                
+                # Open file for writing binary
+                with open(file_path, "wb") as f:
+                    # Iterate over chunks to avoid loading large files into memory
+                    async for chunk in response.content.iter_chunked(8192):
+                        f.write(chunk)
+                        
+        logger.info(f"Successfully downloaded file to: {file_path}")
+
+    except Exception as e:
+        logger.error(f"Failed to process media from {url} to {file_path}: {e}")
+        # Cleanup: Delete the partial/empty file if it was created
+        if file_path.exists():
+            try:
+                file_path.unlink()
+                logger.debug(f"Cleaned up partial file: {file_path}")
+            except OSError as cleanup_error:
+                logger.warning(f"Failed to clean up partial file {file_path}: {cleanup_error}")
+        raise

autobyteus/utils/file_utils.py

@@ -2,8 +2,11 @@
 
 import os
 import platform
+import tempfile
+from pathlib import Path
+from typing import Union
 
-def get_default_download_folder():
+def get_default_download_folder() -> str:
     system = platform.system()
     if system == "Windows":
         return os.path.join(os.path.expanduser("~"), "Downloads")
@@ -12,4 +15,56 @@ def get_default_download_folder():
     elif system == "Linux":
         return os.path.join(os.path.expanduser("~"), "Downloads")
     else:
-        return os.path.join(os.path.expanduser("~"), "Downloads")  # Fallback
+        return os.path.join(os.path.expanduser("~"), "Downloads")  # Fallback
+
+def resolve_safe_path(user_path: str, workspace_root: Union[str, Path]) -> Path:
+    """
+    Resolves a file path and ensures it is contained within allowed safe directories.
+    
+    Allowed directories:
+    1. The Agent's Workspace (workspace_root)
+    2. The User's Downloads directory
+    3. The System Temporary directory
+    
+    Args:
+        user_path: The relative or absolute path provided by the user/tool.
+        workspace_root: The root directory of the agent's workspace.
+        
+    Returns:
+        The resolved absolute Path object.
+        
+    Raises:
+        ValueError: If the path is outside the allowed directories.
+    """
+    workspace = Path(workspace_root).resolve()
+    downloads = Path(get_default_download_folder()).resolve()
+    temp_dir = Path(tempfile.gettempdir()).resolve()
+    
+    path_obj = Path(user_path)
+    
+    # If absolute, check directly. If relative, resolve against workspace.
+    if path_obj.is_absolute():
+        target = path_obj.resolve()
+    else:
+        target = (workspace / path_obj).resolve()
+    
+    # Allowed roots list
+    allowed_roots = [workspace, downloads, temp_dir]
+    
+    is_safe = False
+    for root in allowed_roots:
+        # Check if target is equal to or a subpath of root
+        try:
+            target.relative_to(root)
+            is_safe = True
+            break
+        except ValueError:
+            continue
+            
+    if not is_safe:
+        raise ValueError(
+            f"Security Violation: Path '{user_path}' is not within allowed directories "
+            f"(Workspace: {workspace}, Downloads: {downloads}, or Temp: {temp_dir})."
+        )
+        
+    return target

autobyteus/utils/gemini_helper.py

@@ -0,0 +1,64 @@
+import os
+import logging
+from dataclasses import dataclass
+from google import genai
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class GeminiRuntimeInfo:
+    runtime: str  # "vertex" or "api_key"
+    project: str | None
+    location: str | None
+
+def initialize_gemini_client_with_runtime() -> tuple[genai.Client, GeminiRuntimeInfo]:
+    """
+    Initializes the Google GenAI Client based on available environment variables.
+    Supports Vertex AI (GCP), Vertex AI Express (API Key), and AI Studio (API Key) modes.
+
+    Priority:
+    1. Vertex AI Express (requires VERTEX_AI_API_KEY)
+    2. Vertex AI (requires VERTEX_AI_PROJECT and VERTEX_AI_LOCATION)
+    3. AI Studio (requires GEMINI_API_KEY)
+
+    Returns:
+        (client, runtime_info)
+
+    Raises:
+        ValueError: If neither configuration set is found.
+    """
+    # 1. Try Vertex AI Express Configuration (API Key)
+    vertex_api_key = os.environ.get("VERTEX_AI_API_KEY")
+    if vertex_api_key:
+        logger.info("Initializing Gemini Client in Vertex AI Express mode (API key).")
+        client = genai.Client(vertexai=True, api_key=vertex_api_key)
+        return client, GeminiRuntimeInfo(runtime="vertex", project=None, location=None)
+
+    # 2. Try Vertex AI Configuration (Project/Location + ADC)
+    project = os.environ.get("VERTEX_AI_PROJECT")
+    location = os.environ.get("VERTEX_AI_LOCATION")
+
+    if project and location:
+        logger.info(
+            f"Initializing Gemini Client in Vertex AI mode (Project: {project}, Location: {location})"
+        )
+        client = genai.Client(vertexai=True, project=project, location=location)
+        return client, GeminiRuntimeInfo(runtime="vertex", project=project, location=location)
+
+    # 3. Try AI Studio Configuration (API Key)
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if api_key:
+        logger.info("Initializing Gemini Client in AI Studio mode.")
+        client = genai.Client(api_key=api_key)
+        return client, GeminiRuntimeInfo(runtime="api_key", project=None, location=None)
+
+    # 3. Fallback / Error
+    error_msg = (
+        "Failed to initialize Gemini Client: Missing configuration. "
+        "Please set 'VERTEX_AI_API_KEY' for Vertex AI Express mode, OR set both "
+        "'VERTEX_AI_PROJECT' and 'VERTEX_AI_LOCATION' for Vertex AI mode, OR set "
+        "'GEMINI_API_KEY' for AI Studio mode."
+    )
+    logger.error(error_msg)
+    raise ValueError(error_msg)