bone-agent 1.3.3 → 1.4.0

package/src/core/sub_agent.py

@@ -4,11 +4,12 @@ Uses existing AgenticOrchestrator with isolated message context
 and read-only tools to execute generic delegated tasks.
 """
 
-from pathlib import Path
-
-from core.chat_manager import ChatManager
-from llm.prompts import build_sub_agent_prompt
-from utils.settings import sub_agent_settings
+from pathlib import Path
+
+from core.chat_manager import ChatManager
+from exceptions import LLMError
+from llm.prompts import build_sub_agent_prompt
+from utils.settings import sub_agent_settings
 
 
 class HardLimitExceeded(Exception):
@@ -16,6 +17,11 @@ class HardLimitExceeded(Exception):
     pass
 
 
+class BilledLimitExceeded(Exception):
+    """Raised when the sub-agent hits its cumulative billed token limit."""
+    pass
+
+
 def _format_messages_dump(messages) -> str:
     """Format sub-agent message history as a markdown dump.
 
@@ -89,7 +95,7 @@ def _inject_system_prompt(chat_manager, sub_agent_type: str = "research"):
     chat_manager.messages = [{"role": "system", "content": base_prompt}]
 
 
-def _load_codebase_map(chat_manager):
+def _load_codebase_map(chat_manager):
     """Load agents.md codebase map into sub-agent context if available.
 
     Args:
@@ -98,19 +104,13 @@ def _load_codebase_map(chat_manager):
     agents_path = Path.cwd() / "agents.md"
     if agents_path.exists():
         map_content = agents_path.read_text(encoding="utf-8").strip()
-        user_msg = (
-            "Here is the codebase map for this project. "
-            "This provides an overview of the repository structure and file purposes. "
-            "Use this as a reference when exploring the codebase.\n\n"
-            f"## Codebase Map (auto-generated from agents.md)\n\n{map_content}"
-        )
-        assistant_msg = (
-            "I've received the codebase map. I'll use this as a reference when "
-            "exploring the repository, but I'll always verify current state by "
-            "reading files and searching the codebase before making changes."
-        )
-        chat_manager.messages.append({"role": "user", "content": user_msg})
-        chat_manager.messages.append({"role": "assistant", "content": assistant_msg})
+        user_msg = (
+            "Here is the codebase map for this project. "
+            "This provides an overview of the repository structure and file purposes. "
+            "Use this as a reference when exploring the codebase.\n\n"
+            f"## Codebase Map (auto-generated from agents.md)\n\n{map_content}"
+        )
+        chat_manager.messages.append({"role": "user", "content": user_msg})
 
 
 def _configure_isolation(chat_manager):
@@ -183,14 +183,11 @@ def run_sub_agent(
     # Create fresh ChatManager for sub-agent
     temp_chat_manager = _create_chat_manager(sub_agent_type=sub_agent_type)
 
-    # Inject initial context as a user/assistant exchange if provided
-    if initial_context:
-        temp_chat_manager.messages.append(
-            {"role": "user", "content": initial_context}
-        )
-        temp_chat_manager.messages.append(
-            {"role": "assistant", "content": "I've received the context. I'll analyze it and use the available tools to gather additional information as needed."}
-        )
+    # Inject initial context as a user/assistant exchange if provided
+    if initial_context:
+        temp_chat_manager.messages.append(
+            {"role": "user", "content": initial_context}
+        )
 
     # Import here to avoid circular import with core.agentic
     from core.agentic import AgenticOrchestrator
@@ -216,27 +213,40 @@ def run_sub_agent(
     original_chat_completion = temp_chat_manager.client.chat_completion
 
     _soft_limit_warned = False
+    _billed_warning_sent = False
 
     def _chat_completion_with_token_hint(messages, **kwargs):
-        """Prepend a system-level token budget hint (and soft-limit warning once) to every LLM call."""
-        nonlocal _soft_limit_warned
+        """Prepend a system-level token budget hint and one-time warnings to every LLM call."""
+        nonlocal _soft_limit_warned, _billed_warning_sent
         tt = temp_chat_manager.token_tracker
-        hint = f"[Token budget: {tt.current_context_tokens:,} curr / {tt.conv_total_tokens:,} total]"
+        hint = f"[Token budget: {tt.current_context_tokens:,} curr / {tt.conv_total_tokens:,} total billed]"
+        warnings = []
 
         if not _soft_limit_warned and tt.current_context_tokens >= sub_agent_settings.soft_limit_tokens:
             _soft_limit_warned = True
-            hint = (
-                f"WARNING: You have exceeded the soft token limit "
+            warnings.append(
+                f"WARNING: You have exceeded the current-context soft token limit "
                 f"({tt.current_context_tokens:,} / {sub_agent_settings.soft_limit_tokens:,}). "
-                "STOP exploring and return your findings immediately. Do NOT call any more tools. "
-                + hint
+                "STOP exploring and return your findings immediately. Do NOT call any more tools."
             )
 
+        if not _billed_warning_sent and tt.conv_total_tokens >= sub_agent_settings.billed_warning_tokens:
+            _billed_warning_sent = True
+            warnings.append(
+                f"WARNING: You have exceeded the cumulative billed token warning limit "
+                f"({tt.conv_total_tokens:,} / {sub_agent_settings.billed_warning_tokens:,}). "
+                "This sub-agent may be running away. STOP exploring and return your findings immediately. "
+                "Do NOT call any more tools."
+            )
+
+        if warnings:
+            hint = "\n".join([*warnings, hint])
+
         token_msg = {"role": "system", "content": hint}
         return original_chat_completion([token_msg, *messages], **kwargs)
 
-    def _get_llm_response_with_hard_limit(allowed_tools=None):
-        """Wrapper to check hard token limit and update panel with live token counts."""
+    def _get_llm_response_with_hard_limit(allowed_tools=None, allow_active_plugins=False):
+        """Wrapper to check context and billed token limits and update panel state."""
         tt = temp_chat_manager.token_tracker
 
         # Check hard token limit before making LLM call
@@ -248,6 +258,19 @@ def run_sub_agent(
                 f"{tt.current_context_tokens:,} / {sub_agent_settings.hard_limit_tokens:,} tokens."
             )
 
+        # Check cumulative billed tokens to stop runaway sub-agents even when
+        # current context remains below the prompt-size hard limit.
+        #
+        # Note: the billed warning is injected by _chat_completion_with_token_hint
+        # on the next chat_completion call. This hard stop runs before each LLM
+        # response, so once we hit the billed hard limit the warning may never be
+        # delivered if no further chat_completion call is made.
+        if tt.conv_total_tokens >= sub_agent_settings.billed_hard_limit_tokens:
+            raise BilledLimitExceeded(
+                f"Sub-agent billed token limit exceeded: "
+                f"{tt.conv_total_tokens:,} / {sub_agent_settings.billed_hard_limit_tokens:,} tokens."
+            )
+
         # Update panel with live token counts
         # Order: conversation length (current context) first, total tokens billed second
         conv_length = tt.current_context_tokens
@@ -256,27 +279,45 @@ def run_sub_agent(
             panel_updater.token_info = f"{conv_length:,} curr | {total_billed:,} total"
             panel_updater.append("")  # Refresh panel title
 
-        return original_get_llm_response(allowed_tools=allowed_tools)
+        return original_get_llm_response(
+            allowed_tools=allowed_tools,
+            allow_active_plugins=allow_active_plugins,
+        )
 
     # Apply both patches once, before the orchestrator loop starts
     orchestrator._get_llm_response = _get_llm_response_with_hard_limit
     temp_chat_manager.client.chat_completion = _chat_completion_with_token_hint
 
     hard_limit_exceeded = False
+    billed_limit_exceeded = False
 
     try:
         # Run sub-agent task
         orchestrator.run(
             task_query,
             thinking_indicator=None,
-            allowed_tools=sub_agent_settings.allowed_tools
+            allowed_tools=sub_agent_settings.allowed_tools,
+            allow_active_plugins=sub_agent_settings.allow_active_plugins,
         )
     except HardLimitExceeded:
         hard_limit_exceeded = True
-    except Exception as e:
-        import traceback
-        error_details = f"{e}\n\nTraceback:\n{traceback.format_exc()}"
-        return {
+    except BilledLimitExceeded:
+        billed_limit_exceeded = True
+    except LLMError as e:
+        return {
+            "result": "",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            },
+            "model": temp_chat_manager.client.model,
+            "error": str(e)
+        }
+    except Exception as e:
+        import traceback
+        error_details = f"{e}\n\nTraceback:\n{traceback.format_exc()}"
+        return {
             "result": "",
             "usage": {
                 "prompt_tokens": 0,
@@ -306,7 +347,15 @@ def run_sub_agent(
             if msg.get("role") == "assistant" and msg.get("content"):
                 final_content = msg["content"].strip()
                 break
-        result = final_content
+
+        if billed_limit_exceeded:
+            prefix = (
+                "WARNING: Sub-agent billed token limit reached. "
+                "Returning current findings early to prevent runaway execution."
+            )
+            result = f"{prefix}\n\n{final_content}" if final_content else prefix
+        else:
+            result = final_content
 
     usage = {
         "prompt_tokens": delta_prompt,
@@ -323,4 +372,5 @@ def run_sub_agent(
         "model": temp_chat_manager.client.model,
         "error": None,
         "hard_limit_exceeded": hard_limit_exceeded,
+        "billed_limit_exceeded": billed_limit_exceeded,
     }

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(