bone-agent 1.3.0

package/src/llm/providers.py

@@ -0,0 +1,417 @@
+"""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
+
+
+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_usage = response_json.get("usage", {})
+        openai_format_usage = {
+            'prompt_tokens': anthropic_usage.get('input_tokens', 0),
+            'completion_tokens': anthropic_usage.get('output_tokens', 0),
+            'total_tokens': anthropic_usage.get('input_tokens', 0) + anthropic_usage.get('output_tokens', 0),
+        }
+        # 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']
+
+        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)
+        if usage_data:
+            openai_format_usage = {
+                'prompt_tokens': usage_data.get('input_tokens', 0),
+                'completion_tokens': usage_data.get('output_tokens', 0),
+                'total_tokens': usage_data.get('input_tokens', 0) + usage_data.get('output_tokens', 0),
+            }
+            # 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']
+            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,
+}
+
+
+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', 'get_handler']

package/src/llm/streaming.py

@@ -0,0 +1,163 @@
+"""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()