glaip-sdk 0.0.1b10__py3-none-any.whl → 0.0.3__py3-none-any.whl

glaip_sdk/client/__init__.py

@@ -5,6 +5,8 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+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
@@ -104,10 +106,18 @@ class Client(BaseClient):
         return tool
 
     def create_tool_from_code(
-        self, name: str, code: str, framework: str = "langchain"
+        self,
+        name: str,
+        code: str,
+        framework: str = "langchain",
+        *,
+        description: str | None = None,
+        tags: list[str] | None = None,
     ) -> Tool:
         """Create a new tool plugin from code string."""
-        tool = self.tools.create_tool_from_code(name, code, framework)
+        tool = self.tools.create_tool_from_code(
+            name, code, framework, description=description, tags=tags
+        )
         tool._set_client(self)
         return tool
 
@@ -119,6 +129,16 @@ class Client(BaseClient):
         """Delete a tool by ID."""
         return self.tools.delete_tool(tool_id)
 
+    def get_tool_script(self, tool_id: str) -> str:
+        """Get tool script content."""
+        return self.tools.get_tool_script(tool_id)
+
+    def update_tool_via_file(self, tool_id: str, file_path: str, **kwargs) -> Tool:
+        """Update a tool plugin via file upload."""
+        tool = self.tools.update_tool_via_file(tool_id, file_path, **kwargs)
+        tool._set_client(self)
+        return tool
+
     # ---- MCPs
     def list_mcps(self) -> list[MCP]:
         mcps = self.mcps.list_mcps()
@@ -150,6 +170,18 @@ class Client(BaseClient):
         """Update an MCP by ID."""
         return self.mcps.update_mcp(mcp_id, **kwargs)
 
+    def test_mcp_connection(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Test MCP connection using configuration."""
+        return self.mcps.test_mcp_connection(config)
+
+    def test_mcp_connection_from_config(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Test MCP connection using configuration (alias)."""
+        return self.mcps.test_mcp_connection_from_config(config)
+
+    def get_mcp_tools_from_config(self, config: dict[str, Any]) -> list[dict[str, Any]]:
+        """Fetch tools from MCP configuration without saving."""
+        return self.mcps.get_mcp_tools_from_config(config)
+
     def run_agent(self, agent_id: str, message: str, **kwargs) -> str:
         """Run an agent with a message."""
         return self.agents.run_agent(agent_id, message, **kwargs)
@@ -160,6 +192,26 @@ class Client(BaseClient):
         data = self._request("GET", "/language-models")
         return data or []
 
+    # ---- Timeout propagation ----
+    @property
+    def timeout(self) -> float:  # type: ignore[override]
+        return super().timeout
+
+    @timeout.setter
+    def timeout(self, value: float) -> None:  # type: ignore[override]
+        # Rebuild the root http client
+        BaseClient.timeout.fset(self, value)  # call parent setter
+        # Propagate the new session to sub-clients so they don't hold a closed client
+        try:
+            if hasattr(self, "agents"):
+                self.agents.http_client = self.http_client
+            if hasattr(self, "tools"):
+                self.tools.http_client = self.http_client
+            if hasattr(self, "mcps"):
+                self.mcps.http_client = self.http_client
+        except Exception:
+            pass
+
     # ---- Aliases (back-compat)
     def get_agent(self, agent_id: str) -> Agent:
         return self.get_agent_by_id(agent_id)

glaip_sdk/client/agents.py

@@ -7,46 +7,35 @@ 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
 
 # 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 +48,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 +65,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 +92,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 +115,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 +127,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 +154,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 +172,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 +187,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 +215,47 @@ 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:
+            # Default to a standard rich renderer
+            r = RichStreamRenderer(console=_Console())
 
         # Try to set some meta early; refine as we receive events
         meta = {
@@ -278,172 +271,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