bone-agent 1.4.0 → 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,176 +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:
-                try:
-                    response_json = response.json()
-                    return self.handler.parse_response(response_json)
-                except ValueError:
-                    if getattr(self.handler, "supports_sse_response_fallback", False):
-                        return self.handler.parse_sse_response(response.text)
-                    raise
-
-        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']

package/src/llm/codex_provider.py

@@ -1,350 +0,0 @@
-"""Codex provider adapter.
-
-Codex is intentionally isolated from the normal provider handlers because it is
-not a Chat Completions-compatible API. It targets the ChatGPT Codex Responses
-backend and adapts that protocol back into vmCode's OpenAI-style internal shape.
-"""
-
-import copy
-import hashlib
-import json
-from typing import Any, Dict, Iterator, Optional
-
-import requests
-
-from exceptions import LLMResponseError
-
-
-class CodexResponsesHandler:
-    """Adapter for the ChatGPT Codex Responses backend.
-
-    Codex-specific behavior kept here:
-    - Uses `instructions` + `input` instead of Chat Completions `messages`.
-    - Always sends `stream: true`; the backend returns SSE even for logical
-      non-streaming agent calls.
-    - Stores `_responses_output` replay metadata so tool-call turns can be sent
-      back in Responses-native form while using `store: false`.
-    """
-
-    supports_sse_response_fallback = True
-
-    def build_headers(self, config: Dict[str, Any]) -> Dict[str, str]:
-        """Build request headers."""
-        headers = {"Content-Type": "application/json"}
-        if config.get("type") == "api" and config.get("api_key"):
-            headers["Authorization"] = f"Bearer {config['api_key']}"
-        if "headers_extra" in config:
-            headers.update(config["headers_extra"])
-        return headers
-
-    def build_payload(self, config: Dict[str, Any], messages: list,
-                      tools: Optional[list] = None, stream: bool = True) -> Dict[str, Any]:
-        """Build request payload for Codex backend Responses API."""
-        system_parts = [m["content"] for m in messages if m.get("role") == "system"]
-        instructions = "\n".join(system_parts) if system_parts else "You are a helpful assistant."
-
-        codex_input = []
-        for m in messages:
-            if m.get("role") == "system":
-                continue
-            role = m.get("role", "user")
-            content = m.get("content", "")
-
-            if role == "assistant" and m.get("_responses_output"):
-                codex_input.extend(m.get("_responses_output") or [])
-                continue
-
-            if role == "assistant" and m.get("tool_calls"):
-                if content:
-                    codex_input.append({
-                        "role": "assistant",
-                        "content": [{"type": "input_text", "text": content}]
-                    })
-                for tool_call in m.get("tool_calls", []):
-                    function = tool_call.get("function", {})
-                    codex_input.append({
-                        "type": "function_call",
-                        "call_id": tool_call.get("id"),
-                        "name": function.get("name", ""),
-                        "arguments": function.get("arguments", "{}"),
-                    })
-                continue
-
-            if role == "tool":
-                codex_input.append({
-                    "type": "function_call_output",
-                    "call_id": m.get("tool_call_id"),
-                    "output": content,
-                })
-                continue
-
-            content_type = "output_text" if role == "assistant" else "input_text"
-            codex_input.append({
-                "role": role,
-                "content": [{"type": content_type, "text": content}]
-            })
-
-        payload = {
-            **config.get("payload", {}),
-            "instructions": instructions,
-            "input": codex_input,
-            "store": False,
-            "stream": True,
-        }
-
-        if "model" not in payload:
-            model_name = config.get("api_model") or config.get("model")
-            if model_name:
-                payload["model"] = model_name
-
-        if tools:
-            payload["tools"] = [self._convert_tool_to_responses(tool) for tool in tools]
-
-        if "prompt_cache_key" not in payload:
-            model = payload.get("model") or "unknown-model"
-            payload["prompt_cache_key"] = self._build_prompt_cache_key(
-                model=model,
-                instructions=instructions,
-                tools=payload.get("tools"),
-            )
-
-        if "temperature" not in payload and config.get("allow_temperature", True):
-            payload["temperature"] = config.get("default_temperature", 0.1)
-        if "top_p" not in payload and config.get("allow_top_p", True):
-            payload["top_p"] = config.get("default_top_p", 0.9)
-
-        return payload
-
-    def _build_prompt_cache_key(
-        self,
-        *,
-        model: str,
-        instructions: str,
-        tools: Optional[list] = None,
-    ) -> str:
-        """Build a stable prompt-cache key for the reusable Codex prefix."""
-        cache_scope = {
-            "model": model,
-            "instructions": instructions,
-            "tools": tools or [],
-        }
-        canonical = json.dumps(
-            cache_scope,
-            sort_keys=True,
-            separators=(",", ":"),
-            ensure_ascii=True,
-        )
-        cache_hash = hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:24]
-        return f"bone-agent:{cache_hash}"
-
-    def parse_response(self, response_json: Dict[str, Any]) -> Dict[str, Any]:
-        """Parse Responses API output into Chat Completions format."""
-        return self._normalize_response(response_json)
-
-    def parse_sse_response(self, response_text: str) -> Dict[str, Any]:
-        """Parse a full SSE response body into Chat Completions format."""
-        completed_response = None
-        output_items = []
-
-        for raw_line in response_text.splitlines():
-            line = raw_line.strip()
-            if not line.startswith("data: "):
-                continue
-            data_str = line[6:]
-            if data_str == "[DONE]":
-                break
-            try:
-                data = json.loads(data_str)
-            except json.JSONDecodeError as e:
-                raise LLMResponseError(
-                    "Failed to decode SSE response from Codex backend",
-                    details={"original_error": str(e)}
-                )
-
-            if data.get("type") == "response.output_item.done":
-                item = data.get("item")
-                if item:
-                    output_items.append(item)
-                continue
-
-            if data.get("type") == "response.completed":
-                completed_response = data.get("response")
-                break
-
-        if completed_response is None:
-            raise LLMResponseError(
-                "Codex backend returned streaming data without a completed response event"
-            )
-
-        if not completed_response.get("output") and output_items:
-            completed_response = dict(completed_response)
-            completed_response["output"] = output_items
-
-        return self._normalize_response(completed_response)
-
-    def parse_stream(self, response: requests.Response) -> Iterator[Dict[str, Any]]:
-        """Parse streaming Responses API."""
-        usage_data = None
-
-        for line in response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-
-                if line.startswith('data: '):
-                    data_str = line[6:]
-                    if data_str.strip() == '[DONE]':
-                        break
-
-                    try:
-                        data = json.loads(data_str)
-
-                        if 'error' in data:
-                            error_msg = data.get('error', {}).get('message', 'Unknown streaming error')
-                            raise LLMResponseError(
-                                f"Streaming error: {error_msg}",
-                                details={"error_data": data.get('error')}
-                            )
-
-                        event_type = data.get("type", "")
-
-                        if event_type == "response.completed":
-                            resp = data.get("response", {})
-                            if "usage" in resp:
-                                usage_data = self._normalize_usage(resp["usage"])
-
-                        if event_type == "response.output_text.delta":
-                            delta = data.get("delta", "")
-                            if delta:
-                                yield delta
-
-                    except json.JSONDecodeError as e:
-                        raise LLMResponseError(
-                            f"Failed to decode streaming response",
-                            details={"original_error": str(e)}
-                        )
-
-        if usage_data:
-            yield {'__usage__': usage_data}
-
-    def _convert_tool_to_responses(self, tool: Dict[str, Any]) -> Dict[str, Any]:
-        """Convert Chat Completions tool schema to Responses/Codex schema."""
-        if tool.get("type") == "function" and "function" in tool:
-            function = tool["function"]
-            return {
-                "type": "function",
-                "name": function.get("name", ""),
-                "description": function.get("description", ""),
-                "parameters": self._normalize_json_schema(function.get("parameters", {})),
-                "strict": False,
-            }
-        return tool
-
-    def _normalize_response(self, response_json: Dict[str, Any]) -> Dict[str, Any]:
-        """Normalize Responses output into Chat Completions message shape."""
-        raw_usage = response_json.get("usage", {})
-        usage = self._normalize_usage(raw_usage)
-
-        output_items = response_json.get("output", [])
-        content_parts = []
-        tool_calls = []
-
-        for item in output_items:
-            item_type = item.get("type")
-
-            if item_type == "function_call":
-                call_id = item.get("call_id") or item.get("id")
-                tool_calls.append({
-                    "id": call_id,
-                    "type": "function",
-                    "function": {
-                        "name": item.get("name", ""),
-                        "arguments": item.get("arguments", "{}"),
-                    }
-                })
-                continue
-
-            if item_type != "message":
-                continue
-
-            for c in item.get("content", []):
-                if c.get("type") in {"output_text", "text"}:
-                    text = c.get("text")
-                    if text is not None:
-                        content_parts.append(text)
-
-        message = {"role": "assistant"}
-        text_content = "\n".join(content_parts) if content_parts else ""
-        if tool_calls:
-            message["tool_calls"] = tool_calls
-            message["content"] = text_content or None
-        else:
-            message["content"] = text_content
-
-        replay_items = copy.deepcopy(output_items)
-        for item in replay_items:
-            item.pop("id", None)
-        message["_responses_output"] = replay_items
-
-        return {
-            "choices": [{
-                "message": message,
-                "finish_reason": "tool_calls" if tool_calls else "stop",
-            }],
-            "usage": usage,
-        }
-
-    def _normalize_usage(self, usage: Any) -> Dict[str, Any]:
-        """Normalize Codex Responses usage into vmCode's OpenAI-style usage shape."""
-        if not isinstance(usage, dict):
-            return {}
-
-        normalized = dict(usage)
-
-        input_tokens = normalized.get("input_tokens")
-        output_tokens = normalized.get("output_tokens")
-
-        if normalized.get("prompt_tokens") is None and input_tokens is not None:
-            normalized["prompt_tokens"] = input_tokens
-        if normalized.get("completion_tokens") is None and output_tokens is not None:
-            normalized["completion_tokens"] = output_tokens
-        if normalized.get("total_tokens") is None:
-            prompt_tokens = normalized.get("prompt_tokens")
-            completion_tokens = normalized.get("completion_tokens")
-            if prompt_tokens is not None and completion_tokens is not None:
-                normalized["total_tokens"] = prompt_tokens + completion_tokens
-
-        input_details = normalized.get("input_tokens_details")
-        if isinstance(input_details, dict) and input_details.get("cached_tokens") is not None:
-            cached_tokens = input_details["cached_tokens"]
-            if normalized.get("prompt_tokens_details") is None:
-                normalized["prompt_tokens_details"] = {"cached_tokens": cached_tokens}
-            elif isinstance(normalized["prompt_tokens_details"], dict):
-                normalized["prompt_tokens_details"].setdefault("cached_tokens", cached_tokens)
-            normalized.setdefault("cached_tokens", cached_tokens)
-
-        return normalized
-
-    def _normalize_json_schema(self, schema: Any) -> Any:
-        """Normalize JSON Schema for strict Responses function tools."""
-        if not isinstance(schema, dict):
-            return schema
-
-        normalized = dict(schema)
-        schema_type = normalized.get("type")
-
-        if schema_type == "object":
-            properties = normalized.get("properties", {})
-            normalized["properties"] = {
-                key: self._normalize_json_schema(value)
-                for key, value in properties.items()
-            }
-            normalized.setdefault("additionalProperties", False)
-
-        if schema_type == "array" and "items" in normalized:
-            normalized["items"] = self._normalize_json_schema(normalized["items"])
-
-        for key in ("anyOf", "oneOf", "allOf"):
-            if key in normalized and isinstance(normalized[key], list):
-                normalized[key] = [self._normalize_json_schema(item) for item in normalized[key]]
-
-        return normalized