glaip-sdk 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

glaip_sdk/client/agents.py

@@ -5,9 +5,11 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+import asyncio
 import json
 import logging
 from collections.abc import AsyncGenerator, Callable, Iterator, Mapping
+from contextlib import asynccontextmanager
 from os import PathLike
 from pathlib import Path
 from typing import Any, BinaryIO
@@ -20,14 +22,17 @@ from glaip_sdk.client._agent_payloads import (
     AgentListResult,
     AgentUpdateRequest,
 )
+from glaip_sdk.client.agent_runs import AgentRunsClient
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.client.mcps import MCPClient
 from glaip_sdk.client.run_rendering import (
     AgentRunRenderingManager,
     compute_timeout_seconds,
 )
+from glaip_sdk.client.shared import build_shared_config
 from glaip_sdk.client.tools import ToolClient
 from glaip_sdk.config.constants import (
+    AGENT_CONFIG_FIELDS,
     DEFAULT_AGENT_FRAMEWORK,
     DEFAULT_AGENT_RUN_TIMEOUT,
     DEFAULT_AGENT_TYPE,
@@ -67,6 +72,19 @@ _MERGED_SEQUENCE_FIELDS = ("tools", "agents", "mcps")
 _DEFAULT_METADATA_TYPE = "custom"
 
 
+@asynccontextmanager
+async def _async_timeout_guard(timeout_seconds: float | None) -> AsyncGenerator[None, None]:
+    """Apply an asyncio timeout when a custom timeout is provided."""
+    if timeout_seconds is None:
+        yield
+        return
+    try:
+        async with asyncio.timeout(timeout_seconds):
+            yield
+    except asyncio.TimeoutError as exc:
+        raise httpx.TimeoutException(f"Request timed out after {timeout_seconds}s") from exc
+
+
 def _normalise_sequence(value: Any) -> list[Any] | None:
     """Normalise optional sequence inputs to plain lists."""
     if value is None:
@@ -193,19 +211,7 @@ def _extract_original_refs(raw_definition: dict) -> dict[str, list]:
 
 def _build_cli_args(overrides_dict: dict) -> dict[str, Any]:
     """Build CLI args from overrides, filtering out None values."""
-    cli_args = {
-        key: overrides_dict.get(key)
-        for key in (
-            "name",
-            "instruction",
-            "model",
-            "tools",
-            "agents",
-            "mcps",
-            "timeout",
-        )
-        if overrides_dict.get(key) is not None
-    }
+    cli_args = {key: overrides_dict.get(key) for key in AGENT_CONFIG_FIELDS if overrides_dict.get(key) is not None}
 
     # Normalize sequence fields
     for field in _MERGED_SEQUENCE_FIELDS:
@@ -254,6 +260,7 @@ class AgentClient(BaseClient):
         self._renderer_manager = AgentRunRenderingManager(logger)
         self._tool_client: ToolClient | None = None
         self._mcp_client: MCPClient | None = None
+        self._runs_client: "AgentRunsClient | None" = None
 
     def list_agents(
         self,
@@ -1172,7 +1179,7 @@ class AgentClient(BaseClient):
         message: str,
         files: list[str | BinaryIO] | None = None,
         *,
-        timeout: float | None = None,
+        request_timeout: float | None = None,
         **kwargs,
     ) -> AsyncGenerator[dict, None]:
         """Async run an agent with a message, yielding streaming JSON chunks.
@@ -1181,7 +1188,7 @@ class AgentClient(BaseClient):
             agent_id: ID of the agent to run
             message: Message to send to the agent
             files: Optional list of files to include
-            timeout: Request timeout in seconds
+            request_timeout: Optional request timeout in seconds (defaults to client timeout)
             **kwargs: Additional arguments (chat_history, pii_mapping, etc.)
 
         Yields:
@@ -1192,18 +1199,22 @@ class AgentClient(BaseClient):
             httpx.TimeoutException: When general timeout occurs
             Exception: For other unexpected errors
         """
+        # Derive timeout values for request/control flow
+        legacy_timeout = kwargs.get("timeout")
+        http_timeout_override = request_timeout if request_timeout is not None else legacy_timeout
+        http_timeout = http_timeout_override or self.timeout
+
         # Prepare request data
         payload, data_payload, files_payload, headers = self._prepare_request_data(message, files, **kwargs)
 
         # Create async client configuration
-        async_client_config = self._create_async_client_config(timeout, headers)
+        async_client_config = self._create_async_client_config(http_timeout_override, headers)
 
         # Get execution timeout for streaming control
         timeout_seconds = kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
         agent_name = kwargs.get("agent_name")
 
-        try:
-            # Create async client and stream response
+        async def _chunk_stream() -> AsyncGenerator[dict, None]:
             async with httpx.AsyncClient(**async_client_config) as async_client:
                 async for chunk in self._stream_agent_response(
                     async_client,
@@ -1217,7 +1228,14 @@ class AgentClient(BaseClient):
                 ):
                     yield chunk
 
-        finally:
-            # Ensure cleanup - this is handled by the calling context
-            # but we keep this for safety in case of future changes
-            pass
+        async with _async_timeout_guard(http_timeout):
+            async for chunk in _chunk_stream():
+                yield chunk
+
+    @property
+    def runs(self) -> "AgentRunsClient":
+        """Get the agent runs client."""
+        if self._runs_client is None:
+            shared_config = build_shared_config(self)
+            self._runs_client = AgentRunsClient(**shared_config)
+        return self._runs_client

glaip_sdk/client/main.py

@@ -10,6 +10,7 @@ from typing import Any
 from glaip_sdk.client.agents import AgentClient
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.client.mcps import MCPClient
+from glaip_sdk.client.shared import build_shared_config
 from glaip_sdk.client.tools import ToolClient
 from glaip_sdk.models import MCP, Agent, Tool
 
@@ -25,12 +26,7 @@ class Client(BaseClient):
         """
         super().__init__(**kwargs)
         # Share the single httpx.Client + config with sub-clients
-        shared_config = {
-            "parent_client": self,
-            "api_url": self.api_url,
-            "api_key": self.api_key,
-            "timeout": self._timeout,
-        }
+        shared_config = build_shared_config(self)
         self.agents = AgentClient(**shared_config)
         self.tools = ToolClient(**shared_config)
         self.mcps = MCPClient(**shared_config)

glaip_sdk/client/mcps.py

@@ -14,7 +14,7 @@ from glaip_sdk.config.constants import (
     DEFAULT_MCP_TYPE,
 )
 from glaip_sdk.models import MCP
-from glaip_sdk.utils.client_utils import create_model_instances, find_by_name
+from glaip_sdk.utils.client_utils import add_kwargs_to_payload, create_model_instances, find_by_name
 
 # API endpoints
 MCPS_ENDPOINT = "/mcps/"
@@ -147,9 +147,7 @@ class MCPClient(BaseClient):
 
         # Add any other kwargs (excluding already handled ones)
         excluded_keys = {"type"}  # type is handled above
-        for key, value in kwargs.items():
-            if key not in excluded_keys:
-                payload[key] = value
+        add_kwargs_to_payload(payload, kwargs, excluded_keys)
 
         return payload
 
@@ -206,7 +204,17 @@ class MCPClient(BaseClient):
     def get_mcp_tools(self, mcp_id: str) -> list[dict[str, Any]]:
         """Get tools available from an MCP."""
         data = self._request("GET", f"{MCPS_ENDPOINT}{mcp_id}/tools")
-        return data or []
+        if data is None:
+            return []
+        if isinstance(data, list):
+            return data
+        if isinstance(data, dict):
+            if "tools" in data:
+                return data.get("tools", []) or []
+            logger.warning("Unexpected MCP tools response keys %s; returning empty list", list(data.keys()))
+            return []
+        logger.warning("Unexpected MCP tools response type %s; returning empty list", type(data).__name__)
+        return []
 
     def test_mcp_connection(self, config: dict[str, Any]) -> dict[str, Any]:
         """Test MCP connection using configuration.

glaip_sdk/client/run_rendering.py

@@ -7,9 +7,9 @@ Authors:
 
 from __future__ import annotations
 
-import io
 import json
 import logging
+from collections.abc import Callable
 from time import monotonic
 from typing import Any
 
@@ -19,8 +19,17 @@ from rich.console import Console as _Console
 from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
 from glaip_sdk.utils.client_utils import iter_sse_events
 from glaip_sdk.utils.rendering.models import RunStats
-from glaip_sdk.utils.rendering.renderer import RichStreamRenderer
-from glaip_sdk.utils.rendering.renderer.config import RendererConfig
+from glaip_sdk.utils.rendering.renderer import (
+    RendererFactoryOptions,
+    RichStreamRenderer,
+    make_default_renderer,
+    make_minimal_renderer,
+    make_silent_renderer,
+    make_verbose_renderer,
+)
+from glaip_sdk.utils.rendering.state import TranscriptBuffer
+
+NO_AGENT_RESPONSE_FALLBACK = "No agent response received."
 
 
 def _coerce_to_string(value: Any) -> str:
@@ -36,41 +45,6 @@ def _has_visible_text(value: Any) -> bool:
     return isinstance(value, str) and bool(value.strip())
 
 
-def _update_state_transcript(state: Any, text_value: str) -> bool:
-    """Inject transcript text into renderer state if possible."""
-    if state is None:
-        return False
-
-    updated = False
-
-    if hasattr(state, "final_text") and not _has_visible_text(getattr(state, "final_text", "")):
-        try:
-            state.final_text = text_value
-            updated = True
-        except Exception:
-            pass
-
-    buffer = getattr(state, "buffer", None)
-    if isinstance(buffer, list) and not any(_has_visible_text(item) for item in buffer):
-        buffer.append(text_value)
-        updated = True
-
-    return updated
-
-
-def _update_renderer_transcript(renderer: Any, text_value: str) -> None:
-    """Populate the renderer (or its state) with the supplied text."""
-    state = getattr(renderer, "state", None)
-    if _update_state_transcript(state, text_value):
-        return
-
-    if hasattr(renderer, "final_text") and not _has_visible_text(getattr(renderer, "final_text", "")):
-        try:
-            renderer.final_text = text_value
-        except Exception:
-            pass
-
-
 class AgentRunRenderingManager:
     """Coordinate renderer creation and streaming event handling."""
 
@@ -81,6 +55,7 @@ class AgentRunRenderingManager:
             logger: Optional logger instance, creates default if None
         """
         self._logger = logger or logging.getLogger(__name__)
+        self._buffer_factory = TranscriptBuffer
 
     # --------------------------------------------------------------------- #
     # Renderer setup helpers
@@ -92,17 +67,38 @@ class AgentRunRenderingManager:
         verbose: bool = False,
     ) -> RichStreamRenderer:
         """Create an appropriate renderer based on the supplied spec."""
+        transcript_buffer = self._buffer_factory()
+        base_options = RendererFactoryOptions(console=_Console(), transcript_buffer=transcript_buffer)
         if isinstance(renderer_spec, RichStreamRenderer):
             return renderer_spec
 
         if isinstance(renderer_spec, str):
-            if renderer_spec == "silent":
-                return self._create_silent_renderer()
-            if renderer_spec == "minimal":
-                return self._create_minimal_renderer()
-            return self._create_default_renderer(verbose)
+            lowered = renderer_spec.lower()
+            if lowered == "silent":
+                return self._attach_buffer(base_options.build(make_silent_renderer), transcript_buffer)
+            if lowered == "minimal":
+                return self._attach_buffer(base_options.build(make_minimal_renderer), transcript_buffer)
+            if lowered == "verbose":
+                return self._attach_buffer(base_options.build(make_verbose_renderer), transcript_buffer)
+
+        if verbose:
+            return self._attach_buffer(base_options.build(make_verbose_renderer), transcript_buffer)
 
-        return self._create_default_renderer(verbose)
+        default_options = RendererFactoryOptions(
+            console=_Console(),
+            transcript_buffer=transcript_buffer,
+            verbose=verbose,
+        )
+        return self._attach_buffer(default_options.build(make_default_renderer), transcript_buffer)
+
+    @staticmethod
+    def _attach_buffer(renderer: RichStreamRenderer, buffer: TranscriptBuffer) -> RichStreamRenderer:
+        """Attach a captured transcript buffer to a renderer for later inspection."""
+        try:
+            renderer._captured_transcript_buffer = buffer  # type: ignore[attr-defined]
+        except Exception:
+            pass
+        return renderer
 
     def build_initial_metadata(
         self,
@@ -123,70 +119,6 @@ class AgentRunRenderingManager:
         """Notify renderer that streaming is starting."""
         renderer.on_start(meta)
 
-    def _create_silent_renderer(self) -> RichStreamRenderer:
-        """Create a silent renderer that outputs to a string buffer.
-
-        Returns:
-            RichStreamRenderer configured for silent output.
-        """
-        silent_config = RendererConfig(
-            live=False,
-            persist_live=False,
-            render_thinking=False,
-        )
-        return RichStreamRenderer(
-            console=_Console(file=io.StringIO(), force_terminal=False),
-            cfg=silent_config,
-            verbose=False,
-        )
-
-    def _create_minimal_renderer(self) -> RichStreamRenderer:
-        """Create a minimal renderer with reduced output.
-
-        Returns:
-            RichStreamRenderer configured for minimal output.
-        """
-        minimal_config = RendererConfig(
-            live=False,
-            persist_live=False,
-            render_thinking=False,
-        )
-        return RichStreamRenderer(
-            console=_Console(),
-            cfg=minimal_config,
-            verbose=False,
-        )
-
-    def _create_verbose_renderer(self) -> RichStreamRenderer:
-        """Create a verbose renderer with detailed output.
-
-        Returns:
-            RichStreamRenderer configured for verbose output.
-        """
-        verbose_config = RendererConfig(
-            live=False,
-            append_finished_snapshots=False,
-        )
-        return RichStreamRenderer(
-            console=_Console(),
-            cfg=verbose_config,
-            verbose=True,
-        )
-
-    def _create_default_renderer(self, verbose: bool) -> RichStreamRenderer:
-        """Create the default renderer based on verbosity.
-
-        Args:
-            verbose: Whether to create a verbose renderer.
-
-        Returns:
-            RichStreamRenderer instance.
-        """
-        if verbose:
-            return self._create_verbose_renderer()
-        default_config = RendererConfig()
-        return RichStreamRenderer(console=_Console(), cfg=default_config)
-
     # --------------------------------------------------------------------- #
     # Streaming event handling
     # --------------------------------------------------------------------- #
@@ -382,7 +314,52 @@ class AgentRunRenderingManager:
             return
 
         text_value = _coerce_to_string(text)
-        _update_renderer_transcript(renderer, text_value)
+        state = getattr(renderer, "state", None)
+        if state is None:
+            self._ensure_renderer_text(renderer, text_value)
+            return
+
+        self._ensure_state_final_text(state, text_value)
+        self._ensure_state_buffer(state, text_value)
+
+    def _ensure_renderer_text(self, renderer: RichStreamRenderer, text_value: str) -> None:
+        """Best-effort assignment for renderer.final_text."""
+        if not hasattr(renderer, "final_text"):
+            return
+        current_text = getattr(renderer, "final_text", "")
+        if _has_visible_text(current_text):
+            return
+        self._safe_set_attr(renderer, "final_text", text_value)
+
+    def _ensure_state_final_text(self, state: Any, text_value: str) -> None:
+        """Best-effort assignment for renderer.state.final_text."""
+        current_text = getattr(state, "final_text", "")
+        if _has_visible_text(current_text):
+            return
+        self._safe_set_attr(state, "final_text", text_value)
+
+    def _ensure_state_buffer(self, state: Any, text_value: str) -> None:
+        """Append fallback text to the state buffer when available."""
+        buffer = getattr(state, "buffer", None)
+        if not hasattr(buffer, "append"):
+            return
+        self._safe_append(buffer.append, text_value)
+
+    @staticmethod
+    def _safe_set_attr(target: Any, attr: str, value: str) -> None:
+        """Assign attribute while masking renderer-specific failures."""
+        try:
+            setattr(target, attr, value)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _safe_append(appender: Callable[[str], Any], value: str) -> None:
+        """Invoke append-like functions without leaking renderer errors."""
+        try:
+            appender(value)
+        except Exception:
+            pass
 
     # --------------------------------------------------------------------- #
     # Finalisation helpers
@@ -409,7 +386,9 @@ class AgentRunRenderingManager:
         elif hasattr(renderer, "buffer"):
             buffer_values = renderer.buffer
 
-        if buffer_values is not None:
+        if isinstance(buffer_values, TranscriptBuffer):
+            rendered_text = buffer_values.render()
+        elif buffer_values is not None:
             try:
                 rendered_text = "".join(buffer_values)
             except TypeError:
@@ -420,7 +399,7 @@ class AgentRunRenderingManager:
             self._ensure_renderer_final_content(renderer, fallback_text)
 
         renderer.on_complete(st)
-        return final_text or rendered_text or "No response content received."
+        return final_text or rendered_text or NO_AGENT_RESPONSE_FALLBACK
 
 
 def compute_timeout_seconds(kwargs: dict[str, Any]) -> float:

glaip_sdk/client/shared.py

@@ -0,0 +1,21 @@
+"""Shared helpers for client configuration wiring.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from glaip_sdk.client.base import BaseClient
+
+
+def build_shared_config(client: BaseClient) -> dict[str, Any]:
+    """Return the keyword arguments used to initialize sub-clients."""
+    return {
+        "parent_client": client,
+        "api_url": client.api_url,
+        "api_key": client.api_key,
+        "timeout": client._timeout,
+    }

glaip_sdk/client/tools.py

@@ -18,6 +18,7 @@ from glaip_sdk.config.constants import (
 )
 from glaip_sdk.models import Tool
 from glaip_sdk.utils.client_utils import (
+    add_kwargs_to_payload,
     create_model_instances,
     find_by_name,
 )
@@ -200,9 +201,7 @@ class ToolClient(BaseClient):
 
         # Add any other kwargs (excluding already handled ones)
         excluded_keys = {"tags", "version"}
-        for key, value in kwargs.items():
-            if key not in excluded_keys:
-                payload[key] = value
+        add_kwargs_to_payload(payload, kwargs, excluded_keys)
 
         return payload
 

glaip_sdk/config/constants.py

@@ -39,3 +39,14 @@ DEFAULT_MCP_TRANSPORT = "stdio"
 
 # Default error messages
 DEFAULT_ERROR_MESSAGE = "Unknown error"
+
+# Agent configuration fields used for CLI args and payload building
+AGENT_CONFIG_FIELDS = (
+    "name",
+    "instruction",
+    "model",
+    "tools",
+    "agents",
+    "mcps",
+    "timeout",
+)

glaip_sdk/models/__init__.py

@@ -0,0 +1,56 @@
+"""Models package for AIP SDK.
+
+This package re-exports models from the legacy models.py file for backward compatibility.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+# Export new agent runs models first (no dependencies on legacy models)
+from glaip_sdk.models.agent_runs import (  # noqa: F401
+    RunOutputChunk,
+    RunSummary,
+    RunsPage,
+    RunWithOutput,
+)
+
+# Import from the parent models.py file
+_parent_file = Path(__file__).parent.parent / "models.py"
+if _parent_file.exists():
+    spec = importlib.util.spec_from_file_location("glaip_sdk.models_legacy", _parent_file)
+    models_legacy = importlib.util.module_from_spec(spec)
+    sys.modules["glaip_sdk.models_legacy"] = models_legacy
+    spec.loader.exec_module(models_legacy)
+
+    # Re-export all models
+    Agent = models_legacy.Agent
+    Tool = models_legacy.Tool
+    MCP = models_legacy.MCP
+    LanguageModelResponse = models_legacy.LanguageModelResponse
+    TTYRenderer = models_legacy.TTYRenderer
+else:
+    # Fallback: try direct import (won't work if models/ exists)
+    # pragma: no cover - defensive fallback path, unlikely to execute
+    from glaip_sdk import models as models_legacy  # type: ignore  # pragma: no cover
+
+    Agent = models_legacy.Agent  # pragma: no cover
+    Tool = models_legacy.Tool  # pragma: no cover
+    MCP = models_legacy.MCP  # pragma: no cover
+    LanguageModelResponse = models_legacy.LanguageModelResponse  # pragma: no cover
+    TTYRenderer = models_legacy.TTYRenderer  # pragma: no cover
+
+__all__ = [
+    "Agent",
+    "Tool",
+    "MCP",
+    "LanguageModelResponse",
+    "TTYRenderer",
+    "RunSummary",
+    "RunsPage",
+    "RunWithOutput",
+    "RunOutputChunk",
+]