sandboxy 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

sandboxy/agents/llm_prompt.py

@@ -16,11 +16,37 @@ MAX_RETRIES = 3
 RETRY_DELAY_BASE = 1.0  # seconds
 
 
+def _is_local_provider_model(model_id: str) -> bool:
+    """Check if a model ID refers to a local provider.
+
+    Args:
+        model_id: Model identifier
+
+    Returns:
+        True if the model is from a configured local provider
+    """
+    if "/" not in model_id:
+        return False
+
+    provider_name = model_id.split("/")[0]
+
+    # Check if this provider name matches a configured local provider
+    try:
+        from sandboxy.providers.config import load_providers_config
+
+        config = load_providers_config()
+        return any(p.name == provider_name and p.enabled for p in config.providers)
+    except Exception:
+        return False
+
+
 class LlmPromptAgent(BaseAgent):
     """Agent that uses an LLM via OpenAI-compatible API.
 
-    Supports both direct OpenAI and OpenRouter (for 400+ models).
-    Uses OpenRouter when model contains "/" (e.g., "openai/gpt-4o").
+    Supports:
+    - Local providers (Ollama, LM Studio, vLLM) when model matches configured provider
+    - OpenRouter (for 400+ cloud models)
+    - Direct OpenAI when model has no prefix
     """
 
     def __init__(self, config: AgentConfig) -> None:
@@ -31,7 +57,12 @@ class LlmPromptAgent(BaseAgent):
         """
         super().__init__(config)
         self._client: Any = None
-        self._is_openrouter = "/" in (config.model or "")
+        self._local_provider: Any = None
+
+        # Check for local provider first
+        self._is_local = _is_local_provider_model(config.model or "")
+        self._is_openrouter = not self._is_local and "/" in (config.model or "")
+
         # Token usage tracking
         self._total_input_tokens = 0
         self._total_output_tokens = 0
@@ -39,6 +70,9 @@ class LlmPromptAgent(BaseAgent):
     @property
     def api_key(self) -> str:
         """Get the appropriate API key based on model type."""
+        if self._is_local:
+            # Local providers may not need an API key, or it's in the provider config
+            return ""
         if self._is_openrouter:
             return os.getenv("OPENROUTER_API_KEY", "")
         return os.getenv("OPENAI_API_KEY", "")
@@ -49,15 +83,46 @@ class LlmPromptAgent(BaseAgent):
         if self._client is None:
             from openai import OpenAI
 
-            if self._is_openrouter:
-                logger.debug("Initializing OpenRouter client for model: %s", self.config.model)
-                self._client = OpenAI(
-                    api_key=self.api_key,
-                    base_url="https://openrouter.ai/api/v1",
-                )
-            else:
-                logger.debug("Initializing OpenAI client for model: %s", self.config.model)
-                self._client = OpenAI(api_key=self.api_key)
+            if self._is_local:
+                # Get local provider and create client pointing to it
+                provider_name = (self.config.model or "").split("/")[0]
+                from sandboxy.providers.config import load_providers_config
+
+                config = load_providers_config()
+                provider_config = config.get_provider(provider_name)
+
+                if provider_config:
+                    logger.debug(
+                        "Initializing local client for %s at %s",
+                        provider_name,
+                        provider_config.base_url,
+                    )
+                    headers = {}
+                    if provider_config.api_key:
+                        headers["Authorization"] = f"Bearer {provider_config.api_key}"
+
+                    self._client = OpenAI(
+                        api_key=provider_config.api_key or "not-needed",
+                        base_url=provider_config.base_url,
+                        default_headers=headers if headers else None,
+                    )
+                else:
+                    logger.warning(
+                        "Local provider %s not found, falling back to OpenRouter", provider_name
+                    )
+                    self._is_local = False
+                    self._is_openrouter = True
+
+            if self._client is None:  # Not set by local provider path
+                if self._is_openrouter:
+                    logger.debug("Initializing OpenRouter client for model: %s", self.config.model)
+                    self._client = OpenAI(
+                        api_key=self.api_key,
+                        base_url="https://openrouter.ai/api/v1",
+                    )
+                else:
+                    logger.debug("Initializing OpenAI client for model: %s", self.config.model)
+                    self._client = OpenAI(api_key=self.api_key)
         return self._client
 
     def step(
@@ -66,7 +131,8 @@ class LlmPromptAgent(BaseAgent):
         available_tools: list[dict[str, Any]] | None = None,
     ) -> AgentAction:
         """Process conversation and return next action using LLM."""
-        if not self.api_key:
+        # Local providers don't require an API key
+        if not self._is_local and not self.api_key:
             return self._stub_response(history)
 
         messages = self._build_messages(history)
@@ -188,8 +254,13 @@ class LlmPromptAgent(BaseAgent):
         messages: list[dict[str, Any]],
         tools: list[dict[str, Any]] | None,
     ) -> Any:
-        """Make API call to OpenAI/OpenRouter."""
+        """Make API call to OpenAI/OpenRouter/Local provider."""
         model = self.config.model or "gpt-4o-mini"
+
+        # For local providers, strip the provider prefix (e.g., "ollama/llama3" -> "llama3")
+        if self._is_local and "/" in model:
+            model = model.split("/", 1)[1]
+
         kwargs: dict[str, Any] = {
             "model": model,
             "messages": messages,

sandboxy/api/app.py

@@ -58,12 +58,13 @@ def create_local_app(
     )
 
     # Local routes only
-    from sandboxy.api.routes import agents, tools
+    from sandboxy.api.routes import agents, providers, tools
     from sandboxy.api.routes import local as local_routes
 
     app.include_router(local_routes.router, prefix="/api/v1", tags=["local"])
     app.include_router(agents.router, prefix="/api/v1", tags=["agents"])
     app.include_router(tools.router, prefix="/api/v1", tags=["tools"])
+    app.include_router(providers.router, prefix="/api/v1", tags=["providers"])
 
     @app.get("/health")
     async def health_check():

sandboxy/api/routes/local.py

@@ -636,6 +636,8 @@ async def compare_models(request: CompareModelsRequest) -> CompareModelsResponse
                     exporter.export(
                         result=result.to_dict(),
                         scenario_path=scenario_path,
+                        scenario_name=spec.name,
+                        scenario_id=spec.id,
                         agent_name=result.model,
                     )
             except ImportError:
@@ -692,10 +694,40 @@ def calculate_cost(model_id: str, input_tokens: int, output_tokens: int) -> floa
 
 @router.get("/local/models")
 async def list_available_models() -> list[dict[str, Any]]:
-    """List available models from OpenRouter."""
+    """List available models from OpenRouter and local providers."""
+    from sandboxy.providers.config import get_enabled_providers
+    from sandboxy.providers.local import LocalProvider
     from sandboxy.providers.openrouter import OPENROUTER_MODELS
 
     models = []
+
+    # Add models from local providers first
+    for provider_config in get_enabled_providers():
+        try:
+            provider = LocalProvider(provider_config)
+            local_models = await provider.refresh_models()
+            await provider.close()
+
+            for model in local_models:
+                # Model ID includes provider prefix for routing
+                full_model_id = f"{provider_config.name}/{model.id}"
+                models.append(
+                    {
+                        "id": full_model_id,
+                        "name": model.name,
+                        "price": "Local",
+                        "pricing": {"input": 0, "output": 0},
+                        "provider": provider_config.name,
+                        "context_length": model.context_length,
+                        "supports_vision": model.supports_vision,
+                        "is_local": True,
+                        "provider_name": provider_config.name,
+                    }
+                )
+        except Exception as e:
+            logger.warning(f"Failed to fetch models from {provider_config.name}: {e}")
+
+    # Add OpenRouter models
     for model_id, info in OPENROUTER_MODELS.items():
         # Format price string
         if info.input_cost_per_million == 0 and info.output_cost_per_million == 0:
@@ -715,6 +747,7 @@ async def list_available_models() -> list[dict[str, Any]]:
                 "provider": info.provider,
                 "context_length": info.context_length,
                 "supports_vision": info.supports_vision,
+                "is_local": False,
             }
         )
 

sandboxy/api/routes/providers.py

@@ -0,0 +1,369 @@
+"""API routes for local provider management."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Literal
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel, Field
+
+from sandboxy.providers.config import (
+    LocalProviderConfig,
+    ProviderStatusEnum,
+    load_providers_config,
+    save_providers_config,
+)
+from sandboxy.providers.local import LocalProvider
+from sandboxy.providers.registry import reload_local_providers
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/providers", tags=["providers"])
+
+
+# --- Response Models ---
+
+
+class ProviderSummary(BaseModel):
+    """Summary of a provider for list view."""
+
+    name: str
+    type: str
+    base_url: str
+    enabled: bool
+    status: ProviderStatusEnum
+    model_count: int
+    models: list[str] = Field(default_factory=list)
+
+
+class ProviderListResponse(BaseModel):
+    """Response for GET /api/v1/providers."""
+
+    providers: list[ProviderSummary]
+
+
+class LocalModelInfoResponse(BaseModel):
+    """Model info in API response."""
+
+    id: str
+    name: str
+    context_length: int
+    supports_tools: bool
+    is_local: bool = True
+
+
+class ProviderStatusResponse(BaseModel):
+    """Provider connection status."""
+
+    status: ProviderStatusEnum
+    last_checked: str | None = None
+    available_models: list[str] = Field(default_factory=list)
+    latency_ms: int | None = None
+    error_message: str | None = None
+
+
+class ProviderDetailResponse(BaseModel):
+    """Response for GET /api/v1/providers/{name}."""
+
+    config: dict[str, Any]  # LocalProviderConfig as dict
+    status: ProviderStatusResponse
+    models: list[LocalModelInfoResponse]
+
+
+class AddProviderRequest(BaseModel):
+    """Request body for POST /api/v1/providers."""
+
+    name: str
+    type: Literal["ollama", "lmstudio", "vllm", "openai-compatible"] = "openai-compatible"
+    base_url: str
+    api_key: str | None = None
+    models: list[str] = Field(default_factory=list)
+    default_params: dict[str, Any] = Field(default_factory=dict)
+
+
+class UpdateProviderRequest(BaseModel):
+    """Request body for PATCH /api/v1/providers/{name}."""
+
+    enabled: bool | None = None
+    api_key: str | None = None
+    models: list[str] | None = None
+    default_params: dict[str, Any] | None = None
+
+
+class TestConnectionResponse(BaseModel):
+    """Response for POST /api/v1/providers/{name}/test."""
+
+    success: bool
+    latency_ms: int | None = None
+    models_found: list[str] = Field(default_factory=list)
+    error: str | None = None
+
+
+class RefreshModelsResponse(BaseModel):
+    """Response for POST /api/v1/providers/{name}/refresh."""
+
+    models_found: list[str]
+    models_added: list[str]
+    models_removed: list[str]
+
+
+class ErrorDetail(BaseModel):
+    """Standard error response."""
+
+    code: str
+    message: str
+    details: dict[str, Any] | None = None
+
+
+# --- Routes ---
+
+
+@router.get("", response_model=ProviderListResponse)
+async def list_providers() -> ProviderListResponse:
+    """List all configured providers with status."""
+    config = load_providers_config()
+
+    summaries: list[ProviderSummary] = []
+    for pconfig in config.providers:
+        provider = LocalProvider(pconfig)
+        try:
+            status = await provider.test_connection()
+            summaries.append(
+                ProviderSummary(
+                    name=pconfig.name,
+                    type=pconfig.type,
+                    base_url=pconfig.base_url,
+                    enabled=pconfig.enabled,
+                    status=status.status,
+                    model_count=len(status.available_models),
+                    models=status.available_models,
+                )
+            )
+        except Exception:
+            summaries.append(
+                ProviderSummary(
+                    name=pconfig.name,
+                    type=pconfig.type,
+                    base_url=pconfig.base_url,
+                    enabled=pconfig.enabled,
+                    status=ProviderStatusEnum.ERROR,
+                    model_count=0,
+                    models=[],
+                )
+            )
+        finally:
+            await provider.close()
+
+    return ProviderListResponse(providers=summaries)
+
+
+@router.post("", response_model=ProviderSummary, status_code=status.HTTP_201_CREATED)
+async def add_provider(request: AddProviderRequest) -> ProviderSummary:
+    """Add a new provider."""
+    config = load_providers_config()
+
+    # Check for duplicate
+    if config.get_provider(request.name):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=ErrorDetail(
+                code="provider_exists",
+                message=f"Provider '{request.name}' already exists",
+            ).model_dump(),
+        )
+
+    # Validate and create config
+    try:
+        provider_config = LocalProviderConfig(
+            name=request.name,
+            type=request.type,
+            base_url=request.base_url,
+            api_key=request.api_key,
+            models=request.models,
+            default_params=request.default_params,
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=ErrorDetail(
+                code="validation_error",
+                message=str(e),
+            ).model_dump(),
+        ) from e
+
+    # Test connection
+    provider = LocalProvider(provider_config)
+    try:
+        conn_status = await provider.test_connection()
+    finally:
+        await provider.close()
+
+    # Save config
+    config.add_provider(provider_config)
+    save_providers_config(config)
+    reload_local_providers()
+
+    return ProviderSummary(
+        name=provider_config.name,
+        type=provider_config.type,
+        base_url=provider_config.base_url,
+        enabled=provider_config.enabled,
+        status=conn_status.status,
+        model_count=len(conn_status.available_models),
+    )
+
+
+@router.get("/{name}", response_model=ProviderDetailResponse)
+async def get_provider(name: str) -> ProviderDetailResponse:
+    """Get detailed provider info including models."""
+    config = load_providers_config()
+    provider_config = config.get_provider(name)
+
+    if not provider_config:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ErrorDetail(
+                code="provider_not_found",
+                message=f"Provider '{name}' not found",
+                details={"available_providers": [p.name for p in config.providers]},
+            ).model_dump(),
+        )
+
+    provider = LocalProvider(provider_config)
+    try:
+        conn_status = await provider.test_connection()
+        models = await provider.refresh_models()
+    finally:
+        await provider.close()
+
+    return ProviderDetailResponse(
+        config=provider_config.model_dump(),
+        status=ProviderStatusResponse(
+            status=conn_status.status,
+            last_checked=conn_status.last_checked.isoformat() if conn_status.last_checked else None,
+            available_models=conn_status.available_models,
+            latency_ms=conn_status.latency_ms,
+            error_message=conn_status.error_message,
+        ),
+        models=[
+            LocalModelInfoResponse(
+                id=m.id,
+                name=m.name,
+                context_length=m.context_length,
+                supports_tools=m.supports_tools,
+            )
+            for m in models
+        ],
+    )
+
+
+@router.delete("/{name}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_provider(name: str) -> None:
+    """Remove a provider."""
+    config = load_providers_config()
+
+    if not config.remove_provider(name):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ErrorDetail(
+                code="provider_not_found",
+                message=f"Provider '{name}' not found",
+            ).model_dump(),
+        )
+
+    save_providers_config(config)
+    reload_local_providers()
+
+
+@router.patch("/{name}", response_model=dict)
+async def update_provider(name: str, request: UpdateProviderRequest) -> dict:
+    """Update provider configuration."""
+    config = load_providers_config()
+
+    updates = {k: v for k, v in request.model_dump().items() if v is not None}
+    if not updates:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=ErrorDetail(
+                code="validation_error",
+                message="No fields to update",
+            ).model_dump(),
+        )
+
+    updated = config.update_provider(name, **updates)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ErrorDetail(
+                code="provider_not_found",
+                message=f"Provider '{name}' not found",
+            ).model_dump(),
+        )
+
+    save_providers_config(config)
+    reload_local_providers()
+
+    return updated.model_dump()
+
+
+@router.post("/{name}/test", response_model=TestConnectionResponse)
+async def test_provider_connection(name: str) -> TestConnectionResponse:
+    """Test provider connection."""
+    config = load_providers_config()
+    provider_config = config.get_provider(name)
+
+    if not provider_config:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ErrorDetail(
+                code="provider_not_found",
+                message=f"Provider '{name}' not found",
+            ).model_dump(),
+        )
+
+    provider = LocalProvider(provider_config)
+    try:
+        conn_status = await provider.test_connection()
+    finally:
+        await provider.close()
+
+    return TestConnectionResponse(
+        success=conn_status.status == ProviderStatusEnum.CONNECTED,
+        latency_ms=conn_status.latency_ms,
+        models_found=conn_status.available_models,
+        error=conn_status.error_message,
+    )
+
+
+@router.post("/{name}/refresh", response_model=RefreshModelsResponse)
+async def refresh_provider_models(name: str) -> RefreshModelsResponse:
+    """Refresh model list from provider."""
+    config = load_providers_config()
+    provider_config = config.get_provider(name)
+
+    if not provider_config:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ErrorDetail(
+                code="provider_not_found",
+                message=f"Provider '{name}' not found",
+            ).model_dump(),
+        )
+
+    # Get current models
+    old_models = set(provider_config.models)
+
+    provider = LocalProvider(provider_config)
+    try:
+        models = await provider.refresh_models()
+    finally:
+        await provider.close()
+
+    new_models = {m.id for m in models}
+
+    return RefreshModelsResponse(
+        models_found=list(new_models),
+        models_added=list(new_models - old_models),
+        models_removed=list(old_models - new_models),
+    )