bone-agent 1.4.0 → 2.0.1

package/src/llm/providers.py

@@ -1,438 +0,0 @@
-"""Provider-specific request/response handlers.
-
-This module isolates provider-specific API quirks into handler classes.
-"""
-
-import json
-from typing import Optional, Dict, Any, Iterator
-import requests
-
-from exceptions import LLMResponseError
-from .codex_provider import CodexResponsesHandler
-
-
-class OpenAIHandler:
-    """Handler for OpenAI-compatible providers.
-
-    Supports: OpenAI, OpenRouter, GLM, Gemini, Kimi, MiniMax
-    """
-
-    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."""
-        payload = {**config.get("payload", {}), "messages": messages, "stream": stream}
-
-        # Ensure model is set from config if not in payload
-        if "model" not in payload:
-            model_name = config.get("api_model") or config.get("model")
-            if model_name:
-                payload["model"] = model_name
-
-        # Add tools if provided (OpenAI format)
-        if tools:
-            payload["tools"] = tools
-
-        # Set default parameters if not in config
-        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 parse_response(self, response_json: Dict[str, Any]) -> Dict[str, Any]:
-        """Parse non-streaming response (already in OpenAI format)."""
-        return response_json
-
-    def parse_stream(self, response: requests.Response) -> Iterator[Dict[str, Any]]:
-        """Parse streaming response.
-
-        Yields text chunks, and finally yields a dict with __usage__ key.
-        """
-        usage_data = None
-
-        for line in response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-
-                # Skip OpenRouter comments (start with ':')
-                if line.startswith(':'):
-                    continue
-
-                if line.startswith('data: '):
-                    data_str = line[6:]
-                    if data_str.strip() == '[DONE]':
-                        break
-
-                    try:
-                        data = json.loads(data_str)
-
-                        # Check for mid-stream errors
-                        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')}
-                            )
-
-                        # Capture usage data if present (usually in final chunk)
-                        if 'usage' in data:
-                            usage_data = dict(data['usage'])
-                            # Promote top-level cost into usage dict (OpenRouter places it here)
-                            if 'cost' in data:
-                                usage_data['cost'] = data['cost']
-
-                        choices = data.get('choices', [])
-                        if choices:
-                            delta = choices[0].get('delta', {})
-                            content = delta.get('content')
-                            if content is not None:
-                                yield content
-
-                    except json.JSONDecodeError as e:
-                        raise LLMResponseError(
-                            f"Failed to decode streaming response",
-                            details={"original_error": str(e)}
-                        )
-
-        # Yield usage data as final item if captured
-        if usage_data:
-            yield {'__usage__': usage_data}
-
-
-class AnthropicHandler:
-    """Handler for Anthropic API.
-
-    Anthropic has significant differences from OpenAI:
-    - Different endpoint (/messages vs /chat/completions)
-    - Different message format (content arrays vs strings)
-    - Different tool format (flat vs nested)
-    - Different streaming (SSE with event types vs data: lines)
-    - Different headers (x-api-key vs Authorization: Bearer)
-    - Different parameters (requires max_tokens, forbids top_p with temperature)
-    """
-
-    def build_headers(self, config: Dict[str, Any]) -> Dict[str, str]:
-        """Build request headers (Anthropic uses x-api-key)."""
-        headers = {"Content-Type": "application/json"}
-        if config.get("type") == "api" and config.get("api_key"):
-            headers["x-api-key"] = 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 (Anthropic format)."""
-        # Extract system messages to top-level parameter
-        system_messages = [msg["content"] for msg in messages if msg.get("role") == "system"]
-        system_content = "\n".join(system_messages) if system_messages else None
-        non_system_messages = [msg for msg in messages if msg.get("role") != "system"]
-
-        # Convert messages and tools to Anthropic format
-        anthropic_messages = self._convert_messages_to_anthropic(non_system_messages)
-        anthropic_tools = self._convert_tools_to_anthropic(tools) if tools else None
-
-        payload = {**config.get("payload", {}), "messages": anthropic_messages, "stream": stream}
-
-        # Ensure model is set from config if not in payload
-        if "model" not in payload:
-            model_name = config.get("api_model") or config.get("model")
-            if model_name:
-                payload["model"] = model_name
-
-        if system_content:
-            payload["system"] = system_content
-        if anthropic_tools:
-            payload["tools"] = anthropic_tools
-
-        # Set default parameters (Anthropic requires max_tokens)
-        if "temperature" not in payload and config.get("allow_temperature", True):
-            payload["temperature"] = config.get("default_temperature", 0.1)
-        if "max_tokens" not in payload:
-            payload["max_tokens"] = config.get("max_tokens", 4096)
-        
-        # Anthropic doesn't allow both temperature and top_p
-        # Only set top_p if temperature is not set
-        if "temperature" not in payload and "top_p" not in payload:
-            payload["top_p"] = config.get("default_top_p", 0.9)
-        
-        return payload
-
-    def parse_response(self, response_json: Dict[str, Any]) -> Dict[str, Any]:
-        """Convert Anthropic response format to OpenAI-style format."""
-        # Anthropic format: {"content": [{"type": "text", "text": "..."}], "usage": {...}}
-        # OpenAI format: {"choices": [{"message": {"content": "..."}}], "usage": {...}}
-
-        # Convert Anthropic usage format (input_tokens/output_tokens) to OpenAI format (prompt_tokens/completion_tokens)
-        # Anthropic's input_tokens does NOT include cache tokens; total input =
-        #   input_tokens + cache_read_input_tokens + cache_creation_input_tokens
-        anthropic_usage = response_json.get("usage", {})
-        cache_read = anthropic_usage.get('cache_read_input_tokens', 0)
-        cache_creation = anthropic_usage.get('cache_creation_input_tokens', 0)
-        prompt_tokens = anthropic_usage.get('input_tokens', 0) + cache_read + cache_creation
-        completion_tokens = anthropic_usage.get('output_tokens', 0)
-        openai_format_usage = {
-            'prompt_tokens': prompt_tokens,
-            'completion_tokens': completion_tokens,
-            'total_tokens': prompt_tokens + completion_tokens,
-        }
-        # Preserve Anthropic cache token fields for the token tracker
-        if 'cache_read_input_tokens' in anthropic_usage:
-            openai_format_usage['cache_read_input_tokens'] = anthropic_usage['cache_read_input_tokens']
-        if 'cache_creation_input_tokens' in anthropic_usage:
-            openai_format_usage['cache_creation_input_tokens'] = anthropic_usage['cache_creation_input_tokens']
-        # Preserve non-cache input count so cost estimation can bill only the
-        # non-cache portion without relying on fragile prompt_tokens subtraction.
-        if 'input_tokens' in anthropic_usage:
-            openai_format_usage['input_tokens'] = anthropic_usage['input_tokens']
-
-        result = {
-            "choices": [],
-            "usage": openai_format_usage
-        }
-
-        # Extract content from Anthropic's content array
-        content_blocks = response_json.get("content", [])
-        text_parts = []
-        tool_calls = []
-
-        for block in content_blocks:
-            if block.get("type") == "text":
-                text_parts.append(block.get("text", ""))
-            elif block.get("type") == "tool_use":
-                # Convert Anthropic tool_use to OpenAI tool_calls format
-                tool_calls.append({
-                    "id": block.get("id"),
-                    "type": "function",
-                    "function": {
-                        "name": block.get("name"),
-                        "arguments": json.dumps(block.get("input", {}))
-                    }
-                })
-
-        # Build OpenAI-style message
-        message = {"role": "assistant"}
-
-        # Include either text content or tool calls
-        if tool_calls:
-            message["content"] = None
-            message["tool_calls"] = tool_calls
-        else:
-            message["content"] = "".join(text_parts)
-
-        result["choices"].append({"message": message})
-
-        return result
-
-    def parse_stream(self, response: requests.Response) -> Iterator[Dict[str, Any]]:
-        """Parse Anthropic's SSE-based streaming response.
-
-        Yields text chunks, and finally yields a dict with __usage__ key.
-
-        Anthropic splits usage across two events:
-        - message_start: contains input_tokens
-        - message_delta: contains output_tokens
-        We merge both and convert to OpenAI format (prompt_tokens/completion_tokens).
-        """
-        usage_data = {}
-
-        for line in response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-
-                # Anthropic uses SSE format: "event: <type>" followed by "data: <json>"
-                if line.startswith('data: '):
-                    data_str = line[6:]
-                    try:
-                        data = json.loads(data_str)
-
-                        # Check for errors
-                        if data.get('type') == 'error':
-                            error_msg = data.get('error', {}).get('message', 'Unknown error')
-                            raise LLMResponseError(
-                                f"Anthropic streaming error: {error_msg}",
-                                details={"error_data": data.get('error')}
-                            )
-
-                        # Capture input_tokens from message_start events
-                        if data.get('type') == 'message_start':
-                            message_usage = data.get('message', {}).get('usage', {})
-                            if message_usage:
-                                usage_data.update(message_usage)
-
-                        # Capture output_tokens from message_delta events
-                        if data.get('type') == 'message_delta' and 'usage' in data:
-                            usage_data.update(data['usage'])
-
-                        # Extract text from content_block_delta events
-                        if data.get('type') == 'content_block_delta':
-                            delta = data.get('delta', {})
-                            if delta.get('type') == 'text_delta':
-                                text = delta.get('text', '')
-                                if text:
-                                    yield text
-
-                    except json.JSONDecodeError as e:
-                        raise LLMResponseError(
-                            f"Failed to decode Anthropic streaming response",
-                            details={"original_error": str(e)}
-                        )
-
-        # Yield usage data as final item if captured
-        # Convert Anthropic format (input_tokens/output_tokens) to OpenAI format (prompt_tokens/completion_tokens)
-        # Anthropic's input_tokens does NOT include cache tokens; total input =
-        #   input_tokens + cache_read_input_tokens + cache_creation_input_tokens
-        if usage_data:
-            cache_read = usage_data.get('cache_read_input_tokens', 0)
-            cache_creation = usage_data.get('cache_creation_input_tokens', 0)
-            prompt_tokens = usage_data.get('input_tokens', 0) + cache_read + cache_creation
-            completion_tokens = usage_data.get('output_tokens', 0)
-            openai_format_usage = {
-                'prompt_tokens': prompt_tokens,
-                'completion_tokens': completion_tokens,
-                'total_tokens': prompt_tokens + completion_tokens,
-            }
-            # Preserve Anthropic cache token fields for the token tracker
-            if 'cache_read_input_tokens' in usage_data:
-                openai_format_usage['cache_read_input_tokens'] = usage_data['cache_read_input_tokens']
-            if 'cache_creation_input_tokens' in usage_data:
-                openai_format_usage['cache_creation_input_tokens'] = usage_data['cache_creation_input_tokens']
-            # Preserve non-cache input count for accurate cost estimation
-            if 'input_tokens' in usage_data:
-                openai_format_usage['input_tokens'] = usage_data['input_tokens']
-            yield {'__usage__': openai_format_usage}
-
-    @staticmethod
-    def _convert_tools_to_anthropic(openai_tools: list) -> list:
-        """Convert OpenAI-style tool definitions to Anthropic format.
-
-        OpenAI format: {"type": "function", "function": {"name": "...", "parameters": {...}}}
-        Anthropic format: {"name": "...", "description": "...", "input_schema": {...}}
-        """
-        anthropic_tools = []
-
-        for openai_tool in openai_tools:
-            if openai_tool.get("type") == "function":
-                func = openai_tool.get("function", {})
-                anthropic_tool = {
-                    "name": func.get("name"),
-                    "description": func.get("description", ""),
-                    "input_schema": func.get("parameters", {"type": "object", "properties": {}})
-                }
-                anthropic_tools.append(anthropic_tool)
-
-        return anthropic_tools
-
-    @staticmethod
-    def _convert_messages_to_anthropic(openai_messages: list) -> list:
-        """Convert OpenAI-style messages to Anthropic format.
-
-        Anthropic requires all content to be an array, not a string.
-
-        OpenAI format:
-            {"role": "user", "content": "text"}
-            {"role": "tool", "content": "...", "tool_call_id": "..."}
-
-        Anthropic format:
-            {"role": "user", "content": [{"type": "text", "text": "..."}]}
-            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "...", "content": "..."}]}
-        """
-        anthropic_messages = []
-
-        for msg in openai_messages:
-            # Handle tool result messages
-            if msg.get("role") == "tool":
-                anthropic_msg = {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "tool_result",
-                            "tool_use_id": msg.get("tool_call_id"),
-                            "content": msg.get("content", "")
-                        }
-                    ]
-                }
-                anthropic_messages.append(anthropic_msg)
-            # Handle user and assistant messages - convert string content to array
-            elif msg.get("role") in ("user", "assistant"):
-                content = msg.get("content", "")
-                tool_calls = msg.get("tool_calls")
-
-                # Build content blocks array
-                content_blocks = []
-
-                # Add text content if present
-                if isinstance(content, str) and content.strip():
-                    content_blocks.append({
-                        "type": "text",
-                        "text": content
-                    })
-                elif isinstance(content, list):
-                    # Already an array (Anthropic format), use as-is
-                    anthropic_messages.append(msg)
-                    continue
-
-                # Add tool_use blocks if present (for assistant messages with tool calls)
-                if tool_calls:
-                    for tool_call in tool_calls:
-                        content_blocks.append({
-                            "type": "tool_use",
-                            "id": tool_call.get("id"),
-                            "name": tool_call.get("function", {}).get("name"),
-                            "input": json.loads(tool_call.get("function", {}).get("arguments", "{}"))
-                        })
-
-                # Only add message if we have content blocks (text or tool_use)
-                if content_blocks:
-                    anthropic_msg = {
-                        "role": msg.get("role"),
-                        "content": content_blocks
-                    }
-                    anthropic_messages.append(anthropic_msg)
-            else:
-                # Other message types, pass through
-                anthropic_messages.append(msg)
-
-        return anthropic_messages
-
-
-# Handler registry - maps provider names to handler classes
-HANDLER_REGISTRY = {
-    "openai": OpenAIHandler,
-    "openrouter": OpenAIHandler,
-    "glm": OpenAIHandler,
-    "glm_plan": OpenAIHandler,
-    "gemini": OpenAIHandler,
-    "minimax": AnthropicHandler,
-    "minimax_plan": AnthropicHandler,
-    "kimi": OpenAIHandler,
-    "anthropic": AnthropicHandler,
-    "local": OpenAIHandler,
-    "codex": CodexResponsesHandler,
-}
-
-
-def get_handler(provider_name: str):
-    """Get handler instance for the given provider.
-
-    Args:
-        provider_name: Name of the provider
-
-    Returns:
-        Handler instance for the provider
-    """
-    handler_class = HANDLER_REGISTRY.get(provider_name.lower(), OpenAIHandler)
-    return handler_class()
-
-
-__all__ = ['OpenAIHandler', 'AnthropicHandler', 'CodexResponsesHandler', 'get_handler']

package/src/llm/streaming.py

@@ -1,163 +0,0 @@
-"""Streaming response assembler for agentic mode.
-
-Consumes a StreamWrapper yielding mixed delta dicts and assembles them into
-a complete message dict (content + tool_calls), matching the format that
-non-streaming responses already produce.
-
-Usage:
-    stream = client.chat_completion(messages, stream=True, tools=tools)
-    assembler = StreamingResponse(stream, console, debug_mode=False)
-    message = assembler.consume()  # iterates stream, prints text, assembles tool_calls
-    tool_calls = message.get("tool_calls")
-    usage = assembler.usage
-"""
-
-import json
-import sys
-from typing import Any, Dict, List, Optional
-
-from rich.text import Text
-
-
-class StreamingResponse:
-    """Assemble streaming deltas into a complete message dict.
-
-    Text deltas are printed to stderr immediately (raw, no formatting).
-    Tool call deltas are buffered and reassembled across chunks.
-    """
-
-    def __init__(self, stream, console=None, debug_mode: bool = False,
-                 on_text=None, live=None):
-        """
-        Args:
-            stream: StreamWrapper (or any iterable yielding deltas / __usage__ dicts).
-            console: Rich Console instance (used for debug logging only).
-            debug_mode: If True, log assembly details.
-            on_text: Optional callback(str) invoked for each text token.
-                     Defaults to printing to stderr.
-            live: Optional Rich Live context. When set, streaming text is
-                  rendered through Live (raw during streaming, swappable to
-                  Markdown on completion) instead of raw stderr.
-        """
-        self._stream = stream
-        self._console = console
-        self._debug = debug_mode
-        self._on_text = on_text
-        self._live = live
-
-        # Accumulated state
-        self._text_parts: List[str] = []
-        self._tool_calls: Dict[int, Dict[str, Any]] = {}  # index -> partial tool call
-        self._usage: Optional[Dict[str, Any]] = None
-
-    def consume(self) -> Dict[str, Any]:
-        """Iterate the stream, print text tokens, assemble tool calls.
-
-        Returns:
-            A message dict with 'role', 'content', and optionally 'tool_calls'
-            — same shape as a non-streaming response["choices"][0]["message"].
-        """
-        for item in self._stream:
-            if isinstance(item, dict) and '__usage__' in item:
-                self._usage = item['__usage__']
-                continue
-
-            # OpenAI-style delta: {"content": "...", "tool_calls": [...]}
-            if isinstance(item, dict):
-                self._process_delta(item)
-            elif isinstance(item, str):
-                # Fallback: plain text string (legacy parse_stream behavior)
-                self._print(item)
-                self._text_parts.append(item)
-
-        return self._build_message()
-
-    @property
-    def usage(self) -> Optional[Dict[str, Any]]:
-        """Usage data captured from the stream's final chunk."""
-        return self._usage
-
-    def _process_delta(self, delta: Dict[str, Any]):
-        """Process a single streaming delta dict.
-
-        Expected shapes (OpenAI format):
-            {"content": "some text"}
-            {"tool_calls": [{"index": 0, "id": "call_xxx", "function": {"name": "f"}}]}
-            {"tool_calls": [{"index": 0, "function": {"arguments": "{..."}}]}
-            {"content": "text", "tool_calls": [...]}
-        """
-        # Handle text content
-        content = delta.get("content")
-        if content is not None:
-            self._print(content)
-            self._text_parts.append(content)
-
-        # Handle tool call fragments
-        tool_calls = delta.get("tool_calls")
-        if tool_calls:
-            for tc_delta in tool_calls:
-                idx = tc_delta.get("index", 0)
-                if idx not in self._tool_calls:
-                    self._tool_calls[idx] = {
-                        "id": "",
-                        "type": "function",
-                        "function": {"name": "", "arguments": ""},
-                    }
-
-                entry = self._tool_calls[idx]
-
-                # Tool call id (sent once at the start)
-                if tc_delta.get("id"):
-                    entry["id"] = tc_delta["id"]
-
-                # Function name (sent once at the start)
-                func = tc_delta.get("function", {})
-                if func.get("name"):
-                    entry["function"]["name"] = func["name"]
-
-                # Arguments (sent incrementally, concatenated)
-                if func.get("arguments"):
-                    entry["function"]["arguments"] += func["arguments"]
-
-    def _build_message(self) -> Dict[str, Any]:
-        """Build the final message dict from assembled parts."""
-        message: Dict[str, Any] = {"role": "assistant"}
-
-        # Collect assembled tool calls in index order
-        assembled_tool_calls = []
-        if self._tool_calls:
-            for idx in sorted(self._tool_calls.keys()):
-                assembled_tool_calls.append(self._tool_calls[idx])
-
-        if assembled_tool_calls:
-            message["tool_calls"] = assembled_tool_calls
-            # Content may be None or a string alongside tool calls
-            text = "".join(self._text_parts).strip()
-            message["content"] = text if text else None
-        else:
-            message["content"] = "".join(self._text_parts)
-
-        return message
-
-    def _print(self, text: str):
-        """Output text token via the configured callback (default: stderr).
-
-        When a Rich Live context is provided, text is rendered through Live
-        for atomic screen updates (raw text during streaming, swappable to
-        Markdown on completion).
-        """
-        if self._live is not None:
-            # Render through Rich Live — update with accumulated text so far
-            self._live.update(Text("".join(self._text_parts) + text))
-        elif self._on_text is None:
-            # Default: print to stderr
-            sys.stderr.write(text)
-            sys.stderr.flush()
-        elif callable(self._on_text):
-            self._on_text(text)
-        # If on_text is False, silently drop output (subagent mode)
-
-    def close(self):
-        """Close the underlying stream."""
-        if hasattr(self._stream, 'close'):
-            self._stream.close()