glaip-sdk 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

glaip_sdk/client/main.py

@@ -42,6 +42,10 @@ class Client(BaseClient):
         """Create a new agent."""
         return self.agents.create_agent(**kwargs)
 
+    def create_agent_from_file(self, *args, **kwargs) -> Agent:
+        """Create a new agent from a JSON or YAML configuration file."""
+        return self.agents.create_agent_from_file(*args, **kwargs)
+
     def list_agents(
         self,
         agent_type: str | None = None,
@@ -86,6 +90,10 @@ class Client(BaseClient):
         """Update an existing agent."""
         return self.agents.update_agent(agent_id, **kwargs)
 
+    def update_agent_from_file(self, agent_id: str, *args, **kwargs) -> Agent:
+        """Update an existing agent using a JSON or YAML configuration file."""
+        return self.agents.update_agent_from_file(agent_id, *args, **kwargs)
+
     def delete_agent(self, agent_id: str) -> bool:
         """Delete an agent."""
         return self.agents.delete_agent(agent_id)
@@ -150,9 +158,9 @@ class Client(BaseClient):
         """Get tool script content."""
         return self.tools.get_tool_script(tool_id)
 
-    def update_tool_via_file(self, tool_id: str, file_path: str) -> Tool:
+    def update_tool_via_file(self, tool_id: str, file_path: str, **kwargs) -> Tool:
         """Update tool via file."""
-        return self.tools.update_tool_via_file(tool_id, file_path)
+        return self.tools.update_tool_via_file(tool_id, file_path, **kwargs)
 
     # MCPs
     def create_mcp(self, **kwargs) -> MCP:

glaip_sdk/client/tools.py

@@ -241,7 +241,15 @@ class ToolClient(BaseClient):
         self, update_data: dict[str, Any], kwargs: dict[str, Any]
     ) -> None:
         """Handle additional kwargs in update payload."""
-        excluded_keys = {"tags", "framework", "version"}
+        excluded_keys = {
+            "tags",
+            "framework",
+            "version",
+            "type",
+            "tool_type",
+            "name",
+            "description",
+        }
         for key, value in kwargs.items():
             if key not in excluded_keys:
                 update_data[key] = value
@@ -269,9 +277,19 @@ class ToolClient(BaseClient):
             - Handles metadata updates properly
         """
         # Prepare the update payload with current values as defaults
+        type_override = kwargs.pop("type", None)
+        if type_override is None:
+            type_override = kwargs.pop("tool_type", None)
+        current_type = (
+            type_override
+            or getattr(current_tool, "tool_type", None)
+            or getattr(current_tool, "type", None)
+            or DEFAULT_TOOL_TYPE
+        )
+
         update_data = {
             "name": name if name is not None else current_tool.name,
-            "type": DEFAULT_TOOL_TYPE,  # Required by backend
+            "type": current_type,
             "framework": kwargs.get(
                 "framework", getattr(current_tool, "framework", DEFAULT_TOOL_FRAMEWORK)
             ),
@@ -476,6 +494,19 @@ class ToolClient(BaseClient):
         # Validate file exists
         self._validate_and_read_file(file_path)
 
+        # Fetch current metadata to ensure required fields are preserved
+        current_tool = self.get_tool_by_id(tool_id)
+
+        payload_kwargs = kwargs.copy()
+        name = payload_kwargs.pop("name", None)
+        description = payload_kwargs.pop("description", None)
+        update_payload = self._build_update_payload(
+            current_tool=current_tool,
+            name=name,
+            description=description,
+            **payload_kwargs,
+        )
+
         try:
             # Prepare multipart upload
             with open(file_path, "rb") as fb:
@@ -491,7 +522,7 @@ class ToolClient(BaseClient):
                     "PUT",
                     TOOLS_UPLOAD_BY_ID_ENDPOINT_FMT.format(tool_id=tool_id),
                     files=files,
-                    data=kwargs,  # Pass kwargs directly as data
+                    data=update_payload,
                 )
 
             return Tool(**response)._set_client(self)

glaip_sdk/config/constants.py

@@ -5,7 +5,7 @@ Authors:
 """
 
 # Default language model configuration
-DEFAULT_MODEL = "gpt-4.1"
+DEFAULT_MODEL = "gpt-5-nano"
 DEFAULT_AGENT_RUN_TIMEOUT = 300
 
 # User agent and version

glaip_sdk/utils/agent_config.py

@@ -134,25 +134,51 @@ def normalize_agent_config_for_import(
     if not isinstance(agent_config, dict):
         return normalized_data
 
-    # Priority 1: CLI --model flag (highest priority)
+    # Apply normalization based on priority order
     if cli_model:
-        # When CLI model is specified, set it and don't extract from agent_config
-        normalized_data["model"] = cli_model
-        return normalized_data
+        return _apply_cli_model_override(normalized_data, cli_model)
 
-    # Priority 2: language_model_id already exists - clean up agent_config
     if normalized_data.get("language_model_id"):
-        # If language_model_id exists, we should still clean up any conflicting
-        # LM settings from agent_config to prevent backend validation errors
-        if isinstance(agent_config, dict):
-            # Remove LM identity keys from agent_config since language_model_id takes precedence
-            lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
-            for key in lm_keys_to_remove:
-                agent_config.pop(key, None)
-            normalized_data["agent_config"] = agent_config
+        return _cleanup_existing_language_model(normalized_data, agent_config)
+
+    return _extract_lm_from_agent_config(normalized_data, agent_config)
+
+
+def _apply_cli_model_override(normalized_data: dict, cli_model: str) -> dict:
+    """Apply CLI model override (highest priority)."""
+    normalized_data["model"] = cli_model
+    return normalized_data
+
+
+def _cleanup_existing_language_model(normalized_data: dict, agent_config: dict) -> dict:
+    """Clean up agent_config when language_model_id already exists."""
+    # Remove LM identity keys from agent_config since language_model_id takes precedence
+    lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
+    for key in lm_keys_to_remove:
+        agent_config.pop(key, None)
+    normalized_data["agent_config"] = agent_config
+    return normalized_data
+
+
+def _extract_lm_from_agent_config(normalized_data: dict, agent_config: dict) -> dict:
+    """Extract LM settings from agent_config (lowest priority)."""
+    extracted_lm = _extract_lm_settings(agent_config)
+
+    if not extracted_lm:
         return normalized_data
 
-    # Priority 3: Extract LM settings from agent_config
+    # Add extracted LM settings to top level
+    normalized_data.update(extracted_lm)
+
+    # Create sanitized agent_config (remove extracted LM settings but keep memory)
+    sanitized_config = _sanitize_agent_config(agent_config)
+    normalized_data["agent_config"] = sanitized_config
+
+    return normalized_data
+
+
+def _extract_lm_settings(agent_config: dict) -> dict[str, Any]:
+    """Extract LM settings from agent_config."""
     extracted_lm = {}
 
     # Extract lm_name if present
@@ -163,19 +189,16 @@ def normalize_agent_config_for_import(
     if "lm_provider" in agent_config:
         extracted_lm["lm_provider"] = agent_config["lm_provider"]
 
-    # If we extracted LM settings, update the normalized data
-    if extracted_lm:
-        # Add extracted LM settings to top level
-        normalized_data.update(extracted_lm)
+    return extracted_lm
 
-        # Create sanitized agent_config (remove extracted LM settings but keep memory)
-        sanitized_config = agent_config.copy()
 
-        # Remove LM identity keys but preserve memory and other settings
-        lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
-        for key in lm_keys_to_remove:
-            sanitized_config.pop(key, None)
+def _sanitize_agent_config(agent_config: dict) -> dict:
+    """Create sanitized agent_config by removing LM identity keys."""
+    sanitized_config = agent_config.copy()
 
-        normalized_data["agent_config"] = sanitized_config
+    # Remove LM identity keys but preserve memory and other settings
+    lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
+    for key in lm_keys_to_remove:
+        sanitized_config.pop(key, None)
 
-    return normalized_data
+    return sanitized_config

glaip_sdk/utils/rendering/formatting.py

@@ -57,41 +57,62 @@ def mask_secrets_in_string(text: str) -> str:
 def redact_sensitive(text: str | dict | list) -> str | dict | list:
     """Redact sensitive information in a string, dict, or list."""
     if isinstance(text, dict):
-        # Recursively process dictionary values
-        result = {}
-        for key, value in text.items():
-            # Check if the key itself is sensitive
-            key_lower = key.lower()
-            if any(
-                sensitive in key_lower
-                for sensitive in ["password", "secret", "token", "key", "api_key"]
-            ):
-                result[key] = "••••••"
-            elif isinstance(value, dict | list) or isinstance(value, str):
-                result[key] = redact_sensitive(value)
-            else:
-                result[key] = value
-        return result
+        return _redact_dict_values(text)
     elif isinstance(text, list):
-        # Recursively process list items
-        return [redact_sensitive(item) for item in text]
+        return _redact_list_items(text)
     elif isinstance(text, str):
-        # Process string - first mask secrets, then redact sensitive patterns
-        result = text
-        # First mask secrets
-        for pattern in SECRET_VALUE_PATTERNS:
-            result = re.sub(pattern, "••••••", result)
-        # Then redact sensitive patterns
-        result = re.sub(
-            SENSITIVE_PATTERNS,
-            lambda m: m.group(0).split("=")[0] + "=••••••",
-            result,
-        )
-        return result
+        return _redact_string_content(text)
     else:
         return text
 
 
+def _redact_dict_values(text: dict) -> dict:
+    """Recursively process dictionary values and redact sensitive keys."""
+    result = {}
+    for key, value in text.items():
+        if _is_sensitive_key(key):
+            result[key] = "••••••"
+        elif _should_recurse_redaction(value):
+            result[key] = redact_sensitive(value)
+        else:
+            result[key] = value
+    return result
+
+
+def _redact_list_items(text: list) -> list:
+    """Recursively process list items."""
+    return [redact_sensitive(item) for item in text]
+
+
+def _redact_string_content(text: str) -> str:
+    """Process string - first mask secrets, then redact sensitive patterns."""
+    result = text
+    # First mask secrets
+    for pattern in SECRET_VALUE_PATTERNS:
+        result = re.sub(pattern, "••••••", result)
+    # Then redact sensitive patterns
+    result = re.sub(
+        SENSITIVE_PATTERNS,
+        lambda m: m.group(0).split("=")[0] + "=••••••",
+        result,
+    )
+    return result
+
+
+def _is_sensitive_key(key: str) -> bool:
+    """Check if a key contains sensitive information."""
+    key_lower = key.lower()
+    return any(
+        sensitive in key_lower
+        for sensitive in ["password", "secret", "token", "key", "api_key"]
+    )
+
+
+def _should_recurse_redaction(value: Any) -> bool:
+    """Check if a value should be recursively processed."""
+    return isinstance(value, dict | list) or isinstance(value, str)
+
+
 def pretty_args(args: dict | None, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
     """Format arguments in a pretty way."""
     if not args:

glaip_sdk/utils/rendering/renderer/base.py

@@ -45,16 +45,21 @@ from glaip_sdk.utils.rendering.steps import StepManager
 # Configure logger
 logger = logging.getLogger("glaip_sdk.run_renderer")
 
+# Constants
+LESS_THAN_1MS = "[<1ms]"
+
 
 @dataclass
 class RendererState:
     """Internal state for the renderer."""
 
-    buffer: list[str] = None
+    buffer: list[str] | None = None
     final_text: str = ""
     streaming_started_at: float | None = None
     printed_final_panel: bool = False
     finalizing_ui: bool = False
+    final_duration_seconds: float | None = None
+    final_duration_text: str | None = None
 
     def __post_init__(self) -> None:
         """Initialize renderer state after dataclass creation.
@@ -212,59 +217,76 @@ class RichStreamRenderer:
 
         # Handle different event types
         if kind == "status":
-            # Status events
-            status = ev.get("status")
-            if status == "streaming_started":
-                self.state.streaming_started_at = monotonic()
-            return
-
+            self._handle_status_event(ev)
         elif kind == "content":
-            # Content streaming events
-            if content:
-                self.state.buffer.append(content)
-                self._ensure_live()
-            return
-
+            self._handle_content_event(content)
         elif kind == "final_response":
-            # Final response events
-            if content:
-                self.state.buffer.append(content)
-                self.state.final_text = content
-                self._ensure_live()
+            self._handle_final_response_event(content, metadata)
+        elif kind in {"agent_step", "agent_thinking_step"}:
+            self._handle_agent_step_event(ev)
+        else:
+            # Update live display for unhandled events
+            self._ensure_live()
 
-                # In verbose mode, show the final result in a panel
-                if self.verbose and content and content.strip():
-                    final_panel = create_final_panel(content, theme=self.cfg.theme)
-                    self.console.print(final_panel)
-                    self.state.printed_final_panel = True
-            return
+    def _handle_status_event(self, ev: dict[str, Any]) -> None:
+        """Handle status events."""
+        status = ev.get("status")
+        if status == "streaming_started":
+            self.state.streaming_started_at = monotonic()
 
-        elif kind in {"agent_step", "agent_thinking_step"}:
-            # Agent step events
-            # Note: Thinking gaps are primarily a visual aid. Keep minimal here.
-
-            # Extract tool information
-            (
-                tool_name,
-                tool_args,
-                tool_out,
-                tool_calls_info,
-            ) = self.stream_processor.parse_tool_calls(ev)
-
-            # Track tools and sub-agents
-            self.stream_processor.track_tools_and_agents(
-                tool_name, tool_calls_info, is_delegation_tool
-            )
+    def _handle_content_event(self, content: str) -> None:
+        """Handle content streaming events."""
+        if content:
+            self.state.buffer.append(content)
+            self._ensure_live()
+
+    def _handle_final_response_event(
+        self, content: str, metadata: dict[str, Any]
+    ) -> None:
+        """Handle final response events."""
+        if content:
+            self.state.buffer.append(content)
+            self.state.final_text = content
 
-            # Handle tool execution
-            self._handle_agent_step(ev, tool_name, tool_args, tool_out, tool_calls_info)
+            meta_payload = metadata.get("metadata") or {}
+            self._update_final_duration(meta_payload.get("time"))
+
+            self._ensure_live()
+
+            # In verbose mode, show the final result in a panel
+            if self.verbose and content.strip():
+                final_panel = create_final_panel(
+                    content,
+                    title=self._final_panel_title(),
+                    theme=self.cfg.theme,
+                )
+                self.console.print(final_panel)
+                self.state.printed_final_panel = True
+
+    def _handle_agent_step_event(self, ev: dict[str, Any]) -> None:
+        """Handle agent step events."""
+        # Extract tool information
+        (
+            tool_name,
+            tool_args,
+            tool_out,
+            tool_calls_info,
+        ) = self.stream_processor.parse_tool_calls(ev)
+
+        # Track tools and sub-agents
+        self.stream_processor.track_tools_and_agents(
+            tool_name, tool_calls_info, is_delegation_tool
+        )
+
+        # Handle tool execution
+        self._handle_agent_step(ev, tool_name, tool_args, tool_out, tool_calls_info)
 
         # Update live display
         self._ensure_live()
 
     def _finish_running_steps(self) -> None:
         """Mark any running steps as finished to avoid lingering spinners."""
-        for st in list(self.steps.by_id.values()):
+        for st in self.steps.by_id.values():
             if not is_step_finished(st):
                 st.finish(None)
 
@@ -289,14 +311,31 @@ class RichStreamRenderer:
         if self.verbose and not self.state.printed_final_panel:
             body = ("".join(self.state.buffer) or "").strip()
             if body:
-                final_panel = create_final_panel(body, theme=self.cfg.theme)
+                final_panel = create_final_panel(
+                    body,
+                    title=self._final_panel_title(),
+                    theme=self.cfg.theme,
+                )
                 self.console.print(final_panel)
                 self.state.printed_final_panel = True
 
-    def on_complete(self, _stats: RunStats) -> None:
+    def on_complete(self, stats: RunStats) -> None:
         """Handle completion event."""
         self.state.finalizing_ui = True
 
+        if isinstance(stats, RunStats):
+            duration = None
+            try:
+                if stats.finished_at is not None and stats.started_at is not None:
+                    duration = max(
+                        0.0, float(stats.finished_at) - float(stats.started_at)
+                    )
+            except Exception:
+                duration = None
+
+            if duration is not None:
+                self._update_final_duration(duration, overwrite=True)
+
         # Mark any running steps as finished to avoid lingering spinners
         self._finish_running_steps()
 
@@ -394,15 +433,23 @@ class RichStreamRenderer:
         if not self.verbose:
             final_content = (self.state.final_text or "").strip()
             if final_content:
+                title = self._final_panel_title()
                 return create_final_panel(
                     final_content,
-                    title="Final Result",
+                    title=title,
                     theme=self.cfg.theme,
                 )
         # Dynamic title with spinner + elapsed/hints
         title = self._format_enhanced_main_title()
         return create_main_panel(body, title, self.cfg.theme)
 
+    def _final_panel_title(self) -> str:
+        """Compose title for the final result panel including duration."""
+        title = "Final Result"
+        if self.state.final_duration_text:
+            title = f"{title} · {self.state.final_duration_text}"
+        return title
+
     def apply_verbosity(self, verbose: bool) -> None:
         """Update verbose behaviour at runtime."""
         if self.verbose == verbose:
@@ -507,27 +554,43 @@ class RichStreamRenderer:
         """Process additional tool calls to avoid duplicates."""
         for call_name, call_args, _ in tool_calls_info or []:
             if call_name and call_name != tool_name:
-                self._ensure_tool_panel(call_name, call_args, task_id, context_id)
-                if is_delegation_tool(call_name):
-                    st2 = self.steps.start_or_get(
-                        task_id=task_id,
-                        context_id=context_id,
-                        kind="delegate",
-                        name=call_name,
-                        args=call_args,
-                    )
-                else:
-                    st2 = self.steps.start_or_get(
-                        task_id=task_id,
-                        context_id=context_id,
-                        kind="tool",
-                        name=call_name,
-                        args=call_args,
-                    )
-                if self.stream_processor.server_elapsed_time is not None and st2:
-                    self._step_server_start_times[st2.step_id] = (
-                        self.stream_processor.server_elapsed_time
-                    )
+                self._process_single_tool_call(
+                    call_name, call_args, task_id, context_id
+                )
+
+    def _process_single_tool_call(
+        self, call_name: str, call_args: Any, task_id: str, context_id: str
+    ) -> None:
+        """Process a single additional tool call."""
+        self._ensure_tool_panel(call_name, call_args, task_id, context_id)
+
+        st2 = self._create_step_for_tool_call(call_name, call_args, task_id, context_id)
+
+        if self.stream_processor.server_elapsed_time is not None and st2:
+            self._step_server_start_times[st2.step_id] = (
+                self.stream_processor.server_elapsed_time
+            )
+
+    def _create_step_for_tool_call(
+        self, call_name: str, call_args: Any, task_id: str, context_id: str
+    ) -> Any:
+        """Create appropriate step for tool call."""
+        if is_delegation_tool(call_name):
+            return self.steps.start_or_get(
+                task_id=task_id,
+                context_id=context_id,
+                kind="delegate",
+                name=call_name,
+                args=call_args,
+            )
+        else:
+            return self.steps.start_or_get(
+                task_id=task_id,
+                context_id=context_id,
+                kind="tool",
+                name=call_name,
+                args=call_args,
+            )
 
     def _detect_tool_completion(
         self, metadata: dict, content: str
@@ -941,19 +1004,19 @@ class RichStreamRenderer:
         """Format step status with elapsed time or duration."""
         if is_step_finished(step):
             if step.duration_ms is None:
-                return "[<1ms]"
+                return LESS_THAN_1MS
             elif step.duration_ms >= 1000:
                 return f"[{step.duration_ms / 1000:.2f}s]"
             elif step.duration_ms > 0:
                 return f"[{step.duration_ms}ms]"
-            return "[<1ms]"
+            return LESS_THAN_1MS
         else:
             # Calculate elapsed time for running steps
             elapsed = self._calculate_step_elapsed_time(step)
             if elapsed >= 1:
                 return f"[{elapsed:.2f}s]"
             ms = int(elapsed * 1000)
-            return f"[{ms}ms]" if ms > 0 else "[<1ms]"
+            return f"[{ms}ms]" if ms > 0 else LESS_THAN_1MS
 
     def _calculate_step_elapsed_time(self, step: Step) -> float:
         """Calculate elapsed time for a running step."""
@@ -1024,6 +1087,29 @@ class RichStreamRenderer:
             and sid not in self.stream_processor.current_event_finished_panels
         )
 
+    def _update_final_duration(
+        self, duration: float | None, *, overwrite: bool = False
+    ) -> None:
+        """Store formatted duration for eventual final panels."""
+        if duration is None:
+            return
+
+        try:
+            duration_val = max(0.0, float(duration))
+        except Exception:
+            return
+
+        existing = self.state.final_duration_seconds
+
+        if not overwrite and existing is not None:
+            return
+
+        if overwrite and existing is not None:
+            duration_val = max(existing, duration_val)
+
+        self.state.final_duration_seconds = duration_val
+        self.state.final_duration_text = self._format_elapsed_time(duration_val)
+
     def _calculate_elapsed_time(self, meta: dict[str, Any]) -> str:
         """Calculate elapsed time string for running tools."""
         server_elapsed = self.stream_processor.server_elapsed_time

{glaip_sdk-0.0.16.dist-info → glaip_sdk-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.0.16
+Version: 0.0.18
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher
@@ -22,7 +22,7 @@ Requires-Dist: readchar (>=4.2.1,<5.0.0)
 Requires-Dist: rich (>=13.0.0)
 Description-Content-Type: text/markdown
 
-# GL AIP SDK — GDP Labs AI Agents Package
+# GL AIP — GDP Labs AI Agents Package
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)