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

glaip_sdk/cli/slash/prompt.py

@@ -194,28 +194,43 @@ def _iter_command_completions(
     prefix = text[1:]
     seen: set[str] = set()
 
-    if (
-        session.get_contextual_commands()
-        and not session.should_include_global_commands()
-    ):
+    # Early return for contextual commands scenario
+    if not _should_include_commands(session):
         return []
 
     commands = sorted(session._unique_commands.values(), key=lambda c: c.name)
 
     for cmd in commands:
-        for alias in (cmd.name, *cmd.aliases):
-            if alias in seen or alias.startswith("?"):
-                continue
-            if prefix and not alias.startswith(prefix):
-                continue
-            seen.add(alias)
-            label = f"/{alias}"
-            yield Completion(
-                text=label,
-                start_position=-len(text),
-                display=label,
-                display_meta=cmd.help,
-            )
+        yield from _generate_command_completions(cmd, prefix, text, seen)
+
+
+def _should_include_commands(session: SlashSession) -> bool:
+    """Check if commands should be included in completions."""
+    return not (
+        session.get_contextual_commands()
+        and not session.should_include_global_commands()
+    )
+
+
+def _generate_command_completions(
+    cmd: Any, prefix: str, text: str, seen: set[str]
+) -> Iterable[Completion]:
+    """Generate completion items for a single command."""
+    for alias in (cmd.name, *cmd.aliases):
+        if alias in seen or alias.startswith("?"):
+            continue
+
+        if prefix and not alias.startswith(prefix):
+            continue
+
+        seen.add(alias)
+        label = f"/{alias}"
+        yield Completion(
+            text=label,
+            start_position=-len(text),
+            display=label,
+            display_meta=cmd.help,
+        )
 
 
 def _iter_contextual_completions(

glaip_sdk/cli/slash/session.py

@@ -297,51 +297,80 @@ class SlashSession:
         return True
 
     def _cmd_agents(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        client = self._get_client_or_fail()
+        if not client:
+            return True
+
+        agents = self._get_agents_or_fail(client)
+        if not agents:
+            return True
+
+        picked_agent = self._resolve_or_pick_agent(client, agents, args)
+
+        if not picked_agent:
+            return True
+
+        return self._run_agent_session(picked_agent)
+
+    def _get_client_or_fail(self) -> Any:
+        """Get client or handle failure and return None."""
         try:
-            client = self._get_client()
+            return self._get_client()
         except click.ClickException as exc:
             self.console.print(f"[red]{exc}[/red]")
-            return True
+            return None
 
+    def _get_agents_or_fail(self, client: Any) -> list:
+        """Get agents list or handle failure and return empty list."""
         try:
             agents = client.list_agents()
+            if not agents:
+                self._handle_no_agents()
+            return agents
         except Exception as exc:  # pragma: no cover - API failures
             self.console.print(f"[red]Failed to load agents: {exc}[/red]")
-            return True
+            return []
 
-        if not agents:
-            hint = command_hint("agents create", slash_command=None, ctx=self.ctx)
-            if hint:
-                self.console.print(
-                    f"[yellow]No agents available. Use `{hint}` to add one.[/yellow]"
-                )
-            else:
-                self.console.print("[yellow]No agents available.[/yellow]")
-            return True
+    def _handle_no_agents(self) -> None:
+        """Handle case when no agents are available."""
+        hint = command_hint("agents create", slash_command=None, ctx=self.ctx)
+        if hint:
+            self.console.print(
+                f"[yellow]No agents available. Use `{hint}` to add one.[/yellow]"
+            )
+        else:
+            self.console.print("[yellow]No agents available.[/yellow]")
 
+    def _resolve_or_pick_agent(self, client: Any, agents: list, args: list[str]) -> Any:
+        """Resolve agent from args or pick interactively."""
         if args:
             picked_agent = self._resolve_agent_from_ref(client, agents, args[0])
             if picked_agent is None:
                 self.console.print(
                     f"[yellow]Could not resolve agent '{args[0]}'. Try `/agents` to browse interactively.[/yellow]"
                 )
-                return True
+                return None
         else:
             picked_agent = _fuzzy_pick_for_resources(agents, "agent", "")
 
-        if not picked_agent:
-            return True
+        return picked_agent
 
+    def _run_agent_session(self, picked_agent: Any) -> bool:
+        """Run agent session and show follow-up actions."""
         self._remember_agent(picked_agent)
-
         AgentRunSession(self, picked_agent).run()
 
-        # Refresh the main palette header and surface follow-up actions so the
-        # user has immediate cues after leaving the agent context.
+        # Refresh the main palette header and surface follow-up actions
         self._render_header()
 
+        self._show_agent_followup_actions(picked_agent)
+        return True
+
+    def _show_agent_followup_actions(self, picked_agent: Any) -> None:
+        """Show follow-up action hints after agent session."""
         agent_id = str(getattr(picked_agent, "id", ""))
         agent_label = getattr(picked_agent, "name", "") or agent_id or "this agent"
+
         hints: list[tuple[str, str]] = []
         if agent_id:
             hints.append((f"/agents {agent_id}", f"Reopen {agent_label}"))
@@ -351,8 +380,8 @@ class SlashSession:
                 (self.STATUS_COMMAND, "Check connection"),
             ]
         )
+
         self._show_quick_actions(hints, title="Next actions")
-        return True
 
     def _cmd_exit(self, _args: list[str], invoked_from_agent: bool) -> bool:
         if invoked_from_agent:
@@ -710,12 +739,12 @@ class SlashSession:
 
         if full:
             lines = [
-                self._branding.get_welcome_banner(),
-                "",
-                f"[dim]API URL[/dim]: {api_url or 'Not configured'}",
-                f"[dim]Credentials[/dim]: {status}",
-                f"[dim]Verbose mode[/dim]: {'on' if self._verbose_enabled else 'off'}",
-                "[dim]Tip[/dim]: Press Ctrl+T or run `/verbose` to toggle verbose streaming.",
+                f"GL AIP v{self._branding.version} · GDP Labs AI Agents Package",
+                f"API: {api_url or 'Not configured'} · Credentials: {status}",
+                (
+                    f"Verbose: {'on' if self._verbose_enabled else 'off'} "
+                    "(Ctrl+T toggles verbose streaming)"
+                ),
             ]
             extra: list[str] = []
             self._add_agent_info_to_header(extra, active_agent)

glaip_sdk/client/agents.py

@@ -64,6 +64,7 @@ logger = logging.getLogger("glaip_sdk.agents")
 
 _SERVER_ONLY_IMPORT_FIELDS = set(list_server_only_fields()) | {"success", "message"}
 _MERGED_SEQUENCE_FIELDS = ("tools", "agents", "mcps")
+_DEFAULT_METADATA_TYPE = "custom"
 
 
 def _normalise_sequence(value: Any) -> list[Any] | None:
@@ -119,6 +120,20 @@ def _split_known_and_extra(
     return known, extras
 
 
+def _prepare_agent_metadata(value: Any) -> dict[str, Any]:
+    """Ensure agent metadata contains ``type: custom`` by default."""
+    if value is None:
+        return {"type": _DEFAULT_METADATA_TYPE}
+    if not isinstance(value, Mapping):
+        return {"type": _DEFAULT_METADATA_TYPE}
+
+    prepared = dict(value)
+    metadata_type = prepared.get("type")
+    if not metadata_type:
+        prepared["type"] = _DEFAULT_METADATA_TYPE
+    return prepared
+
+
 def _load_agent_file_payload(
     file_path: Path, *, model_override: str | None
 ) -> dict[str, Any]:
@@ -151,16 +166,39 @@ def _prepare_import_payload(
     overrides_dict = dict(overrides)
 
     raw_definition = load_resource_from_file(file_path)
-    original_refs = {
+    original_refs = _extract_original_refs(raw_definition)
+
+    base_payload = _load_agent_file_payload(
+        file_path, model_override=overrides_dict.get("model")
+    )
+
+    cli_args = _build_cli_args(overrides_dict)
+
+    merged = merge_import_with_cli_args(base_payload, cli_args)
+
+    additional = _build_additional_args(overrides_dict, cli_args)
+    merged.update(additional)
+
+    if drop_model_fields:
+        _remove_model_fields_if_needed(merged, overrides_dict)
+
+    _set_default_refs(merged, original_refs)
+
+    _normalise_sequence_fields(merged)
+    return merged
+
+
+def _extract_original_refs(raw_definition: dict) -> dict[str, list]:
+    """Extract original tool/agent/mcp references from raw definition."""
+    return {
         "tools": list(raw_definition.get("tools") or []),
         "agents": list(raw_definition.get("agents") or []),
         "mcps": list(raw_definition.get("mcps") or []),
     }
 
-    base_payload = _load_agent_file_payload(
-        file_path, model_override=overrides_dict.get("model")
-    )
 
+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 (
@@ -175,32 +213,37 @@ def _prepare_import_payload(
         if overrides_dict.get(key) is not None
     }
 
+    # Normalize sequence fields
     for field in _MERGED_SEQUENCE_FIELDS:
         if field in cli_args:
             cli_args[field] = tuple(_normalise_sequence(cli_args[field]) or [])
 
-    merged = merge_import_with_cli_args(base_payload, cli_args)
+    return cli_args
 
-    additional = {
+
+def _build_additional_args(overrides_dict: dict, cli_args: dict) -> dict[str, Any]:
+    """Build additional args not already in CLI args."""
+    return {
         key: value
         for key, value in overrides_dict.items()
         if value is not None and key not in cli_args
     }
-    merged.update(additional)
 
-    if drop_model_fields:
-        if overrides_dict.get("language_model_id") is None:
-            merged.pop("language_model_id", None)
-        if overrides_dict.get("provider") is None:
-            merged.pop("provider", None)
 
+def _remove_model_fields_if_needed(merged: dict, overrides_dict: dict) -> None:
+    """Remove model fields if not explicitly overridden."""
+    if overrides_dict.get("language_model_id") is None:
+        merged.pop("language_model_id", None)
+    if overrides_dict.get("provider") is None:
+        merged.pop("provider", None)
+
+
+def _set_default_refs(merged: dict, original_refs: dict) -> None:
+    """Set default references if not already present."""
     merged.setdefault("_tool_refs", original_refs["tools"])
     merged.setdefault("_agent_refs", original_refs["agents"])
     merged.setdefault("_mcp_refs", original_refs["mcps"])
 
-    _normalise_sequence_fields(merged)
-    return merged
-
 
 class AgentClient(BaseClient):
     """Client for agent operations."""
@@ -594,6 +637,25 @@ class AgentClient(BaseClient):
         resolved_agents = self._resolve_agent_ids(agents_raw, agent_refs)
         resolved_mcps = self._resolve_mcp_ids(mcps_raw, mcp_refs)
 
+        language_model_id = known.pop("language_model_id", None)
+        provider = known.pop("provider", None)
+        model_name = known.pop("model_name", None)
+
+        agent_type_value = known.pop("agent_type", None)
+        fallback_type_value = known.pop("type", None)
+        if agent_type_value is None:
+            agent_type_value = fallback_type_value or DEFAULT_AGENT_TYPE
+
+        framework_value = known.pop("framework", None) or DEFAULT_AGENT_FRAMEWORK
+        version_value = known.pop("version", None) or DEFAULT_AGENT_VERSION
+        account_id = known.pop("account_id", None)
+        description = known.pop("description", None)
+        metadata = _prepare_agent_metadata(known.pop("metadata", None))
+        tool_configs = known.pop("tool_configs", None)
+        agent_config = known.pop("agent_config", None)
+        timeout_value = known.pop("timeout", None)
+        a2a_profile = known.pop("a2a_profile", None)
+
         final_extras = {**known, **extras}
         final_extras.setdefault("model", resolved_model)
 
@@ -601,22 +663,22 @@ class AgentClient(BaseClient):
             name=str(name).strip(),
             instruction=validated_instruction,
             model=resolved_model,
-            language_model_id=known.pop("language_model_id", None),
-            provider=known.pop("provider", None),
-            model_name=known.pop("model_name", None),
-            agent_type=known.pop("agent_type", known.pop("type", DEFAULT_AGENT_TYPE)),
-            framework=known.pop("framework", None) or DEFAULT_AGENT_FRAMEWORK,
-            version=known.pop("version", None) or DEFAULT_AGENT_VERSION,
-            account_id=known.pop("account_id", None),
-            description=known.pop("description", None),
-            metadata=known.pop("metadata", None),
+            language_model_id=language_model_id,
+            provider=provider,
+            model_name=model_name,
+            agent_type=agent_type_value,
+            framework=framework_value,
+            version=version_value,
+            account_id=account_id,
+            description=description,
+            metadata=metadata,
             tools=resolved_tools,
             agents=resolved_agents,
             mcps=resolved_mcps,
-            tool_configs=known.pop("tool_configs", None),
-            agent_config=known.pop("agent_config", None),
-            timeout=known.pop("timeout", None) or DEFAULT_AGENT_RUN_TIMEOUT,
-            a2a_profile=known.pop("a2a_profile", None),
+            tool_configs=tool_configs,
+            agent_config=agent_config,
+            timeout=timeout_value or DEFAULT_AGENT_RUN_TIMEOUT,
+            a2a_profile=a2a_profile,
             extras=final_extras,
         )
 

glaip_sdk/client/main.py

@@ -158,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/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.17.dist-info → glaip_sdk-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.0.17
+Version: 0.0.18
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher

{glaip_sdk-0.0.17.dist-info → glaip_sdk-0.0.18.dist-info}/RECORD

@@ -24,19 +24,19 @@ glaip_sdk/cli/resolution.py,sha256=jXUNpKKhs30n7Ke0uz1Hbny5DTo2_sxvchIhTbeBubE,2
 glaip_sdk/cli/rich_helpers.py,sha256=ByUOmK16IisoXWE7nEiI55BF1KWDrm6KCYAxqHu0XOU,825
 glaip_sdk/cli/slash/__init__.py,sha256=Vdv6Y8bu-pA8dxDlyP4XrhudBPivztUozhLAz9vaLig,682
 glaip_sdk/cli/slash/agent_session.py,sha256=-woZkqH70YUSaEHDF9XpxP-cbh36Jx7yuJW7aA3JszI,7078
-glaip_sdk/cli/slash/prompt.py,sha256=2CLAfdmX6yQedcNLnwZ4g6QFoV9TVv8il9OF8iaJwdc,7977
-glaip_sdk/cli/slash/session.py,sha256=JsTHZB8gPFFdcp_bhtw-nig37Z61OWK_okPMx47H86c,31484
+glaip_sdk/cli/slash/prompt.py,sha256=Cfd6nL1T-F51WNuRCO09RxXfuJn0I1OyBi5dx3xKtaY,8407
+glaip_sdk/cli/slash/session.py,sha256=WZKAwkio1DMK72r6myR8Ou7weIS5JsQutbtVMox7ctc,32515
 glaip_sdk/cli/update_notifier.py,sha256=nfQ-jRQKn-nZyt7EhxNfZq9Z7nBrYjZJKAgAtuHffnw,3410
 glaip_sdk/cli/utils.py,sha256=pgbV0f5rdjAHeZ-ULCntH7HUG6FdFB9kODv0a9puB40,35503
 glaip_sdk/cli/validators.py,sha256=USbBgY86AwuDHO-Q_g8g7hu-ot4NgITBsWjTWIl62ms,5569
 glaip_sdk/client/__init__.py,sha256=nYLXfBVTTWwKjP0e63iumPYO4k5FifwWaELQPaPIKIg,188
 glaip_sdk/client/_agent_payloads.py,sha256=sYlMzrfAdd8KC37qxokLy2uDd3aOhzQirnv7UYlvwYc,16385
-glaip_sdk/client/agents.py,sha256=GpDlxzhUQaMn9IUq_kCsbZo5TBfwWXFYs1bbpPLiSok,35492
+glaip_sdk/client/agents.py,sha256=-ORfxYaoX6JkgGS9B7ZCQmr1o9H5KEr0GesbfeiSros,37594
 glaip_sdk/client/base.py,sha256=OPRlAWhZ77rUK0MRGA83-zW5NVhxJ1RgdfcfGOYr8rI,16267
-glaip_sdk/client/main.py,sha256=tfyyx9utReq7nXdtHKOCXQIUXXeZ1-D6u4OGTu6h8Es,8632
+glaip_sdk/client/main.py,sha256=tELAA36rzthnNKTgwZ6lLPb3Au8Wh1mF8Kz-9N-YtCg,8652
 glaip_sdk/client/mcps.py,sha256=-O-I15qjbwfSA69mouHY6g5_qgPWC4rM98VJLpOkh1A,8975
 glaip_sdk/client/run_rendering.py,sha256=fXUj1FBw8n-nAzjI_zaG7-Ap_UXXe0z4tMdL7m2R7Ek,9213
-glaip_sdk/client/tools.py,sha256=n8DIiOOf1YU_j9JK3Bx2-rDnkpckPi0MI9Ok2s1kwa4,16634
+glaip_sdk/client/tools.py,sha256=rWxfNO30sS468513IoE5PfEaqNq6HBwmcHVh4FzhvYQ,17532
 glaip_sdk/client/validators.py,sha256=NtPsWjQLjj25LiUnmR-WuS8lL5p4MVRaYT9UVRmj9bo,8809
 glaip_sdk/config/constants.py,sha256=B9CSlYG8LYjQuo_vNpqy-eSks3ej37FMcvJMy6d_F4U,888
 glaip_sdk/exceptions.py,sha256=ILquxC4QGPFR9eY6RpeXzkQsblfsvZMGFqz38ZjeW3E,2345
@@ -45,16 +45,16 @@ glaip_sdk/payload_schemas/__init__.py,sha256=fJamlkpS3IfS9xyKAQaUbnalvrtG5Ied69O
 glaip_sdk/payload_schemas/agent.py,sha256=nlizuv2w4SVzmMJSE90rE6Ll0Hfpcr5hvPsW_NtXCV0,3204
 glaip_sdk/rich_components.py,sha256=veaps1hrSkC3nSVunAevvynSux8Cg3yFEDmbJk66p7w,1267
 glaip_sdk/utils/__init__.py,sha256=fmVGcUFa7G0CCfSMSqfNU2BqFl36G1gOFyDfTvtJfVw,926
-glaip_sdk/utils/agent_config.py,sha256=b7_J5DELyk0b_XEoi7tsxbS3wqzAKbMa-3_C-65pPIY,6791
+glaip_sdk/utils/agent_config.py,sha256=p3uK5qC0M5uQv9uY7-U8ej11Vh81fwKAPSsYcRoNdlk,7342
 glaip_sdk/utils/client_utils.py,sha256=x27kHQNOxvyVN5GLUiymi0eHzkXRKw-x3s0q0VkMvY4,13938
 glaip_sdk/utils/display.py,sha256=94s9lYF_8ra8jpeqOkbVrUm8oidtCE6OtucyxLQPKmU,3105
 glaip_sdk/utils/general.py,sha256=V5hJrIpYDvDsldU_nChHpuvV2AwhFLUI7Qvcaihq_8A,2270
 glaip_sdk/utils/import_export.py,sha256=jEhl5U6hWWMR1wo5AXpV-_jN_56DcWcemOa2UaFHapk,5217
 glaip_sdk/utils/rendering/__init__.py,sha256=vXjwk5rPhhfPyD8S0DnV4GFFEtPJp4HCCg1Um9SXfs0,70
-glaip_sdk/utils/rendering/formatting.py,sha256=I8nN4H3DxTOYIExn6gozcxyAn_GO1lSztbcrSCkcscg,7351
+glaip_sdk/utils/rendering/formatting.py,sha256=mS4xvbNy1NSH4nXm8mKj03jEXMNinxfbtVJGYf3sXlk,7770
 glaip_sdk/utils/rendering/models.py,sha256=AM9JbToyA3zrAzXQYjh6oxjBkgZDfWEbs5MmNKODnOY,2259
 glaip_sdk/utils/rendering/renderer/__init__.py,sha256=EXwVBmGkSYcype4ocAXo69Z1kXu0gpNXmhH5LW0_B7A,2939
-glaip_sdk/utils/rendering/renderer/base.py,sha256=HGljrxMcDq4QCsWcwR45qZYjKWZprBunnZJYYea8FTQ,42764
+glaip_sdk/utils/rendering/renderer/base.py,sha256=Tk-N0Fpi4kyuJYb-YaYEAytpho2vcWBKdDmzqIK_Pto,45543
 glaip_sdk/utils/rendering/renderer/config.py,sha256=-P35z9JO_1ypJXAqxJ1ybHraH4i-I1LPopeW3Lh7ACE,785
 glaip_sdk/utils/rendering/renderer/console.py,sha256=4cLOw4Q1fkHkApuj6dWW8eYpeYdcT0t2SO5MbVt5UTc,1844
 glaip_sdk/utils/rendering/renderer/debug.py,sha256=FEYxAu4ZB0CjrJKevqQ2TKDgElA2cf6GqZXCNm12sNQ,3721
@@ -67,7 +67,7 @@ glaip_sdk/utils/rich_utils.py,sha256=-Ij-1bIJvnVAi6DrfftchIlMcvOTjVmSE0Qqax0EY_s
 glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDad0,1365
 glaip_sdk/utils/serialization.py,sha256=AFbucakFaCtQDfcgsm2gHZ1iZDA8OaJSZUsS6FhWFR0,12820
 glaip_sdk/utils/validation.py,sha256=QNORcdyvuliEs4EH2_mkDgmoyT9utgl7YNhaf45SEf8,6992
-glaip_sdk-0.0.17.dist-info/METADATA,sha256=z1GiwKAgE5eXkCbBfUXrQuMZBUQ14XWuOZhgj5ugyAw,5164
-glaip_sdk-0.0.17.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-glaip_sdk-0.0.17.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
-glaip_sdk-0.0.17.dist-info/RECORD,,
+glaip_sdk-0.0.18.dist-info/METADATA,sha256=IaSz5FAxBzrHDKtbgjyg6h4vyClUS7C3M4ovlax0rv4,5164
+glaip_sdk-0.0.18.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+glaip_sdk-0.0.18.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
+glaip_sdk-0.0.18.dist-info/RECORD,,