glaip-sdk 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

glaip_sdk/client/agents.py

@@ -7,46 +7,36 @@ Authors:
 
 import json
 import logging
-import sys
+from time import monotonic
 from typing import Any, BinaryIO
 
-import httpx
-from rich.console import Console
+from rich.console import Console as _Console
 
 from glaip_sdk.client.base import BaseClient
+from glaip_sdk.config.constants import (
+    DEFAULT_AGENT_FRAMEWORK,
+    DEFAULT_AGENT_PROVIDER,
+    DEFAULT_AGENT_RUN_TIMEOUT,
+    DEFAULT_AGENT_TYPE,
+    DEFAULT_AGENT_VERSION,
+    DEFAULT_MODEL,
+)
 from glaip_sdk.models import Agent
-from glaip_sdk.utils.run_renderer import (
-    RichStreamRenderer,
+from glaip_sdk.utils.client_utils import (
+    create_model_instances,
+    extract_ids,
+    find_by_name,
+    iter_sse_events,
+    prepare_multipart_data,
 )
+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
 
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.agents")
 
 
-def _select_renderer(
-    renderer: RichStreamRenderer | str | None, *, verbose: bool = False
-) -> RichStreamRenderer:
-    """Select the appropriate renderer based on input."""
-    if isinstance(renderer, RichStreamRenderer):
-        return renderer
-
-    console = Console(file=sys.stdout, force_terminal=sys.stdout.isatty())
-
-    if renderer in (None, "auto"):
-        return RichStreamRenderer(console=console, verbose=verbose)
-    if renderer == "json":
-        # JSON output is handled by the renderer itself
-        return RichStreamRenderer(console=console, verbose=verbose)
-    if renderer == "markdown":
-        # Markdown output is handled by the renderer itself
-        return RichStreamRenderer(console=console, verbose=verbose)
-    if renderer == "plain":
-        # Plain output is handled by the renderer itself
-        return RichStreamRenderer(console=console, verbose=verbose)
-
-    raise ValueError(f"Unknown renderer: {renderer}")
-
-
 class AgentClient(BaseClient):
     """Client for agent operations."""
 
@@ -59,27 +49,10 @@ class AgentClient(BaseClient):
         """
         super().__init__(parent_client=parent_client, **kwargs)
 
-    def _extract_ids(self, items: list[str | Any] | None) -> list[str] | None:
-        """Extract IDs from a list of objects or strings."""
-        if not items:
-            return None
-
-        ids = []
-        for item in items:
-            if isinstance(item, str):
-                ids.append(item)
-            elif hasattr(item, "id"):
-                ids.append(item.id)
-            else:
-                # Fallback: convert to string
-                ids.append(str(item))
-
-        return ids
-
     def list_agents(self) -> list[Agent]:
         """List all agents."""
         data = self._request("GET", "/agents/")
-        return [Agent(**agent_data)._set_client(self) for agent_data in (data or [])]
+        return create_model_instances(data, Agent, self)
 
     def get_agent_by_id(self, agent_id: str) -> Agent:
         """Get agent by ID."""
@@ -93,16 +66,19 @@ class AgentClient(BaseClient):
             params["name"] = name
 
         data = self._request("GET", "/agents/", params=params)
-        return [Agent(**agent_data)._set_client(self) for agent_data in (data or [])]
+        agents = create_model_instances(data, Agent, self)
+        if name is None:
+            return agents
+        return find_by_name(agents, name, case_sensitive=False)
 
     def create_agent(
         self,
         name: str,
         instruction: str,
-        model: str = "gpt-4.1",
+        model: str = DEFAULT_MODEL,
         tools: list[str | Any] | None = None,
         agents: list[str | Any] | None = None,
-        timeout: int = 300,
+        timeout: int = DEFAULT_AGENT_RUN_TIMEOUT,
         **kwargs,
     ) -> "Agent":
         """Create a new agent."""
@@ -117,16 +93,20 @@ class AgentClient(BaseClient):
             raise ValueError("Agent instruction must be at least 10 characters long")
 
         # Prepare the creation payload
-        payload = {
+        payload: dict[str, Any] = {
             "name": name.strip(),
             "instruction": instruction.strip(),
-            "type": "config",
-            "framework": "langchain",
-            "version": "1.0",
-            "provider": "openai",
-            "model_name": model or "gpt-4.1",  # Ensure model_name is never None
+            "type": DEFAULT_AGENT_TYPE,
+            "framework": DEFAULT_AGENT_FRAMEWORK,
+            "version": DEFAULT_AGENT_VERSION,
+            "provider": DEFAULT_AGENT_PROVIDER,
+            "model_name": model or DEFAULT_MODEL,  # Ensure model_name is never None
         }
 
+        # Include default execution timeout if provided
+        if timeout is not None:
+            payload["timeout"] = str(timeout)
+
         # Ensure minimum required metadata for visibility
         if "metadata" not in kwargs:
             kwargs["metadata"] = {}
@@ -136,8 +116,8 @@ class AgentClient(BaseClient):
             kwargs["metadata"]["type"] = "custom"
 
         # Extract IDs from tool and agent objects
-        tool_ids = self._extract_ids(tools)
-        agent_ids = self._extract_ids(agents)
+        tool_ids = extract_ids(tools)
+        agent_ids = extract_ids(agents)
 
         # Add tools and agents if provided
         if tool_ids:
@@ -148,16 +128,13 @@ class AgentClient(BaseClient):
         # Add any additional kwargs
         payload.update(kwargs)
 
-        # Create the agent
-        data = self._request("POST", "/agents/", json=payload)
-
-        # The backend only returns the ID, so we need to fetch the full agent details
-        agent_id = data.get("id")
-        if not agent_id:
-            raise ValueError("Backend did not return agent ID")
-
-        # Fetch the full agent details
-        full_agent_data = self._request("GET", f"/agents/{agent_id}")
+        # Create the agent and fetch full details
+        full_agent_data = self._post_then_fetch(
+            id_key="id",
+            post_endpoint="/agents/",
+            get_endpoint_fmt="/agents/{id}",
+            json=payload,
+        )
         return Agent(**full_agent_data)._set_client(self)
 
     def update_agent(
@@ -178,14 +155,14 @@ class AgentClient(BaseClient):
             "instruction": instruction
             if instruction is not None
             else current_agent.instruction,
-            "type": "config",  # Required by backend
-            "framework": "langchain",  # Required by backend
-            "version": "1.0",  # Required by backend
+            "type": DEFAULT_AGENT_TYPE,  # Required by backend
+            "framework": DEFAULT_AGENT_FRAMEWORK,  # Required by backend
+            "version": DEFAULT_AGENT_VERSION,  # Required by backend
         }
 
         # Handle model specification
         if model is not None:
-            update_data["provider"] = "openai"  # Default provider
+            update_data["provider"] = DEFAULT_AGENT_PROVIDER  # Default provider
             update_data["model_name"] = model
         else:
             # Use current model if available
@@ -196,12 +173,12 @@ class AgentClient(BaseClient):
                     update_data["model_name"] = current_agent.agent_config["lm_name"]
             else:
                 # Default values
-                update_data["provider"] = "openai"
-                update_data["model_name"] = "gpt-4.1"
+                update_data["provider"] = DEFAULT_AGENT_PROVIDER
+                update_data["model_name"] = DEFAULT_MODEL
 
         # Handle tools and agents
         if "tools" in kwargs:
-            tool_ids = self._extract_ids(kwargs["tools"])
+            tool_ids = extract_ids(kwargs["tools"])
             if tool_ids:
                 update_data["tools"] = tool_ids
         elif current_agent.tools:
@@ -211,7 +188,7 @@ class AgentClient(BaseClient):
             ]
 
         if "agents" in kwargs:
-            agent_ids = self._extract_ids(kwargs["agents"])
+            agent_ids = extract_ids(kwargs["agents"])
             if agent_ids:
                 update_data["agents"] = agent_ids
         elif current_agent.agents:
@@ -239,30 +216,67 @@ class AgentClient(BaseClient):
         message: str,
         files: list[str | BinaryIO] | None = None,
         tty: bool = False,
-        stream: bool = True,
         *,
         renderer: RichStreamRenderer | str | None = "auto",
-        verbose: bool = False,
         **kwargs,
     ) -> str:
         """Run an agent with a message, streaming via a renderer."""
         # Prepare multipart data if files are provided
-        form_data = None
-        headers = {}
+        multipart_data = None
+        headers = None  # None means "don't override client defaults"
+
+        if files:
+            multipart_data = prepare_multipart_data(message, files)
+            # Inject optional multipart extras expected by backend
+            if "chat_history" in kwargs and kwargs["chat_history"] is not None:
+                multipart_data.data["chat_history"] = kwargs["chat_history"]
+            if "pii_mapping" in kwargs and kwargs["pii_mapping"] is not None:
+                multipart_data.data["pii_mapping"] = kwargs["pii_mapping"]
+            headers = None  # Let httpx set proper multipart boundaries
+
+        # When streaming, explicitly prefer SSE
+        headers = {**(headers or {}), "Accept": "text/event-stream"}
 
         if files:
-            form_data = self._prepare_multipart_data(message, files)
-            headers["Content-Type"] = "multipart/form-data"
             payload = None
+            # Use multipart data
+            data_payload = multipart_data.data
+            files_payload = multipart_data.files
         else:
             payload = {"input": message, **kwargs}
             if tty:
                 payload["tty"] = True
-            if not stream:
-                payload["stream"] = False
-
-        # Choose renderer (even if stream=False, we can still format final)
-        r = _select_renderer(renderer, verbose=verbose)
+            # Explicitly send stream intent both ways
+            payload["stream"] = True
+            data_payload = None
+            files_payload = None
+
+        # Choose renderer: use provided instance or create a default
+        if isinstance(renderer, RichStreamRenderer):
+            r = renderer
+        else:
+            # Check if verbose mode is requested
+            verbose = kwargs.get("verbose", False)
+            if verbose:
+                # Create a verbose renderer similar to CLI --verbose
+                verbose_config = RendererConfig(
+                    theme="dark",
+                    style="debug",  # CLI uses "debug" style for verbose
+                    live=False,  # CLI disables live updates for verbose
+                    show_delegate_tool_panels=True,  # CLI always shows tool panels
+                    append_finished_snapshots=False,
+                )
+                r = RichStreamRenderer(
+                    console=_Console(),
+                    cfg=verbose_config,
+                    verbose=True,
+                )
+            else:
+                # Default to a standard rich renderer with tool panels enabled
+                default_config = RendererConfig(
+                    show_delegate_tool_panels=True,  # Enable tool panels by default
+                )
+                r = RichStreamRenderer(console=_Console(), cfg=default_config)
 
         # Try to set some meta early; refine as we receive events
         meta = {
@@ -278,172 +292,117 @@ class AgentClient(BaseClient):
         started_monotonic = None
         finished_monotonic = None
 
-        with self.http_client.stream(
-            "POST",
-            f"/agents/{agent_id}/run",
-            json=payload if not files else None,
-            data=form_data.get("data") if files else None,
-            files=form_data.get("files") if files else None,
-            headers=headers,
-        ) as response:
-            response.raise_for_status()
-
-            # capture request id if provided
-            req_id = response.headers.get("x-request-id") or response.headers.get(
-                "x-run-id"
+        # MultipartData handles file cleanup automatically
+
+        try:
+            response = self.http_client.stream(
+                "POST",
+                f"/agents/{agent_id}/run",
+                json=payload,
+                data=data_payload,
+                files=files_payload,
+                headers=headers,
             )
-            if req_id:
-                meta["run_id"] = req_id
-                r.on_start(meta)  # refresh header with run_id
-
-            for event in self._iter_sse_events(response):
-                try:
-                    ev = json.loads(event["data"])
-                except json.JSONDecodeError:
-                    logger.debug("Non-JSON SSE fragment skipped")
-                    continue
-
-                # Start timer at first meaningful event
-                if started_monotonic is None and (
-                    "content" in ev or "status" in ev or ev.get("metadata")
-                ):
-                    from time import monotonic
 
-                    started_monotonic = monotonic()
+            with response as stream_response:
+                stream_response.raise_for_status()
 
-                kind = (ev.get("metadata") or {}).get("kind")
+                # capture request id if provided
+                req_id = stream_response.headers.get(
+                    "x-request-id"
+                ) or stream_response.headers.get("x-run-id")
+                if req_id:
+                    meta["run_id"] = req_id
+                    r.on_start(meta)  # refresh header with run_id
 
-                # Hide "artifact" chatter
-                if kind == "artifact":
-                    continue
+                # Get agent run timeout for execution control
+                # Prefer CLI-provided timeout, otherwise use default
+                timeout_seconds = kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
 
-                # Accumulate assistant content, but do not print here
-                if "content" in ev and ev["content"]:
-                    # Filter weird backend text like "Artifact received: ..."
-                    if not ev["content"].startswith("Artifact received:"):
-                        final_text = ev["content"]  # replace with latest
-                    r.on_event(ev)
-                    continue
+                agent_name = kwargs.get("agent_name")
 
-                # Step / tool events
-                if kind == "agent_step":
-                    r.on_event(ev)
-                    continue
+                for event in iter_sse_events(
+                    stream_response, timeout_seconds, agent_name
+                ):
+                    try:
+                        ev = json.loads(event["data"])
+                    except json.JSONDecodeError:
+                        logger.debug("Non-JSON SSE fragment skipped")
+                        continue
 
-                # Statuses: forward to renderer (it decides to collapse)
-                if "status" in ev:
-                    r.on_event(ev)
-                    continue
+                    # Start timer at first meaningful event
+                    if started_monotonic is None and (
+                        "content" in ev or "status" in ev or ev.get("metadata")
+                    ):
+                        started_monotonic = monotonic()
 
-                # Usage/cost event (if your backend emits it)
-                if kind == "usage":
-                    stats_usage.update(ev.get("usage") or {})
-                    continue
+                    kind = (ev.get("metadata") or {}).get("kind")
 
-                # Model/run info (if emitted mid-stream)
-                if kind == "run_info":
-                    if ev.get("model"):
-                        meta["model"] = ev["model"]
-                        r.on_start(meta)
-                    if ev.get("run_id"):
-                        meta["run_id"] = ev["run_id"]
-                        r.on_start(meta)
+                    # Pass event to the renderer (always, don't filter)
+                    r.on_event(ev)
 
-            from time import monotonic
+                    # Hide "artifact" chatter from content accumulation only
+                    if kind == "artifact":
+                        continue
+
+                    # Accumulate assistant content, but do not print here
+                    if "content" in ev and ev["content"]:
+                        # Filter weird backend text like "Artifact received: ..."
+                        if not ev["content"].startswith("Artifact received:"):
+                            final_text = ev["content"]  # replace with latest
+                        continue
+
+                    # Also treat final_response like content for CLI return value
+                    if kind == "final_response" and ev.get("content"):
+                        final_text = ev["content"]  # ensure CLI non-empty
+                        continue
+
+                    # Usage/cost event (if your backend emits it)
+                    if kind == "usage":
+                        stats_usage.update(ev.get("usage") or {})
+                        continue
+
+                    # Model/run info (if emitted mid-stream)
+                    if kind == "run_info":
+                        if ev.get("model"):
+                            meta["model"] = ev["model"]
+                            r.on_start(meta)
+                        if ev.get("run_id"):
+                            meta["run_id"] = ev["run_id"]
+                            r.on_start(meta)
 
             finished_monotonic = monotonic()
+        except KeyboardInterrupt:
+            try:
+                r.close()
+            finally:
+                raise
+        except Exception:
+            try:
+                r.close()
+            finally:
+                raise
+        finally:
+            # Ensure we close any opened file handles from multipart
+            if multipart_data:
+                multipart_data.close()
 
         # Finalize stats
-        from glaip_sdk.utils.run_renderer import RunStats
-
         st = RunStats()
+        # Ensure monotonic order (avoid negative -0.0s)
+        if started_monotonic is None:
+            started_monotonic = finished_monotonic
+
         st.started_at = started_monotonic or st.started_at
         st.finished_at = finished_monotonic or st.started_at
         st.usage = stats_usage
 
-        r.on_complete(final_text or "No response content received.", st)
-        return final_text or "No response content received."
-
-    def _iter_sse_events(self, response: httpx.Response):
-        """Iterate over Server-Sent Events with proper parsing."""
-        buf = []
-        event_type = None
-        event_id = None
-
-        for raw in response.iter_lines():
-            line = raw.decode("utf-8") if isinstance(raw, bytes) else raw
-
-            if line == "":
-                if buf:
-                    data = "\n".join(buf)
-                    yield {
-                        "event": event_type or "message",
-                        "id": event_id,
-                        "data": data,
-                    }
-                    buf, event_type, event_id = [], None, None
-                continue
-
-            if line.startswith(":"):  # comment
-                continue
-            if line.startswith("data:"):
-                buf.append(line[5:].lstrip())
-            elif line.startswith("event:"):
-                event_type = line[6:].strip() or None
-            elif line.startswith("id:"):
-                event_id = line[3:].strip() or None
-
-        # Flush any remaining data
-        if buf:
-            yield {
-                "event": event_type or "message",
-                "id": event_id,
-                "data": "\n".join(buf),
-            }
-
-    def _prepare_multipart_data(
-        self, message: str, files: list[str | BinaryIO]
-    ) -> dict[str, Any]:
-        """Prepare multipart form data for file uploads."""
-        from pathlib import Path
-
-        form_data = {"data": {"message": message}}
-        file_list = []
-
-        for file_item in files:
-            if isinstance(file_item, str):
-                # File path - let httpx stream the file handle
-                file_path = Path(file_item)
-                if not file_path.exists():
-                    raise FileNotFoundError(f"File not found: {file_item}")
-
-                file_list.append(
-                    (
-                        "files",
-                        (
-                            file_path.name,
-                            open(file_path, "rb"),
-                            "application/octet-stream",
-                        ),
-                    )
-                )
-            else:
-                # File-like object
-                if hasattr(file_item, "name"):
-                    filename = getattr(file_item, "name", "file")
-                else:
-                    filename = "file"
-
-                if hasattr(file_item, "read"):
-                    # For file-like objects, we need to read them since httpx expects bytes
-                    file_content = file_item.read()
-                    file_list.append(
-                        ("files", (filename, file_content, "application/octet-stream"))
-                    )
-                else:
-                    raise ValueError(f"Invalid file object: {file_item}")
-
-        if file_list:
-            form_data["files"] = file_list
-
-        return form_data
+        # Prefer explicit content, otherwise fall back to what the renderer saw
+        if hasattr(r, "state") and hasattr(r.state, "buffer"):
+            rendered_text = "".join(r.state.buffer)
+        else:
+            rendered_text = ""
+        final_payload = final_text or rendered_text or "No response content received."
+
+        r.on_complete(st)
+        return final_payload

glaip_sdk/client/base.py

@@ -12,6 +12,7 @@ from typing import Any, Union
 import httpx
 from dotenv import load_dotenv
 
+from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
 from glaip_sdk.exceptions import (
     AuthenticationError,
     ConflictError,
@@ -82,7 +83,15 @@ class BaseClient:
 
     def _build_client(self, timeout: float) -> httpx.Client:
         """Build HTTP client with configuration."""
-        from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
+        # For streaming operations, we need more generous read timeouts
+        # while keeping reasonable connect timeouts
+        timeout_config = httpx.Timeout(
+            timeout=timeout,  # Total timeout
+            connect=min(30.0, timeout),  # Connect timeout (max 30s)
+            read=timeout,  # Read timeout (same as total for streaming)
+            write=min(30.0, timeout),  # Write timeout (max 30s)
+            pool=timeout,  # Pool timeout (same as total)
+        )
 
         return httpx.Client(
             base_url=self.api_url,
@@ -90,7 +99,7 @@ class BaseClient:
                 "X-API-Key": self.api_key,
                 "User-Agent": f"{SDK_NAME}/{SDK_VERSION}",
             },
-            timeout=httpx.Timeout(timeout),
+            timeout=timeout_config,
             follow_redirects=True,
             http2=False,
             limits=httpx.Limits(max_keepalive_connections=10, max_connections=100),
@@ -113,6 +122,57 @@ class BaseClient:
             self.http_client.close()
             self.http_client = self._build_client(value)
 
+    def _post_then_fetch(
+        self,
+        id_key: str,
+        post_endpoint: str,
+        get_endpoint_fmt: str,
+        *,
+        json=None,
+        data=None,
+        files=None,
+        **kwargs,
+    ) -> Any:
+        """Helper for POST-then-GET pattern used in create methods.
+
+        Args:
+            id_key: Key in POST response containing the ID
+            post_endpoint: Endpoint for POST request
+            get_endpoint_fmt: Format string for GET endpoint (e.g., "/items/{id}")
+            json: JSON data for POST
+            data: Form data for POST
+            files: Files for POST
+            **kwargs: Additional kwargs for POST
+
+        Returns:
+            Full resource data from GET request
+        """
+        # Create the resource
+        post_kwargs = {}
+        if json is not None:
+            post_kwargs["json"] = json
+        if data is not None:
+            post_kwargs["data"] = data
+        if files is not None:
+            post_kwargs["files"] = files
+        post_kwargs.update(kwargs)
+
+        response_data = self._request("POST", post_endpoint, **post_kwargs)
+
+        # Extract the ID
+        if isinstance(response_data, dict):
+            resource_id = response_data.get(id_key)
+        else:
+            # Fallback: assume response_data is the ID directly
+            resource_id = str(response_data)
+
+        if not resource_id:
+            raise ValueError(f"Backend did not return {id_key}")
+
+        # Fetch the full resource details
+        get_endpoint = get_endpoint_fmt.format(id=resource_id)
+        return self._request("GET", get_endpoint)
+
     def _request(self, method: str, endpoint: str, **kwargs) -> Any:
         """Make HTTP request with error handling."""
         client_log.debug(f"Making {method} request to {endpoint}")