glaip-sdk 0.0.5__py3-none-any.whl → 0.0.6a0__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/console.py

@@ -7,6 +7,7 @@ Authors:
 from __future__ import annotations
 
 import io
+from typing import Any
 
 from rich.console import Console as RichConsole
 
@@ -14,7 +15,7 @@ from rich.console import Console as RichConsole
 class CapturingConsole:
     """Console wrapper that captures all output for saving."""
 
-    def __init__(self, original_console, capture=False):
+    def __init__(self, original_console: RichConsole, capture: bool = False) -> None:
         """Initialize the capturing console.
 
         Args:
@@ -23,9 +24,9 @@ class CapturingConsole:
         """
         self.original_console = original_console
         self.capture = capture
-        self.captured_output = []
+        self.captured_output: list[str] = []
 
-    def print(self, *args, **kwargs):
+    def print(self, *args: Any, **kwargs: Any) -> None:
         """Print to both original console and capture buffer if capturing."""
         # Always print to original console
         self.original_console.print(*args, **kwargs)
@@ -43,12 +44,12 @@ class CapturingConsole:
             temp_console.print(*args, **kwargs)
             self.captured_output.append(temp_output.getvalue())
 
-    def get_captured_output(self):
+    def get_captured_output(self) -> str:
         """Get the captured output as plain text."""
         if self.capture:
             return "".join(self.captured_output)
         return ""
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         """Delegate all other attributes to the original console."""
         return getattr(self.original_console, name)

glaip_sdk/utils/rendering/renderer/debug.py

@@ -15,6 +15,81 @@ from rich.markdown import Markdown
 from glaip_sdk.rich_components import AIPPanel
 
 
+def _calculate_relative_time(started_ts: float | None) -> tuple[float, str]:
+    """Calculate relative time since start."""
+    now_mono = monotonic()
+    rel = 0.0
+    if started_ts is not None:
+        rel = max(0.0, now_mono - started_ts)
+
+    ts_full = datetime.now().strftime("%H:%M:%S.%f")
+    ts_ms = ts_full[:-3]  # trim to milliseconds
+
+    return rel, ts_ms
+
+
+def _get_event_metadata(event: dict[str, Any]) -> tuple[str, str | None]:
+    """Extract event kind and status."""
+    sse_kind = (event.get("metadata") or {}).get("kind") or "event"
+    status_str = event.get("status") or (event.get("metadata") or {}).get("status")
+    return sse_kind, status_str
+
+
+def _build_debug_title(
+    sse_kind: str, status_str: str | None, ts_ms: str, rel: float
+) -> str:
+    """Build the debug event title."""
+    if status_str:
+        return f"SSE: {sse_kind} — {status_str} @ {ts_ms} (+{rel:.2f}s)"
+    else:
+        return f"SSE: {sse_kind} @ {ts_ms} (+{rel:.2f}s)"
+
+
+def _dejson_value(obj: Any) -> Any:
+    """Deep-parse JSON strings in nested objects."""
+    if isinstance(obj, dict):
+        return {k: _dejson_value(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_dejson_value(x) for x in obj]
+    if isinstance(obj, str):
+        s = obj.strip()
+        if (s.startswith("{") and s.endswith("}")) or (
+            s.startswith("[") and s.endswith("]")
+        ):
+            try:
+                return _dejson_value(json.loads(s))
+            except Exception:
+                return obj
+        return obj
+    return obj
+
+
+def _format_event_json(event: dict[str, Any]) -> str:
+    """Format event as JSON with deep parsing."""
+    try:
+        return json.dumps(_dejson_value(event), indent=2, ensure_ascii=False)
+    except Exception:
+        return str(event)
+
+
+def _get_border_color(sse_kind: str) -> str:
+    """Get border color for event type."""
+    border_map = {
+        "agent_step": "blue",
+        "content": "green",
+        "final_response": "green",
+        "status": "yellow",
+        "artifact": "grey42",
+    }
+    return border_map.get(sse_kind, "grey42")
+
+
+def _create_debug_panel(title: str, event_json: str, border: str) -> AIPPanel:
+    """Create the debug panel."""
+    md = Markdown(f"```json\n{event_json}\n```", code_theme="monokai")
+    return AIPPanel(md, title=title, border_style=border)
+
+
 def render_debug_event(
     event: dict[str, Any], console: Console, started_ts: float | None = None
 ) -> None:
@@ -26,58 +101,25 @@ def render_debug_event(
         started_ts: Monotonic timestamp when streaming started
     """
     try:
-        # Add relative time since first meaningful event and wall-clock stamp
-        now_mono = monotonic()
-        rel = 0.0
-        if started_ts is not None:
-            rel = max(0.0, now_mono - started_ts)
-        ts_full = datetime.now().strftime("%H:%M:%S.%f")
-        ts_ms = ts_full[:-3]  # trim to milliseconds
-
-        # Compose a descriptive title with kind/status
-        sse_kind = (event.get("metadata") or {}).get("kind") or "event"
-        status_str = event.get("status") or (event.get("metadata") or {}).get("status")
-        title = (
-            f"SSE: {sse_kind} — {status_str} @ {ts_ms} (+{rel:.2f}s)"
-            if status_str
-            else f"SSE: {sse_kind} @ {ts_ms} (+{rel:.2f}s)"
-        )
-
-        # Deep-pretty the event by parsing nested JSON strings
-        def _dejson(obj):
-            if isinstance(obj, dict):
-                return {k: _dejson(v) for k, v in obj.items()}
-            if isinstance(obj, list):
-                return [_dejson(x) for x in obj]
-            if isinstance(obj, str):
-                s = obj.strip()
-                if (s.startswith("{") and s.endswith("}")) or (
-                    s.startswith("[") and s.endswith("]")
-                ):
-                    try:
-                        return _dejson(json.loads(s))
-                    except Exception:
-                        return obj
-                return obj
-            return obj
-
-        try:
-            event_json = json.dumps(_dejson(event), indent=2, ensure_ascii=False)
-        except Exception:
-            event_json = str(event)
-
-        # Choose border color by kind for readability
-        border = {
-            "agent_step": "blue",
-            "content": "green",
-            "final_response": "green",
-            "status": "yellow",
-            "artifact": "grey42",
-        }.get(sse_kind, "grey42")
-
-        # Render using Markdown with JSON code block (consistent with tool panels)
-        md = Markdown(f"```json\n{event_json}\n```", code_theme="monokai")
-        console.print(AIPPanel(md, title=title, border_style=border))
+        # Calculate timing information
+        rel, ts_ms = _calculate_relative_time(started_ts)
+
+        # Extract event metadata
+        sse_kind, status_str = _get_event_metadata(event)
+
+        # Build title
+        title = _build_debug_title(sse_kind, status_str, ts_ms, rel)
+
+        # Format event JSON
+        event_json = _format_event_json(event)
+
+        # Get border color
+        border = _get_border_color(sse_kind)
+
+        # Create and print panel
+        panel = _create_debug_panel(title, event_json, border)
+        console.print(panel)
+
     except Exception as e:
         # Debug helpers must not break streaming
         print(f"Debug error: {e}")  # Fallback debug output

glaip_sdk/utils/rendering/renderer/stream.py

@@ -6,6 +6,7 @@ Authors:
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from time import monotonic
 from typing import Any
 
@@ -13,7 +14,7 @@ from typing import Any
 class StreamProcessor:
     """Handles event routing and parsing for streaming agent execution."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the stream processor."""
         self.streaming_started_at: float | None = None
         self.server_elapsed_time: float | None = None
@@ -22,7 +23,7 @@ class StreamProcessor:
         self.current_event_finished_panels: set[str] = set()
         self.last_event_time_by_ctx: dict[str, float] = {}
 
-    def reset_event_tracking(self):
+    def reset_event_tracking(self) -> None:
         """Reset tracking for the current event."""
         self.current_event_tools.clear()
         self.current_event_sub_agents.clear()
@@ -47,7 +48,7 @@ class StreamProcessor:
             pass
 
         return {
-            "kind": metadata.get("kind") if metadata else None,
+            "kind": metadata.get("kind") if metadata else event.get("kind"),
             "task_id": event.get("task_id"),
             "context_id": event.get("context_id"),
             "content": event.get("content", ""),
@@ -55,9 +56,78 @@ class StreamProcessor:
             "metadata": metadata,
         }
 
+    def _extract_metadata_tool_calls(
+        self, metadata: dict[str, Any]
+    ) -> tuple[str | None, dict, Any, list]:
+        """Extract tool calls from metadata."""
+        tool_calls = metadata.get("tool_calls", [])
+        if not tool_calls:
+            return None, {}, None, []
+
+        # Take the first tool call if multiple exist
+        first_call = tool_calls[0] if isinstance(tool_calls, list) else tool_calls
+        tool_name = first_call.get("name")
+        tool_args = first_call.get("arguments", {})
+        tool_out = first_call.get("output")
+
+        # Collect info for all tool calls
+        tool_calls_info = []
+        for call in tool_calls if isinstance(tool_calls, list) else [tool_calls]:
+            if isinstance(call, dict) and "name" in call:
+                tool_calls_info.append(
+                    (
+                        call.get("name", ""),
+                        call.get("arguments", {}),
+                        call.get("output"),
+                    )
+                )
+
+        return tool_name, tool_args, tool_out, tool_calls_info
+
+    def _extract_tool_info_calls(
+        self, tool_info: dict[str, Any]
+    ) -> tuple[str | None, dict, Any, list]:
+        """Extract tool calls from tool_info structure."""
+        tool_calls_info = []
+        tool_name = None
+        tool_args = {}
+        tool_out = None
+
+        # Case 1: tool_info.tool_calls
+        ti_calls = tool_info.get("tool_calls")
+        if isinstance(ti_calls, list) and ti_calls:
+            for call in ti_calls:
+                if isinstance(call, dict) and call.get("name"):
+                    tool_calls_info.append(
+                        (call.get("name"), call.get("args", {}), call.get("output"))
+                    )
+            if tool_calls_info:
+                tool_name, tool_args, tool_out = tool_calls_info[0]
+            return tool_name, tool_args, tool_out, tool_calls_info
+
+        # Case 2: single tool_info name/args/output
+        if tool_info.get("name"):
+            tool_name = tool_info.get("name")
+            tool_args = tool_info.get("args", {})
+            tool_out = tool_info.get("output")
+            tool_calls_info.append((tool_name, tool_args, tool_out))
+
+        return tool_name, tool_args, tool_out, tool_calls_info
+
+    def _extract_tool_calls_from_metadata(
+        self, metadata: dict[str, Any]
+    ) -> tuple[str | None, dict, Any, list]:
+        """Extract tool calls from metadata structure."""
+        tool_info = metadata.get("tool_info", {}) or {}
+
+        if tool_info:
+            return self._extract_tool_info_calls(tool_info)
+
+        return None, {}, None, []
+
     def parse_tool_calls(
         self, event: dict[str, Any]
-    ) -> tuple[str | None, Any, Any, list]:
+    ) -> tuple[str | None, Any, Any, list[tuple[str, Any, Any]]]:
         """Parse tool call information from an event.
 
         Args:
@@ -66,56 +136,28 @@ class StreamProcessor:
         Returns:
             Tuple of (tool_name, tool_args, tool_output, tool_calls_info)
         """
-        tool_name = None
-        tool_args = {}
-        tool_out = None
-        tool_calls_info = []
-
-        # Extract tool information from metadata
         metadata = event.get("metadata", {})
-        tool_calls = metadata.get("tool_calls", [])
 
-        if tool_calls:
-            # Take the first tool call if multiple exist
-            first_call = tool_calls[0] if isinstance(tool_calls, list) else tool_calls
-            tool_name = first_call.get("name")
-            tool_args = first_call.get("arguments", {})
-            tool_out = first_call.get("output")
-
-            # Collect info for all tool calls
-            for call in tool_calls if isinstance(tool_calls, list) else [tool_calls]:
-                if isinstance(call, dict) and "name" in call:
-                    tool_calls_info.append(
-                        (
-                            call.get("name", ""),
-                            call.get("arguments", {}),
-                            call.get("output"),
-                        )
-                    )
+        # Try primary extraction method
+        (
+            tool_name,
+            tool_args,
+            tool_out,
+            tool_calls_info,
+        ) = self._extract_metadata_tool_calls(metadata)
 
         # Fallback to nested metadata.tool_info (newer schema)
         if not tool_calls_info:
-            tool_info = metadata.get("tool_info", {}) or {}
-            # Case 1: tool_info.tool_calls
-            ti_calls = tool_info.get("tool_calls")
-            if isinstance(ti_calls, list) and ti_calls:
-                for call in ti_calls:
-                    if isinstance(call, dict) and call.get("name"):
-                        tool_calls_info.append(
-                            (call.get("name"), call.get("args", {}), call.get("output"))
-                        )
-                if tool_calls_info and not tool_name:
-                    tool_name, tool_args, tool_out = tool_calls_info[0]
-            # Case 2: single tool_info name/args/output
-            if tool_info.get("name") and not tool_name:
-                tool_name = tool_info.get("name")
-                tool_args = tool_info.get("args", {})
-                tool_out = tool_info.get("output")
-                tool_calls_info.append((tool_name, tool_args, tool_out))
+            (
+                tool_name,
+                tool_args,
+                tool_out,
+                tool_calls_info,
+            ) = self._extract_tool_calls_from_metadata(metadata)
 
         return tool_name, tool_args, tool_out, tool_calls_info
 
-    def update_timing(self, context_id: str | None):
+    def update_timing(self, context_id: str | None) -> None:
         """Update timing information for the given context.
 
         Args:
@@ -148,8 +190,11 @@ class StreamProcessor:
         return elapsed >= think_threshold
 
     def track_tools_and_agents(
-        self, tool_name: str | None, tool_calls_info: list, is_delegation_tool_func
-    ):
+        self,
+        tool_name: str | None,
+        tool_calls_info: list[tuple[str, Any, Any]],
+        is_delegation_tool_func: Callable[[str], bool],
+    ) -> None:
         """Track tools and sub-agents mentioned in the current event.
 
         Args:

glaip_sdk/utils/rendering/steps.py

@@ -12,7 +12,7 @@ from glaip_sdk.utils.rendering.models import Step
 
 
 class StepManager:
-    def __init__(self, max_steps: int = 200):
+    def __init__(self, max_steps: int = 200) -> None:
         self.by_id: dict[str, Step] = {}
         self.order: list[str] = []
         self.children: dict[str, list[str]] = {}
@@ -21,19 +21,46 @@ class StepManager:
         self.max_steps = max_steps
         self._last_running: dict[tuple, str] = {}
 
-    def _alloc_slot(self, task_id, context_id, kind, name) -> int:
+    def _alloc_slot(
+        self,
+        task_id: str | None,
+        context_id: str | None,
+        kind: str,
+        name: str,
+    ) -> int:
         k = (task_id, context_id, kind, name)
         self.slot_counter[k] = self.slot_counter.get(k, 0) + 1
         return self.slot_counter[k]
 
-    def _key(self, task_id, context_id, kind, name, slot) -> tuple:
+    def _key(
+        self,
+        task_id: str | None,
+        context_id: str | None,
+        kind: str,
+        name: str,
+        slot: int,
+    ) -> tuple[str | None, str | None, str, str, int]:
         return (task_id, context_id, kind, name, slot)
 
-    def _make_id(self, task_id, context_id, kind, name, slot) -> str:
+    def _make_id(
+        self,
+        task_id: str | None,
+        context_id: str | None,
+        kind: str,
+        name: str,
+        slot: int,
+    ) -> str:
         return f"{task_id or 't'}::{context_id or 'c'}::{kind}::{name}::{slot}"
 
     def start_or_get(
-        self, *, task_id, context_id, kind, name, parent_id=None, args=None
+        self,
+        *,
+        task_id: str | None,
+        context_id: str | None,
+        kind: str,
+        name: str,
+        parent_id: str | None = None,
+        args: dict[str, object] | None = None,
     ) -> Step:
         existing = self.find_running(
             task_id=task_id, context_id=context_id, kind=kind, name=name
@@ -64,44 +91,74 @@ class StepManager:
         self._last_running[(task_id, context_id, kind, name)] = step_id
         return st
 
-    def _prune_steps(self):
-        total = len(self.order) + sum(len(v) for v in self.children.values())
-        if total <= self.max_steps:
+    def _calculate_total_steps(self) -> int:
+        """Calculate total number of steps."""
+        return len(self.order) + sum(len(v) for v in self.children.values())
+
+    def _get_subtree_size(self, root_id: str) -> int:
+        """Get the size of a subtree (including root)."""
+        subtree = [root_id]
+        stack = list(self.children.get(root_id, []))
+        while stack:
+            x = stack.pop()
+            subtree.append(x)
+            stack.extend(self.children.get(x, []))
+        return len(subtree)
+
+    def _remove_subtree(self, root_id: str) -> None:
+        """Remove a complete subtree from all data structures."""
+        stack = [root_id]
+        to_remove = []
+        while stack:
+            sid = stack.pop()
+            to_remove.append(sid)
+            stack.extend(self.children.pop(sid, []))
+
+        for sid in to_remove:
+            st = self.by_id.pop(sid, None)
+            if st:
+                key = (st.task_id, st.context_id, st.kind, st.name)
+                self._last_running.pop(key, None)
+            for _parent, kids in list(self.children.items()):
+                if sid in kids:
+                    kids.remove(sid)
+            if sid in self.order:
+                self.order.remove(sid)
+
+    def _should_prune_steps(self, total: int) -> bool:
+        """Check if steps should be pruned."""
+        return total > self.max_steps
+
+    def _get_oldest_step_id(self) -> str | None:
+        """Get the oldest step ID for pruning."""
+        return self.order[0] if self.order else None
+
+    def _prune_steps(self) -> None:
+        """Prune steps when total exceeds maximum."""
+        total = self._calculate_total_steps()
+        if not self._should_prune_steps(total):
             return
 
-        def remove_subtree(root_id: str):
-            stack = [root_id]
-            to_remove = []
-            while stack:
-                sid = stack.pop()
-                to_remove.append(sid)
-                stack.extend(self.children.pop(sid, []))
-            for sid in to_remove:
-                st = self.by_id.pop(sid, None)
-                if st:
-                    key = (st.task_id, st.context_id, st.kind, st.name)
-                    self._last_running.pop(key, None)
-                for _parent, kids in list(self.children.items()):
-                    if sid in kids:
-                        kids.remove(sid)
-                if sid in self.order:
-                    self.order.remove(sid)
-
-        while total > self.max_steps and self.order:
-            sid = self.order[0]
-            subtree = [sid]
-            stack = list(self.children.get(sid, []))
-            while stack:
-                x = stack.pop()
-                subtree.append(x)
-                stack.extend(self.children.get(x, []))
-            total -= len(subtree)
-            remove_subtree(sid)
+        while self._should_prune_steps(total) and self.order:
+            sid = self._get_oldest_step_id()
+            if not sid:
+                break
+
+            subtree_size = self._get_subtree_size(sid)
+            self._remove_subtree(sid)
+            total -= subtree_size
 
     def get_child_count(self, step_id: str) -> int:
         return len(self.children.get(step_id, []))
 
-    def find_running(self, *, task_id, context_id, kind, name) -> Step | None:
+    def find_running(
+        self,
+        *,
+        task_id: str | None,
+        context_id: str | None,
+        kind: str,
+        name: str,
+    ) -> Step | None:
         key = (task_id, context_id, kind, name)
         step_id = self._last_running.get(key)
         if step_id:
@@ -125,8 +182,15 @@ class StepManager:
         return None
 
     def finish(
-        self, *, task_id, context_id, kind, name, output=None, duration_raw=None
-    ):
+        self,
+        *,
+        task_id: str | None,
+        context_id: str | None,
+        kind: str,
+        name: str,
+        output: object | None = None,
+        duration_raw: float | None = None,
+    ) -> Step:
         st = self.find_running(
             task_id=task_id, context_id=context_id, kind=kind, name=name
         )

glaip_sdk/utils/rich_utils.py

@@ -5,7 +5,7 @@ Authors:
 """
 
 
-def _check_rich_available():
+def _check_rich_available() -> bool:
     """Check if Rich is available by attempting imports."""
     try:
         import importlib.util

glaip_sdk/utils/run_renderer.py

@@ -35,7 +35,7 @@ __all__ = [
     "CapturingConsole",
     "RendererConfig",
     "RichStreamRenderer",
-    "render_debug_event",
     "RunStats",
     "StepManager",
+    "render_debug_event",
 ]

glaip_sdk/utils/serialization.py

@@ -92,7 +92,9 @@ def write_yaml(file_path: Path, data: dict[str, Any]) -> None:
     class LiteralString(str):
         pass
 
-    def literal_string_representer(dumper, data):
+    def literal_string_representer(
+        dumper: yaml.Dumper, data: "LiteralString"
+    ) -> yaml.nodes.Node:
         # Use literal block scalar (|) for multiline strings to preserve formatting
         if "\n" in data:
             return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")

glaip_sdk/utils/validation.py

@@ -55,8 +55,8 @@ def validate_agent_instruction(instruction: str) -> str:
 
     cleaned_instruction = instruction.strip()
 
-    if len(cleaned_instruction) > 10000:
-        raise ValueError("Agent instruction cannot be longer than 10,000 characters")
+    if len(cleaned_instruction) > 100000:
+        raise ValueError("Agent instruction cannot be longer than 100,000 characters")
 
     return cleaned_instruction