agentpool 2.1.9__py3-none-any.whl → 2.2.3__py3-none-any.whl

agentpool_server/opencode_server/routes/config_routes.py

@@ -0,0 +1,241 @@
+"""Config and provider routes."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from datetime import timedelta
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter
+
+from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.models import (
+    Config,
+    Mode,
+    Model,
+    ModelCost,
+    ModelLimit,
+    Provider,
+    ProviderListResponse,
+    ProvidersResponse,
+)
+
+
+if TYPE_CHECKING:
+    from tokonomics.model_discovery.model_info import ModelInfo as TokoModelInfo
+
+
+router = APIRouter(tags=["config"])
+
+# Provider display names and environment variable mappings
+PROVIDER_INFO: dict[str, tuple[str, list[str]]] = {
+    "anthropic": ("Anthropic", ["ANTHROPIC_API_KEY"]),
+    "openai": ("OpenAI", ["OPENAI_API_KEY"]),
+    "google": ("Google", ["GOOGLE_API_KEY", "GEMINI_API_KEY"]),
+    "mistral": ("Mistral", ["MISTRAL_API_KEY"]),
+    "groq": ("Groq", ["GROQ_API_KEY"]),
+    "deepseek": ("DeepSeek", ["DEEPSEEK_API_KEY"]),
+    "xai": ("xAI", ["XAI_API_KEY"]),
+    "together": ("Together AI", ["TOGETHER_API_KEY"]),
+    "perplexity": ("Perplexity", ["PERPLEXITY_API_KEY"]),
+    "cohere": ("Cohere", ["COHERE_API_KEY"]),
+    "fireworks": ("Fireworks AI", ["FIREWORKS_API_KEY"]),
+    "openrouter": ("OpenRouter", ["OPENROUTER_API_KEY"]),
+    "bedrock": ("AWS Bedrock", ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"]),
+    "azure": ("Azure OpenAI", ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"]),
+    "vertex": ("Google Vertex AI", ["GOOGLE_APPLICATION_CREDENTIALS"]),
+}
+
+
+def _convert_toko_model_to_opencode(model: TokoModelInfo) -> Model:
+    """Convert a tokonomics ModelInfo to an OpenCode Model."""
+    # Convert pricing (tokonomics uses per-token, OpenCode uses per-million-token)
+    input_cost = 0.0
+    output_cost = 0.0
+    cache_read = None
+    cache_write = None
+
+    if model.pricing:
+        # tokonomics pricing is per-token, convert to per-million-tokens
+        if model.pricing.prompt is not None:
+            input_cost = model.pricing.prompt * 1_000_000
+        if model.pricing.completion is not None:
+            output_cost = model.pricing.completion * 1_000_000
+        if model.pricing.input_cache_read is not None:
+            cache_read = model.pricing.input_cache_read * 1_000_000
+        if model.pricing.input_cache_write is not None:
+            cache_write = model.pricing.input_cache_write * 1_000_000
+
+    cost = ModelCost(
+        input=input_cost,
+        output=output_cost,
+        cache_read=cache_read,
+        cache_write=cache_write,
+    )
+
+    # Convert limits
+    context = float(model.context_window) if model.context_window else 128000.0
+    output = float(model.max_output_tokens) if model.max_output_tokens else 4096.0
+    limit = ModelLimit(context=context, output=output)
+
+    # Determine capabilities from modalities and metadata
+    has_vision = "image" in model.input_modalities
+    has_reasoning = "reasoning" in model.output_modalities or "thinking" in model.name.lower()
+
+    # Format release date if available
+    release_date = ""
+    if model.created_at:
+        release_date = model.created_at.strftime("%Y-%m-%d")
+
+    return Model(
+        id=model.id,
+        name=model.name,
+        attachment=has_vision,
+        cost=cost,
+        limit=limit,
+        reasoning=has_reasoning,
+        release_date=release_date,
+        temperature=True,
+        tool_call=True,  # Assume most models support tool calling
+    )
+
+
+def _group_models_by_provider(
+    models: list[TokoModelInfo],
+) -> dict[str, list[TokoModelInfo]]:
+    """Group models by their provider."""
+    grouped: dict[str, list[TokoModelInfo]] = defaultdict(list)
+    for model in models:
+        # Skip embedding models - OpenCode is for chat/agent models
+        if model.is_embedding:
+            continue
+        grouped[model.provider].append(model)
+    return grouped
+
+
+def _build_providers(models: list[TokoModelInfo]) -> list[Provider]:
+    """Build Provider list from tokonomics models."""
+    grouped = _group_models_by_provider(models)
+    providers: list[Provider] = []
+
+    for provider_id, provider_models in sorted(grouped.items()):
+        # Get provider display info
+        display_name, env_vars = PROVIDER_INFO.get(
+            provider_id, (provider_id.title(), [f"{provider_id.upper()}_API_KEY"])
+        )
+
+        # Convert models to OpenCode format
+        models_dict: dict[str, Model] = {}
+        for toko_model in provider_models:
+            opencode_model = _convert_toko_model_to_opencode(toko_model)
+            models_dict[toko_model.id] = opencode_model
+
+        provider = Provider(
+            id=provider_id,
+            name=display_name,
+            env=env_vars,
+            models=models_dict,
+        )
+        providers.append(provider)
+
+    return providers
+
+
+async def _get_available_models() -> list[TokoModelInfo]:
+    """Fetch available models using tokonomics."""
+    from tokonomics.model_discovery import get_all_models
+
+    max_age = timedelta(days=7)  # Cache for a week
+    return await get_all_models(max_age=max_age)
+
+
+@router.get("/config")
+async def get_config(state: StateDep) -> Config:
+    """Get server configuration."""
+    _ = state  # unused for now
+    return Config()
+
+
+def _get_dummy_providers() -> list[Provider]:
+    """Return a single dummy provider for testing."""
+    dummy_model = Model(
+        id="gpt-4o",
+        name="GPT-4o",
+        attachment=True,
+        cost=ModelCost(input=5.0, output=15.0),
+        limit=ModelLimit(context=128000.0, output=4096.0),
+        reasoning=False,
+        release_date="2024-05-13",
+        temperature=True,
+        tool_call=True,
+    )
+    dummy_provider = Provider(
+        id="openai",
+        name="OpenAI",
+        env=["OPENAI_API_KEY"],
+        models={"gpt-4o": dummy_model},
+    )
+    return [dummy_provider]
+
+
+@router.get("/config/providers")
+async def get_providers(state: StateDep) -> ProvidersResponse:
+    """Get available providers and models from agent."""
+    providers: list[Provider] = []
+
+    # Try to get models from the agent
+    try:
+        toko_models = await state.agent.get_available_models()
+        if toko_models:
+            providers = _build_providers(toko_models)
+    except Exception:  # noqa: BLE001
+        pass  # Fall through to dummy providers
+
+    # Fall back to dummy providers if no models available
+    if not providers:
+        providers = _get_dummy_providers()
+
+    return ProvidersResponse(providers=providers)
+
+
+@router.get("/provider")
+async def list_providers(state: StateDep) -> ProviderListResponse:
+    """List all providers."""
+    import os
+
+    providers: list[Provider] = []
+
+    # Try to get models from the agent
+    try:
+        toko_models = await state.agent.get_available_models()
+        if toko_models:
+            providers = _build_providers(toko_models)
+    except Exception:  # noqa: BLE001
+        pass  # Fall through to dummy providers
+
+    # Fall back to dummy providers if no models available
+    if not providers:
+        providers = _get_dummy_providers()
+
+    # Determine which providers are "connected" based on env vars
+    connected = [
+        provider.id for provider in providers if any(os.environ.get(env) for env in provider.env)
+    ]
+
+    return ProviderListResponse(
+        all=providers,
+        default={},
+        connected=connected,
+    )
+
+
+@router.get("/mode")
+async def list_modes(state: StateDep) -> list[Mode]:
+    """List available modes."""
+    _ = state  # unused for now
+    return [
+        Mode(
+            name="default",
+            tools={},
+        )
+    ]

agentpool_server/opencode_server/routes/file_routes.py

@@ -0,0 +1,392 @@
+"""File operation routes."""
+
+from __future__ import annotations
+
+import fnmatch
+from pathlib import Path
+import re
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter, HTTPException, Query
+
+from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.models import (  # noqa: TC001
+    FileContent,
+    FileNode,
+    FindMatch,
+    Symbol,
+)
+from agentpool_server.opencode_server.models.file import SubmatchInfo
+
+
+if TYPE_CHECKING:
+    from fsspec.asyn import AsyncFileSystem
+
+
+router = APIRouter(tags=["file"])
+
+
+# Directories to skip when searching
+SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".tox", "dist", "build"}
+
+# Sensitive files that should never be exposed via the API
+BLOCKED_FILES = {".env", ".env.local", ".env.production", ".env.development", ".env.test"}
+
+
+def _validate_path(root: Path, user_path: str) -> Path:
+    """Validate and resolve a user-provided path, ensuring it stays within root.
+
+    Args:
+        root: The root directory (working_dir) that paths must stay within.
+        user_path: The user-provided relative path.
+
+    Returns:
+        The resolved absolute path that is guaranteed to be within root.
+
+    Raises:
+        HTTPException: If the path escapes root or is blocked.
+    """
+    # Resolve the root to handle any symlinks in the root itself
+    resolved_root = root.resolve()
+
+    # Join and resolve the full path (this handles ../, symlinks, etc.)
+    target = (root / user_path).resolve()
+
+    # Check that the resolved path is within the resolved root
+    try:
+        target.relative_to(resolved_root)
+    except ValueError:
+        raise HTTPException(
+            status_code=403,
+            detail="Access denied: path escapes project directory",
+        ) from None
+
+    # Check for blocked files
+    if target.name in BLOCKED_FILES:
+        raise HTTPException(
+            status_code=403,
+            detail=f"Access denied: {target.name} files are protected",
+        )
+
+    return target
+
+
+def _validate_path_str(root: str, user_path: str) -> str:
+    """Validate path for fsspec filesystem (string-based).
+
+    Args:
+        root: The root directory path as string.
+        user_path: The user-provided relative path.
+
+    Returns:
+        The validated absolute path as string.
+
+    Raises:
+        HTTPException: If the path escapes root or is blocked.
+    """
+    validated = _validate_path(Path(root), user_path)
+    return str(validated)
+
+
+def _get_fs(state: StateDep) -> tuple[AsyncFileSystem, str] | None:
+    """Get the fsspec filesystem from the agent's environment if available.
+
+    Returns:
+        Tuple of (filesystem, base_path) or None if not available.
+        base_path is the root directory to use for operations.
+    """
+    try:
+        fs = state.agent.env.get_fs()
+        # Use env's cwd if set, otherwise use state.working_dir
+        env = state.agent.env
+        base_path = env.cwd or state.working_dir
+    except NotImplementedError:
+        return None
+    else:
+        return (fs, base_path)
+
+
+@router.get("/file")
+async def list_files(state: StateDep, path: str = Query(default="")) -> list[FileNode]:
+    """List files in a directory."""
+    working_path = Path(state.working_dir)
+
+    # Validate path if provided (empty path means root, which is always valid)
+    target_p = _validate_path(working_path, path) if path else working_path.resolve()
+
+    fs_info = _get_fs(state)
+
+    if fs_info is not None:
+        fs, _base_path = fs_info
+        # Use fsspec filesystem with validated path
+        target = str(target_p)
+        try:
+            if not await fs._isdir(target):
+                raise HTTPException(status_code=404, detail="Directory not found")
+
+            entries = await fs._ls(target, detail=True)
+            nodes = []
+            resolved_root = working_path.resolve()
+            for entry in entries:
+                full_name = entry.get("name", "")
+                name = full_name.split("/")[-1]
+                if not name:
+                    continue
+                # Skip blocked files in directory listings
+                if name in BLOCKED_FILES:
+                    continue
+                node_type = "directory" if entry.get("type") == "directory" else "file"
+                size = entry.get("size") if node_type == "file" else None
+                # Build relative path from resolved root
+                entry_path = Path(full_name)
+                try:
+                    rel_path = str(entry_path.relative_to(resolved_root))
+                except ValueError:
+                    rel_path = name
+                nodes.append(FileNode(name=name, path=rel_path or name, type=node_type, size=size))
+            return sorted(nodes, key=lambda n: (n.type != "directory", n.name.lower()))
+        except FileNotFoundError as err:
+            raise HTTPException(status_code=404, detail="Directory not found") from err
+    else:
+        # Fallback to local Path operations
+        if not target_p.is_dir():
+            raise HTTPException(status_code=404, detail="Directory not found")
+
+        nodes = []
+        resolved_root = working_path.resolve()
+        for entry in target_p.iterdir():
+            # Skip blocked files in directory listings
+            if entry.name in BLOCKED_FILES:
+                continue
+            node_type = "directory" if entry.is_dir() else "file"
+            size = entry.stat().st_size if entry.is_file() else None
+            rel_path = str(entry.relative_to(resolved_root))
+            nodes.append(FileNode(name=entry.name, path=rel_path, type=node_type, size=size))
+
+        return sorted(nodes, key=lambda n: (n.type != "directory", n.name.lower()))
+
+
+@router.get("/file/content")
+async def read_file(state: StateDep, path: str = Query()) -> FileContent:
+    """Read a file's content."""
+    working_path = Path(state.working_dir)
+
+    # Validate path - this checks for traversal, symlink escapes, and blocked files
+    target = _validate_path(working_path, path)
+
+    fs_info = _get_fs(state)
+
+    if fs_info is not None:
+        fs, _base_path = fs_info
+        # Use fsspec filesystem with validated path
+        full_path = str(target)
+        try:
+            if not await fs._isfile(full_path):
+                raise HTTPException(status_code=404, detail="File not found")
+            content = await fs._cat_file(full_path)
+            if isinstance(content, bytes):
+                content = content.decode("utf-8")
+            return FileContent(path=path, content=content)
+        except FileNotFoundError as err:
+            raise HTTPException(status_code=404, detail="File not found") from err
+        except UnicodeDecodeError as err:
+            raise HTTPException(status_code=400, detail="Cannot read binary file") from err
+    else:
+        # Fallback to local Path operations (target already validated)
+        if not target.is_file():
+            raise HTTPException(status_code=404, detail="File not found")
+
+        try:
+            content = target.read_text(encoding="utf-8")
+            return FileContent(path=path, content=content)
+        except UnicodeDecodeError as err:
+            raise HTTPException(status_code=400, detail="Cannot read binary file") from err
+
+
+@router.get("/file/status")
+async def get_file_status(state: StateDep) -> list[dict[str, Any]]:
+    """Get status of tracked files.
+
+    Returns empty list - file tracking not yet implemented.
+    """
+    _ = state
+    return []
+
+
+@router.get("/find")
+async def find_text(state: StateDep, pattern: str = Query()) -> list[FindMatch]:  # noqa: PLR0915
+    """Search for text pattern in files using regex."""
+    try:
+        regex = re.compile(pattern)
+    except re.error as e:
+        raise HTTPException(status_code=400, detail=f"Invalid regex: {e}") from e
+
+    matches: list[FindMatch] = []
+    max_matches = 100
+    fs_info = _get_fs(state)
+
+    if fs_info is not None:
+        fs, base_path = fs_info
+
+        # Use fsspec filesystem with walk
+        async def search_fs() -> None:
+            try:
+                # Use find to get all files recursively (limit depth to avoid scanning huge trees)
+                all_files = await fs._find(base_path, maxdepth=10, withdirs=False)
+                for file_path in all_files:
+                    if len(matches) >= max_matches:
+                        return
+
+                    # Skip directories we don't want to search
+                    parts = file_path.split("/")
+                    if any(part in SKIP_DIRS for part in parts):
+                        continue
+
+                    # Get relative path
+                    if file_path.startswith(base_path):
+                        rel_path = file_path[len(base_path) :].lstrip("/")
+                    else:
+                        rel_path = file_path
+
+                    try:
+                        content = await fs._cat_file(file_path)
+                        if isinstance(content, bytes):
+                            content = content.decode("utf-8")
+
+                        for line_num, line in enumerate(content.splitlines(), 1):
+                            for match in regex.finditer(line):
+                                submatches = [
+                                    SubmatchInfo.create(match.group(), match.start(), match.end())
+                                ]
+                                matches.append(
+                                    FindMatch.create(
+                                        path=rel_path,
+                                        lines=line.strip(),
+                                        line_number=line_num,
+                                        absolute_offset=match.start(),
+                                        submatches=submatches,
+                                    )
+                                )
+                                if len(matches) >= max_matches:
+                                    return
+                    except (UnicodeDecodeError, PermissionError, OSError):
+                        continue
+            except Exception:  # noqa: BLE001
+                pass
+
+        await search_fs()
+    else:
+        # Fallback to local Path operations
+        working_path = Path(state.working_dir)
+
+        def search_dir(dir_path: Path) -> None:
+            if len(matches) >= max_matches:
+                return
+
+            for entry in dir_path.iterdir():
+                if len(matches) >= max_matches:
+                    return
+
+                if entry.is_dir():
+                    if entry.name not in SKIP_DIRS:
+                        search_dir(entry)
+                elif entry.is_file():
+                    try:
+                        content = entry.read_text(encoding="utf-8")
+                        for line_num, line in enumerate(content.splitlines(), 1):
+                            for match in regex.finditer(line):
+                                rel_path = str(entry.relative_to(working_path))
+                                submatches = [
+                                    SubmatchInfo.create(match.group(), match.start(), match.end())
+                                ]
+                                matches.append(
+                                    FindMatch.create(
+                                        path=rel_path,
+                                        lines=line.strip(),
+                                        line_number=line_num,
+                                        absolute_offset=match.start(),
+                                        submatches=submatches,
+                                    )
+                                )
+                                if len(matches) >= max_matches:
+                                    return
+                    except (UnicodeDecodeError, PermissionError, OSError):
+                        continue
+
+        search_dir(working_path)
+
+    return matches
+
+
+@router.get("/find/file")
+async def find_files(
+    state: StateDep,
+    query: str = Query(),
+    dirs: str = Query(default="false"),
+) -> list[str]:
+    """Find files by name pattern (glob-style matching)."""
+    include_dirs = dirs.lower() == "true"
+    results: list[str] = []
+    max_results = 100
+    fs_info = _get_fs(state)
+
+    if fs_info is not None:
+        fs, base_path = fs_info
+        # Use fsspec filesystem
+        try:
+            # Get all entries recursively (limit depth to avoid scanning huge trees)
+            all_entries = await fs._find(base_path, maxdepth=10, withdirs=include_dirs)
+            for entry_path in all_entries:
+                if len(results) >= max_results:
+                    break
+
+                # Skip directories we don't want to search
+                parts = entry_path.split("/")
+                if any(part in SKIP_DIRS for part in parts):
+                    continue
+
+                name = parts[-1] if parts else entry_path
+                if fnmatch.fnmatch(name, query):
+                    # Get relative path
+                    if entry_path.startswith(base_path):
+                        rel_path = entry_path[len(base_path) :].lstrip("/")
+                    else:
+                        rel_path = entry_path
+                    results.append(rel_path)
+        except Exception:  # noqa: BLE001
+            pass
+    else:
+        # Fallback to local Path operations
+        working_path = Path(state.working_dir)
+
+        def search_dir(dir_path: Path) -> None:
+            if len(results) >= max_results:
+                return
+
+            for entry in dir_path.iterdir():
+                if len(results) >= max_results:
+                    return
+
+                if entry.is_dir():
+                    if entry.name not in SKIP_DIRS:
+                        if include_dirs and fnmatch.fnmatch(entry.name, query):
+                            results.append(str(entry.relative_to(working_path)))
+                        search_dir(entry)
+                elif entry.is_file() and fnmatch.fnmatch(entry.name, query):
+                    results.append(str(entry.relative_to(working_path)))
+
+        search_dir(working_path)
+
+    return sorted(results)
+
+
+@router.get("/find/symbol")
+async def find_symbols(state: StateDep, query: str = Query()) -> list[Symbol]:
+    """Find workspace symbols.
+
+    Returns empty list - LSP symbol search not yet implemented.
+    """
+    _ = state
+    _ = query
+    # TODO: Integrate with LSP or implement basic symbol extraction
+    return []