bone-agent 1.3.3 → 2.0.0

package/src/exceptions.py

@@ -1,79 +0,0 @@
-"""Custom exception hierarchy for bone-agent."""
-
-class BoneAgentError(Exception):
-    """Base exception for all bone-agent application errors.
-
-    All custom exceptions should inherit from this class.
-    Provides consistent error handling and allows catching
-    all bone-agent-specific errors with a single except clause.
-    """
-    def __init__(self, message: str, *, details: dict = None):
-        """Initialize exception with optional details.
-
-        Args:
-            message: Human-readable error message
-            details: Optional dictionary with additional error context
-        """
-        super().__init__(message)
-        self.details = details or {}
-
-    def __str__(self):
-        base_msg = super().__str__()
-        if self.details:
-            # Skip multi-line values from the compact string representation
-            # (they're included separately in detailed error formatting)
-            single_line_details = {k: v for k, v in self.details.items() if "\n" not in str(v)}
-            if single_line_details:
-                details_str = ", ".join(f"{k}={v}" for k, v in single_line_details.items())
-                return f"{base_msg} ({details_str})"
-        return base_msg
-
-
-class ConfigurationError(BoneAgentError):
-    """Raised when configuration is invalid, missing, or cannot be loaded."""
-    pass
-
-
-class LLMError(BoneAgentError):
-    """Raised when LLM API communication fails or returns unexpected data."""
-    pass
-
-
-class LLMConnectionError(LLMError):
-    """Raised when network connection to LLM provider fails."""
-    pass
-
-
-class LLMResponseError(LLMError):
-    """Raised when LLM response is malformed or invalid."""
-    pass
-
-
-class ToolExecutionError(BoneAgentError):
-    """Raised when tool execution fails."""
-    pass
-
-
-class CommandExecutionError(ToolExecutionError):
-    """Raised when shell command execution fails."""
-    pass
-
-
-class FileEditError(ToolExecutionError):
-    """Raised when file edit operation fails."""
-    pass
-
-
-class ValidationError(BoneAgentError):
-    """Raised when input validation fails."""
-    pass
-
-
-class PathValidationError(ValidationError):
-    """Raised when path validation fails (blocked by gitignore, etc.)."""
-    pass
-
-
-class CommandValidationError(ValidationError):
-    """Raised when command validation fails (dangerous operators, etc.)."""
-    pass

package/src/llm/__init__.py

@@ -1 +0,0 @@
-"""LLM integration layer for bone-agent."""

package/src/llm/client.py

@@ -1,171 +0,0 @@
-"""LLM client for making API requests to various providers."""
-
-import logging
-
-import requests
-from llm import config as config_module
-from llm.config import PROVIDER_REGISTRY, get_provider_config, get_providers
-from llm.providers import get_handler
-from exceptions import LLMConnectionError, LLMResponseError, ConfigurationError
-from utils.validation import validate_api_url
-
-logger = logging.getLogger(__name__)
-
-# Connection/read timeouts (seconds)
-_CONNECT_TIMEOUT = 10
-_READ_TIMEOUT = 120
-
-
-class StreamWrapper:
-    """Wraps streaming response generator with cleanup capability."""
-
-    def __init__(self, response, generator):
-        self._response = response
-        self._generator = generator
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return next(self._generator)
-
-    def close(self):
-        """Close underlying HTTP connection."""
-        if self._response:
-            self._response.close()
-
-
-class LLMClient:
-    def __init__(self, provider=None):
-        """Initialize LLM client.
-
-        Args:
-            provider: Provider name. If None, uses global LLM_PROVIDER from config.
-        """
-        self.provider = provider or config_module.LLM_PROVIDER
-        self.handler = get_handler(self.provider)
-        self.config = self._get_provider_config()
-
-    @property
-    def model(self) -> str:
-        """Return configured model name, if any."""
-        return str(self.config.get("payload", {}).get("model") or "")
-
-    def _get_provider_config(self):
-        """Build provider config from PROVIDER_REGISTRY."""
-        registry = get_provider_config(self.provider)
-        if not registry:
-            raise ConfigurationError(f"Unknown provider: {self.provider}")
-
-        # Build headers using handler
-        headers = self.handler.build_headers(registry)
-
-        # Build payload with model name
-        payload = {}
-        model_name = registry.get("api_model") or registry.get("model")
-        if model_name:
-            payload["model"] = model_name
-
-        url = f"{registry['api_base']}{registry['endpoint']}"
-        valid, err = validate_api_url(url)
-        if not valid:
-            raise ConfigurationError(
-                f"Insecure API endpoint for provider '{self.provider}': {err}"
-            )
-
-        return {
-            "url": url,
-            "headers": headers,
-            "payload": payload,
-            "error_prefix": registry["error_prefix"],
-            "registry": registry
-        }
-
-    def chat_completion(self, messages, stream=True, tools=None):
-        """Make a chat completion request.
-
-        Args:
-            messages: List of message dicts
-            stream: Whether to stream the response
-            tools: Optional list of tool definitions
-
-        Returns:
-            StreamWrapper if stream=True, else response dict
-        """
-        config = self.config
-        registry = config["registry"]
-
-        # Build payload using handler
-        payload = self.handler.build_payload(registry, messages, tools, stream)
-
-        try:
-            response = requests.post(
-                config["url"],
-                headers=config["headers"],
-                json=payload,
-                stream=stream,
-                verify=True,
-                timeout=(_CONNECT_TIMEOUT, _READ_TIMEOUT),
-            )
-
-            # For better debugging, include response text on 4xx errors
-            if not response.ok:
-                error_details = response.text if response.text else str(response.status_code)
-                raise LLMConnectionError(
-                    f"Error communicating with {config['error_prefix']}",
-                    details={
-                        "provider": self.provider,
-                        "original_error": error_details,
-                        "status_code": response.status_code,
-                    }
-                )
-            response.raise_for_status()
-
-            if stream:
-                return StreamWrapper(
-                    response,
-                    self.handler.parse_stream(response)
-                )
-            else:
-                response_json = response.json()
-                return self.handler.parse_response(response_json)
-
-        except requests.exceptions.RequestException as e:
-            raise LLMConnectionError(
-                f"Error communicating with {config['error_prefix']}",
-                details={"provider": self.provider, "original_error": str(e)}
-            )
-
-    def switch_provider(self, new_provider):
-        """Switch to a different provider.
-
-        Args:
-            new_provider: Name of the provider to switch to.
-
-        Returns:
-            True if successful, False if provider not found.
-        """
-        if new_provider in get_providers():
-            self.provider = new_provider
-            self.handler = get_handler(new_provider)
-            self.config = self._get_provider_config()
-            return True
-        return False
-
-    def sync_provider_from_config(self):
-        """Sync this client's provider and config with the current config.
-
-        This should be called after config is reloaded from disk.
-        """
-        current_provider = config_module.LLM_PROVIDER
-        if self.provider != current_provider:
-            self.provider = current_provider
-            self.handler = get_handler(current_provider)
-            self.config = self._get_provider_config()
-            return True
-        # Even if provider hasn't changed, config values (model, api_key) might have
-        self.config = self._get_provider_config()
-        return False
-
-
-__all__ = ['LLMClient']