glaip-sdk 0.6.12__py3-none-any.whl → 0.6.14__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/thinking.py

@@ -1,273 +0,0 @@
-"""Thinking scope controller used by the renderer.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-from time import monotonic
-from typing import Any
-
-from glaip_sdk.utils.rendering.formatting import is_step_finished
-from glaip_sdk.utils.rendering.models import Step
-from glaip_sdk.utils.rendering.state import ThinkingScopeState
-from glaip_sdk.utils.rendering.steps import StepManager
-from glaip_sdk.utils.rendering.timing import calculate_timeline_duration, coerce_server_time
-
-FINISHED_STATUS_HINTS = {
-    "finished",
-    "success",
-    "succeeded",
-    "completed",
-    "failed",
-    "stopped",
-    "error",
-}
-
-
-class ThinkingScopeController:
-    """Encapsulates deterministic thinking bookkeeping for the renderer."""
-
-    def __init__(self, steps: StepManager, *, step_server_start_times: dict[str, float]) -> None:
-        """Initialize the thinking scope controller.
-
-        Args:
-            steps: Step manager instance for tracking steps
-            step_server_start_times: Dictionary mapping step IDs to server start times
-        """
-        self._steps = steps
-        self._step_server_start_times = step_server_start_times
-        self._scopes: dict[str, ThinkingScopeState] = {}
-
-    def update_timeline(self, step: Step | None, payload: dict[str, Any], *, enabled: bool) -> None:
-        """Update thinking spans for a streamed step event."""
-        if not enabled or not step:
-            return
-
-        now_monotonic = monotonic()
-        server_time = coerce_server_time(payload.get("time"))
-        status_hint = (payload.get("status") or "").lower()
-
-        if self._is_scope_anchor(step):
-            self._update_anchor_thinking(
-                step=step,
-                server_time=server_time,
-                status_hint=status_hint,
-                now_monotonic=now_monotonic,
-            )
-            return
-
-        self._update_child_thinking(
-            step=step,
-            server_time=server_time,
-            status_hint=status_hint,
-            now_monotonic=now_monotonic,
-        )
-
-    def close_active_scopes(self, server_time: float | None) -> None:
-        """Finish any in-flight thinking nodes during finalization."""
-        now = monotonic()
-        for scope in self._scopes.values():
-            if not scope.active_thinking_id:
-                continue
-            self._finish_scope_thinking(scope, server_time, now)
-
-    # ------------------------------------------------------------------
-    # Internal helpers mirroring the previous renderer implementation.
-    # ------------------------------------------------------------------
-    def _update_anchor_thinking(
-        self,
-        *,
-        step: Step,
-        server_time: float | None,
-        status_hint: str,
-        now_monotonic: float,
-    ) -> None:
-        scope = self._get_or_create_scope(step)
-        if scope.anchor_started_at is None and server_time is not None:
-            scope.anchor_started_at = server_time
-
-        if not scope.closed and scope.active_thinking_id is None:
-            self._start_scope_thinking(
-                scope,
-                start_server_time=scope.anchor_started_at or server_time,
-                start_monotonic=now_monotonic,
-            )
-
-        is_anchor_finished = status_hint in FINISHED_STATUS_HINTS or (not status_hint and is_step_finished(step))
-        if is_anchor_finished:
-            scope.anchor_finished_at = server_time or scope.anchor_finished_at
-            self._finish_scope_thinking(scope, server_time, now_monotonic)
-            scope.closed = True
-
-        parent_anchor_id = self._resolve_anchor_id(step)
-        if parent_anchor_id:
-            self._cascade_anchor_update(
-                parent_anchor_id=parent_anchor_id,
-                child_step=step,
-                server_time=server_time,
-                now_monotonic=now_monotonic,
-                is_finished=is_anchor_finished,
-            )
-
-    def _cascade_anchor_update(
-        self,
-        *,
-        parent_anchor_id: str,
-        child_step: Step,
-        server_time: float | None,
-        now_monotonic: float,
-        is_finished: bool,
-    ) -> None:
-        parent_scope = self._scopes.get(parent_anchor_id)
-        if not parent_scope or parent_scope.closed:
-            return
-        if is_finished:
-            self._mark_child_finished(parent_scope, child_step.step_id, server_time, now_monotonic)
-        else:
-            self._mark_child_running(parent_scope, child_step, server_time, now_monotonic)
-
-    def _update_child_thinking(
-        self,
-        *,
-        step: Step,
-        server_time: float | None,
-        status_hint: str,
-        now_monotonic: float,
-    ) -> None:
-        anchor_id = self._resolve_anchor_id(step)
-        if not anchor_id:
-            return
-
-        scope = self._scopes.get(anchor_id)
-        if not scope or scope.closed or step.kind == "thinking":
-            return
-
-        is_finish_event = status_hint in FINISHED_STATUS_HINTS or (not status_hint and is_step_finished(step))
-        if is_finish_event:
-            self._mark_child_finished(scope, step.step_id, server_time, now_monotonic)
-        else:
-            self._mark_child_running(scope, step, server_time, now_monotonic)
-
-    def _resolve_anchor_id(self, step: Step) -> str | None:
-        parent_id = step.parent_id
-        while parent_id:
-            parent = self._steps.by_id.get(parent_id)
-            if not parent:
-                return None
-            if self._is_scope_anchor(parent):
-                return parent.step_id
-            parent_id = parent.parent_id
-        return None
-
-    def _get_or_create_scope(self, step: Step) -> ThinkingScopeState:
-        scope = self._scopes.get(step.step_id)
-        if scope:
-            if scope.task_id is None:
-                scope.task_id = step.task_id
-            if scope.context_id is None:
-                scope.context_id = step.context_id
-            return scope
-        scope = ThinkingScopeState(
-            anchor_id=step.step_id,
-            task_id=step.task_id,
-            context_id=step.context_id,
-        )
-        self._scopes[step.step_id] = scope
-        return scope
-
-    def _is_scope_anchor(self, step: Step) -> bool:
-        if step.kind in {"agent", "delegate"}:
-            return True
-        name = (step.name or "").lower()
-        return name.startswith(("delegate_to_", "delegate_", "delegate "))
-
-    def _start_scope_thinking(
-        self,
-        scope: ThinkingScopeState,
-        *,
-        start_server_time: float | None,
-        start_monotonic: float,
-    ) -> None:
-        if scope.closed or scope.active_thinking_id or not scope.anchor_id:
-            return
-        step = self._steps.start_or_get(
-            task_id=scope.task_id,
-            context_id=scope.context_id,
-            kind="thinking",
-            name=f"agent_thinking_step::{scope.anchor_id}",
-            parent_id=scope.anchor_id,
-            args={"reason": "deterministic_timeline"},
-        )
-        step.display_label = "💭 Thinking…"
-        scope.active_thinking_id = step.step_id
-        scope.idle_started_at = start_server_time
-        scope.idle_started_monotonic = start_monotonic
-
-    def _finish_scope_thinking(
-        self,
-        scope: ThinkingScopeState,
-        end_server_time: float | None,
-        end_monotonic: float,
-    ) -> None:
-        if not scope.active_thinking_id:
-            return
-        thinking_step = self._steps.by_id.get(scope.active_thinking_id)
-        if not thinking_step:
-            scope.active_thinking_id = None
-            scope.idle_started_at = None
-            scope.idle_started_monotonic = None
-            return
-
-        duration = calculate_timeline_duration(
-            scope.idle_started_at,
-            end_server_time,
-            scope.idle_started_monotonic,
-            end_monotonic,
-        )
-        thinking_step.display_label = thinking_step.display_label or "💭 Thinking…"
-        if duration is not None:
-            thinking_step.finish(duration, source="timeline")
-        else:
-            thinking_step.finish(None, source="timeline")
-        scope.active_thinking_id = None
-        scope.idle_started_at = None
-        scope.idle_started_monotonic = None
-
-    def _mark_child_running(
-        self,
-        scope: ThinkingScopeState,
-        step: Step,
-        server_time: float | None,
-        now_monotonic: float,
-    ) -> None:
-        if step.step_id in scope.running_children:
-            return
-        scope.running_children.add(step.step_id)
-        if not scope.active_thinking_id:
-            return
-
-        start_server = self._step_server_start_times.get(step.step_id)
-        if start_server is None:
-            start_server = server_time
-        self._finish_scope_thinking(scope, start_server, now_monotonic)
-
-    def _mark_child_finished(
-        self,
-        scope: ThinkingScopeState,
-        step_id: str,
-        server_time: float | None,
-        now_monotonic: float,
-    ) -> None:
-        scope.running_children.discard(step_id)
-        if scope.active_thinking_id or scope.closed or scope.running_children:
-            return
-        self._start_scope_thinking(
-            scope,
-            start_server_time=server_time,
-            start_monotonic=now_monotonic,
-        )
-
-
-__all__ = ["ThinkingScopeController", "FINISHED_STATUS_HINTS"]

glaip_sdk/utils/rendering/renderer/toggle.py

@@ -1,182 +0,0 @@
-"""Keyboard-driven transcript toggling support for the live renderer.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import threading
-import time
-from typing import Any
-
-try:  # pragma: no cover - Windows-specific dependencies
-    import msvcrt  # type: ignore[import]
-except ImportError:  # pragma: no cover - POSIX fallback
-    msvcrt = None  # type: ignore[assignment]
-
-if os.name != "nt":  # pragma: no cover - POSIX-only imports
-    import select
-    import termios
-    import tty
-
-
-CTRL_T = "\x14"
-
-
-class TranscriptToggleController:
-    """Manage mid-run transcript toggling for RichStreamRenderer instances."""
-
-    def __init__(self, *, enabled: bool) -> None:
-        """Initialise controller.
-
-        Args:
-            enabled: Whether toggling should be active (usually gated by TTY checks).
-        """
-        self._enabled = enabled and bool(sys.stdin) and sys.stdin.isatty()
-        self._lock = threading.Lock()
-        self._posix_fd: int | None = None
-        self._posix_attrs: list[int] | None = None
-        self._active = False
-        self._stop_event = threading.Event()
-        self._poll_thread: threading.Thread | None = None
-
-    @property
-    def enabled(self) -> bool:
-        """Return True when controller is able to process keypresses."""
-        return self._enabled
-
-    def on_stream_start(self, renderer: Any) -> None:
-        """Prepare terminal state before streaming begins."""
-        if not self._enabled:
-            return
-
-        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
-            self._active = True
-            self._start_polling_thread(renderer)
-            return
-
-        fd = sys.stdin.fileno()
-        try:
-            attrs = termios.tcgetattr(fd)
-        except Exception:
-            self._enabled = False
-            return
-
-        try:
-            tty.setcbreak(fd)
-        except Exception:
-            try:
-                termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
-            except Exception:
-                pass
-            self._enabled = False
-            return
-
-        with self._lock:
-            self._posix_fd = fd
-            self._posix_attrs = attrs
-            self._active = True
-
-        self._start_polling_thread(renderer)
-
-    def on_stream_complete(self) -> None:
-        """Restore terminal state when streaming ends."""
-        if not self._active:
-            return
-
-        self._stop_polling_thread()
-
-        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
-            self._active = False
-            return
-
-        with self._lock:
-            fd = self._posix_fd
-            attrs = self._posix_attrs
-            self._posix_fd = None
-            self._posix_attrs = None
-            self._active = False
-
-        if fd is None or attrs is None:
-            return
-
-        try:
-            termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
-        except Exception:
-            pass
-
-    def poll(self, renderer: Any) -> None:
-        """Poll for toggle keypresses and update renderer if needed."""
-        if not self._active:
-            return
-
-        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
-            self._poll_windows(renderer)
-        else:
-            self._poll_posix(renderer)
-
-    # ------------------------------------------------------------------
-    # Platform-specific polling
-    # ------------------------------------------------------------------
-    def _poll_windows(self, renderer: Any) -> None:
-        if not msvcrt:  # pragma: no cover - safety guard
-            return
-
-        while msvcrt.kbhit():
-            ch = msvcrt.getwch()
-            if ch == CTRL_T:
-                renderer.toggle_transcript_mode()
-
-    def _poll_posix(self, renderer: Any) -> None:  # pragma: no cover - requires TTY
-        fd = self._posix_fd
-        if fd is None:
-            return
-
-        while True:
-            readable, _, _ = select.select([fd], [], [], 0)
-            if not readable:
-                return
-
-            try:
-                data = os.read(fd, 1)
-            except Exception:
-                return
-
-            if not data:
-                return
-
-            ch = data.decode(errors="ignore")
-            if ch == CTRL_T:
-                renderer.toggle_transcript_mode()
-
-    def _start_polling_thread(self, renderer: Any) -> None:
-        if self._poll_thread and self._poll_thread.is_alive():
-            return
-        if not self._active:
-            return
-
-        self._stop_event.clear()
-        self._poll_thread = threading.Thread(target=self._poll_loop, args=(renderer,), daemon=True)
-        self._poll_thread.start()
-
-    def _stop_polling_thread(self) -> None:
-        self._stop_event.set()
-        thread = self._poll_thread
-        if thread and thread.is_alive():
-            thread.join(timeout=0.2)
-        self._poll_thread = None
-
-    def _poll_loop(self, renderer: Any) -> None:
-        while self._active and not self._stop_event.is_set():
-            try:
-                if os.name == "nt":
-                    self._poll_windows(renderer)
-                else:
-                    self._poll_posix(renderer)
-            except Exception:
-                # Never let background polling disrupt the main stream
-                pass
-            time.sleep(0.05)