bone-agent 1.3.2 → 1.4.0

package/src/core/tool_feedback.py

@@ -1,6 +1,7 @@
 """Tool result display functions for the agentic loop."""
 
 import re
+import textwrap
 from pathlib import Path
 from typing import Optional
 
@@ -8,6 +9,7 @@ from rich.syntax import Syntax
 
 from utils.settings import MAX_COMMAND_OUTPUT_LINES, MonokaiDarkBGStyle
 from utils.result_parsers import extract_exit_code, extract_all_metadata, extract_multiple_metadata
+from tools.search_plugins import HEADER_MATCHES, HEADER_ALL
 from tools.task_list import _format_task_list, _strip_rich_markup
 
 
@@ -303,110 +305,119 @@ def handle_list_directory_feedback(tool_result, console, panel_updater):
 def handle_search_plugins_feedback(tool_result, console, panel_updater):
     """Handle feedback for search_plugins tool.
 
-    Display a tree of found plugins with query and category info,
-    similar to list_directory feedback style.
+    Display compact capability results in the same style as other tool output.
     """
     lines = tool_result.split('\n')
+    prefix = "╰─ " if not panel_updater else ""
 
-    # Extract query from "Found N plugin(s) matching 'query':" line
     query = ""
-    query_match = re.search(r"matching '([^']+)':", tool_result)
-    if query_match:
-        query = query_match.group(1)
+    capabilities = []
+    in_capability_section = False
 
-    # Parse plugin entries: - **name** [category] (status): description
-    #                         Tags: tag1, tag2
-    plugins = []
     i = 0
     while i < len(lines):
-        plugin_match = re.match(r'^- \*\*(.+?)\*\*(?:\s+\[(.+?)\])?\s+\((.+?)\):\s+(.+)$', lines[i])
-        if plugin_match:
-            name = plugin_match.group(1)
-            category = plugin_match.group(2) or ""
-            status = plugin_match.group(3)
-            description = plugin_match.group(4)
-
-            # Check next line for tags
-            tags = ""
-            if i + 1 < len(lines) and lines[i + 1].strip().startswith("Tags:"):
-                tags = lines[i + 1].strip().replace("Tags: ", "")
+        raw_line = lines[i]
+        line = raw_line.strip()
+
+        if line.startswith(HEADER_MATCHES):
+            query = line.replace(HEADER_MATCHES, "", 1)
+            in_capability_section = True
+            i += 1
+            continue
+
+        if line == HEADER_ALL:
+            query = line
+            in_capability_section = True
+            i += 1
+            continue
+
+        if not in_capability_section:
+            i += 1
+            continue
+
+        if line.startswith("Results: ") or line.startswith("Total: ") or not line:
+            i += 1
+            continue
+
+        if line.startswith("Activated plugins:") or line.startswith("Loaded skills:") or line.startswith("Load issues:"):
+            break
+
+        item_match = re.match(r'^- (.+)$', line)
+        if item_match:
+            item = {
+                "name": item_match.group(1),
+                "type": "",
+                "status": "",
+                "summary": "",
+                "tags": "",
+            }
+            i += 1
+            while i < len(lines):
+                raw_detail_line = lines[i]
+                stripped = raw_detail_line.strip()
+                if not stripped:
+                    i += 1
+                    continue
+                if re.match(r'^- (.+)$', stripped):
+                    break
+                if stripped.startswith("Activated plugins:") or stripped.startswith("Loaded skills:") or stripped.startswith("Load issues:"):
+                    break
+                if stripped.startswith("type: "):
+                    item["type"] = stripped.replace("type: ", "", 1)
+                elif stripped.startswith("status: "):
+                    item["status"] = stripped.replace("status: ", "", 1)
+                elif stripped.startswith("summary: "):
+                    item["summary"] = stripped.replace("summary: ", "", 1)
+                elif stripped.startswith("tags: "):
+                    item["tags"] = stripped.replace("tags: ", "", 1)
                 i += 1
+            capabilities.append(item)
+            continue
 
-            plugins.append({
-                "name": name,
-                "category": category,
-                "status": status,
-                "description": description,
-                "tags": tags,
-            })
         i += 1
 
-    if not plugins:
-        # No plugins found — just show the message
-        prefix = "╰─ " if not panel_updater else ""
-        # Extract the informational message (skip exit_code line)
+    if not capabilities:
         msg_lines = [l for l in lines if l.strip() and not l.startswith("exit_code=")]
-        output = prefix + "\n".join(msg_lines) if msg_lines else f"{prefix}No plugins found"
+        output = prefix + "\n".join(msg_lines) if msg_lines else f"{prefix}No capability matches"
         _print_or_append(output, console, panel_updater)
         if not panel_updater:
             console.print()
         return
 
-    # Build tree display
-    max_display = 10
-    display_plugins = plugins[:max_display]
-    remaining = max(0, len(plugins) - max_display)
+    def append_wrapped_detail(line_parts, text, indent, width=72):
+        wrapped_lines = textwrap.wrap(text, width=width) or [text]
+        line_parts.extend(f"{indent}[dim]{wrapped}[/dim]" for wrapped in wrapped_lines)
 
-    # Count activated vs already active
-    activated_count = sum(1 for p in plugins if p["status"] == "activated")
-    already_active_count = sum(1 for p in plugins if p["status"] == "already active")
+    max_display = 10
+    display_capabilities = capabilities[:max_display]
+    remaining = max(0, len(capabilities) - max_display)
 
+    header = f"{query} ({len(capabilities)} match{'es' if len(capabilities) != 1 else ''})" if query else "capabilities"
     tree_lines = []
-    for i, plugin in enumerate(display_plugins):
-        is_last = (i == len(display_plugins) - 1) and (remaining == 0)
-        connector = "└─" if is_last else "├─"
 
-        # Build the plugin line: name [category] (status)
-        cat_part = f" [{plugin['category']}]" if plugin['category'] else ""
-        status_part = plugin['status']
+    for idx, capability in enumerate(display_capabilities):
+        is_last = (idx == len(display_capabilities) - 1) and (remaining == 0)
+        connector = "└─" if is_last else "├─"
 
-        if status_part == "activated":
-            status_display = f"[green]{status_part}[/green]"
+        if capability["type"] == "plugin":
+            meta = "[dim](plugin)[/dim]"
+            if capability["status"]:
+                meta += f" [dim][{capability['status']}][/dim]"
         else:
-            status_display = f"[dim]{status_part}[/dim]"
-
-        line = f"   {connector} **{plugin['name']}**{cat_part} ({status_display}): {plugin['description']}"
-        tree_lines.append(line)
+            meta = "[dim](skill)[/dim]"
 
-        # Tags on sub-line
-        if plugin["tags"]:
-            tag_connector = "│  " if not is_last else "   "
-            tree_lines.append(f"{tag_connector}   Tags: [dim]{plugin['tags']}[/dim]")
+        detail_indent = "   │  " if not is_last else "      "
+        line_parts = [f"   {connector} {capability['name']} {meta}"]
+        if capability["summary"]:
+            append_wrapped_detail(line_parts, capability["summary"], detail_indent)
+        if capability["tags"]:
+            append_wrapped_detail(line_parts, f"tags: {capability['tags']}", detail_indent)
+        tree_lines.append("\n".join(line_parts))
 
-    # Add overflow indicator
     if remaining > 0:
         tree_lines.append(f"   └─ ... and {remaining} more")
 
-    # Build header
-    if query:
-        header = f"plugins matching '{query}' ({len(plugins)} found)"
-    else:
-        header = f"plugins ({len(plugins)} found)"
-
-    prefix = "╰─ " if not panel_updater else ""
-    output = f"{prefix}{header}\n"
-    output += "\n".join(tree_lines)
-
-    # Activation summary
-    if activated_count > 0 or already_active_count > 0:
-        summary_parts = []
-        if activated_count > 0:
-            summary_parts.append(f"{activated_count} activated")
-        if already_active_count > 0:
-            summary_parts.append(f"{already_active_count} already active")
-        summary = ", ".join(summary_parts)
-        output += f"\n{prefix}[dim]{summary}. Schemas available next turn. Auto-evict after 10 turns of non-use.[/dim]"
-
+    output = f"{prefix}{header}\n" + "\n".join(tree_lines)
     _print_or_append(output, console, panel_updater)
 
     if not panel_updater:

package/src/llm/client.py

@@ -127,8 +127,13 @@ class LLMClient:
                     self.handler.parse_stream(response)
                 )
             else:
-                response_json = response.json()
-                return self.handler.parse_response(response_json)
+                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(

package/src/llm/codex_provider.py

@@ -0,0 +1,350 @@
+"""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