✨ performance updated 2

Author: FJRG2007

src/agent.py

@@ -25,6 +25,7 @@
     set_rotation_callbacks, model_fallback_manager
 )
 from .tools import TOOL_DEFINITIONS, execute_tool, TOOLS, get_all_tool_definitions
+from .terminal import terminal_title
 from .ui import (
     console, display_tool_call, display_tool_result, display_executed_tool,
     display_code_execution_result, display_info, display_warning,
@@ -397,6 +398,7 @@ def _generate():
             try:
                 title = self.client_manager.generate_title(first_message)
                 history_manager.set_title(title)
+                terminal_title.set_session(title)
                 log_debug(f"Generated title: {title}")
             except Exception as e:
                 log_error("Failed to generate title", e)
@@ -435,18 +437,91 @@ def _parse_tool_calls_from_text(self, text: str) -> List[ToolCall]:
 
         return tool_calls
 
+    def _repair_json(self, json_str: str) -> str:
+        """Attempt to repair malformed JSON from LLM responses"""
+        if not json_str or not json_str.strip():
+            return "{}"
+
+        s = json_str.strip()
+
+        # Extract JSON if wrapped in markdown code blocks
+        if "```json" in s:
+            start = s.find("```json") + 7
+            end = s.find("```", start)
+            if end > start:
+                s = s[start:end].strip()
+        elif "```" in s:
+            start = s.find("```") + 3
+            end = s.find("```", start)
+            if end > start:
+                s = s[start:end].strip()
+
+        # Find the actual JSON object/array
+        first_brace = s.find('{')
+        first_bracket = s.find('[')
+        if first_brace == -1 and first_bracket == -1:
+            return "{}"
+
+        if first_brace != -1 and (first_bracket == -1 or first_brace < first_bracket):
+            s = s[first_brace:]
+            # Find matching closing brace
+            depth = 0
+            in_string = False
+            escape = False
+            end_idx = len(s)
+            for i, c in enumerate(s):
+                if escape:
+                    escape = False
+                    continue
+                if c == '\\':
+                    escape = True
+                    continue
+                if c == '"' and not escape:
+                    in_string = not in_string
+                    continue
+                if in_string:
+                    continue
+                if c == '{':
+                    depth += 1
+                elif c == '}':
+                    depth -= 1
+                    if depth == 0:
+                        end_idx = i + 1
+                        break
+            s = s[:end_idx]
+        elif first_bracket != -1:
+            s = s[first_bracket:]
+
+        # Fix common JSON issues
+        # Remove trailing commas before } or ]
+        s = re.sub(r',\s*([}\]])', r'\1', s)
+
+        # Balance braces if needed
+        open_braces = s.count('{') - s.count('}')
+        open_brackets = s.count('[') - s.count(']')
+        s = s + '}' * max(0, open_braces) + ']' * max(0, open_brackets)
+
+        return s
+
     def _parse_tool_args(self, tc) -> dict:
-        """Parse tool call arguments"""
+        """Parse tool call arguments with JSON repair for malformed responses"""
         try:
             if isinstance(tc.arguments, dict):
                 return tc.arguments
             elif isinstance(tc.arguments, str) and tc.arguments.strip():
                 return json.loads(tc.arguments)
             else:
                 return {}
-        except json.JSONDecodeError as e:
-            log_error("Failed to parse tool arguments", e, {"tool": tc.name, "args": tc.arguments[:200] if tc.arguments else ""})
-            return {}
+        except json.JSONDecodeError:
+            # Try to repair the JSON
+            try:
+                repaired = self._repair_json(tc.arguments)
+                result = json.loads(repaired)
+                log_debug(f"Repaired malformed JSON for tool {tc.name}")
+                return result
+            except json.JSONDecodeError as e:
+                log_error("Failed to parse tool arguments", e, {"tool": tc.name, "args": tc.arguments[:200] if tc.arguments else ""})
+                return {}
 
     def _execute_tool_only(self, tc, args: dict) -> tuple:
         """Execute a tool without UI - for parallel execution"""

src/clients.py

@@ -307,6 +307,53 @@ def _stream_compound_chat(
             )
             raise
 
+    def _estimate_tokens(self, messages: List[Dict[str, Any]]) -> int:
+        """Rough estimate of token count (approx 4 chars per token)"""
+        total_chars = 0
+        for msg in messages:
+            content = msg.get("content", "")
+            if isinstance(content, str):
+                total_chars += len(content)
+            elif isinstance(content, list):
+                for item in content:
+                    if isinstance(item, dict) and "text" in item:
+                        total_chars += len(item["text"])
+            # Count tool calls too
+            if "tool_calls" in msg:
+                for tc in msg.get("tool_calls", []):
+                    if isinstance(tc, dict) and "function" in tc:
+                        total_chars += len(str(tc["function"]))
+        return total_chars // 4
+
+    def _truncate_messages_for_limit(self, messages: List[Dict[str, Any]], max_tokens: int = 5000) -> List[Dict[str, Any]]:
+        """Truncate older messages to stay within token limit for GPT-OSS models"""
+        if not messages:
+            return messages
+
+        # Always keep system message and last few messages
+        system_msgs = [m for m in messages if m.get("role") == "system"]
+        non_system = [m for m in messages if m.get("role") != "system"]
+
+        if self._estimate_tokens(messages) <= max_tokens:
+            return messages
+
+        # Keep system + last N messages, progressively reducing
+        result = system_msgs.copy()
+        for i in range(len(non_system) - 1, -1, -1):
+            candidate = result + non_system[i:]
+            if self._estimate_tokens(candidate) <= max_tokens:
+                return candidate
+
+        # If still too large, just keep system + last message with truncated content
+        if non_system:
+            last_msg = non_system[-1].copy()
+            content = last_msg.get("content", "")
+            if isinstance(content, str) and len(content) > 2000:
+                last_msg["content"] = content[:2000] + "... (truncated)"
+            result.append(last_msg)
+
+        return result
+
     def _stream_gpt_oss_chat(
         self,
         client,
@@ -320,9 +367,12 @@ def _stream_gpt_oss_chat(
         # Import here to avoid circular imports
         from .tools import get_all_tool_definitions
 
+        # Truncate messages to avoid rate limit (GPT-OSS has 8000 TPM limit)
+        truncated_messages = self._truncate_messages_for_limit(messages, max_tokens=5000)
+
         try:
             kwargs = {
-                "messages": messages,
+                "messages": truncated_messages,
                 "model": model,
                 "stream": True
             }

src/multi_agent.py

@@ -7,6 +7,8 @@
 import time
 import uuid
 import queue
+import re
+import json
 from enum import Enum
 from typing import Dict, Any, List, Optional, Callable
 from dataclasses import dataclass, field
@@ -24,6 +26,47 @@
 from .config import COLORS, AVAILABLE_MODELS, DEFAULT_MODEL, get_system_prompt
 
 
+# ═══════════════════════════════════════════════════════════════════════════════
+# JSON Repair Helper
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def _repair_json(json_str: str) -> str:
+    """Attempt to repair malformed JSON from LLM responses"""
+    if not json_str or not json_str.strip():
+        return "{}"
+
+    s = json_str.strip()
+
+    # Extract JSON if wrapped in markdown code blocks
+    if "```json" in s:
+        start = s.find("```json") + 7
+        end = s.find("```", start)
+        if end > start:
+            s = s[start:end].strip()
+    elif "```" in s:
+        start = s.find("```") + 3
+        end = s.find("```", start)
+        if end > start:
+            s = s[start:end].strip()
+
+    # Find the actual JSON object
+    first_brace = s.find('{')
+    if first_brace == -1:
+        return "{}"
+
+    s = s[first_brace:]
+
+    # Remove trailing commas before } or ]
+    s = re.sub(r',\s*([}\]])', r'\1', s)
+
+    # Balance braces if needed
+    open_braces = s.count('{') - s.count('}')
+    open_brackets = s.count('[') - s.count(']')
+    s = s + '}' * max(0, open_braces) + ']' * max(0, open_brackets)
+
+    return s
+
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Task Status
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -184,11 +227,15 @@ def execute_task(self, task: AgentTask, progress_callback: Callable = None) -> s
                             if isinstance(tc.arguments, dict):
                                 args = tc.arguments
                             elif isinstance(tc.arguments, str):
-                                import json
                                 try:
                                     args = json.loads(tc.arguments) if tc.arguments.strip() else {}
                                 except json.JSONDecodeError:
-                                    args = {}
+                                    # Try to repair malformed JSON
+                                    try:
+                                        repaired = _repair_json(tc.arguments)
+                                        args = json.loads(repaired)
+                                    except json.JSONDecodeError:
+                                        args = {}
                             else:
                                 args = {}
 

static-api/version.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.0.0.31"
+    "version": "0.0.0.32"
 }