glaip-sdk 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/progress.py

@@ -48,15 +48,11 @@ def format_working_indicator(
     """Format a working indicator with elapsed time."""
     base_message = "Working..."
 
-    if started_at is None and (
-        server_elapsed_time is None or streaming_started_at is None
-    ):
+    if started_at is None and (server_elapsed_time is None or streaming_started_at is None):
         return base_message
 
     spinner_chip = f"{get_spinner_char()} {base_message}"
-    elapsed = _resolve_elapsed_time(
-        started_at, server_elapsed_time, streaming_started_at
-    )
+    elapsed = _resolve_elapsed_time(started_at, server_elapsed_time, streaming_started_at)
     if elapsed is None:
         return spinner_chip
 
@@ -93,11 +89,7 @@ def is_delegation_tool(tool_name: str) -> bool:
     Returns:
         True if this is a delegation tool
     """
-    return (
-        tool_name.startswith("delegate_to_")
-        or tool_name.startswith("delegate_")
-        or "sub_agent" in tool_name.lower()
-    )
+    return tool_name.startswith("delegate_to_") or tool_name.startswith("delegate_") or "sub_agent" in tool_name.lower()
 
 
 def _delegation_tool_title(tool_name: str) -> str | None:

glaip_sdk/utils/rendering/renderer/stream.py

@@ -42,7 +42,7 @@ class StreamProcessor:
         # Update server elapsed timing if backend provides it
         try:
             t = metadata.get("time")
-            if isinstance(t, int | float):
+            if isinstance(t, (int, float)):
                 self.server_elapsed_time = float(t)
         except Exception:
             pass
@@ -56,9 +56,7 @@ class StreamProcessor:
             "metadata": metadata,
         }
 
-    def _extract_metadata_tool_calls(
-        self, metadata: dict[str, Any]
-    ) -> tuple[str | None, dict, Any, list]:
+    def _extract_metadata_tool_calls(self, metadata: dict[str, Any]) -> tuple[str | None, dict, Any, list]:
         """Extract tool calls from metadata."""
         tool_calls = metadata.get("tool_calls", [])
         if not tool_calls:
@@ -84,9 +82,7 @@ class StreamProcessor:
 
         return tool_name, tool_args, tool_out, tool_calls_info
 
-    def _extract_tool_info_calls(
-        self, tool_info: dict[str, Any]
-    ) -> tuple[str | None, dict, Any, list]:
+    def _extract_tool_info_calls(self, tool_info: dict[str, Any]) -> tuple[str | None, dict, Any, list]:
         """Extract tool calls from tool_info structure."""
         tool_calls_info = []
         tool_name = None
@@ -98,9 +94,7 @@ class StreamProcessor:
         if isinstance(ti_calls, list) and ti_calls:
             for call in ti_calls:
                 if isinstance(call, dict) and call.get("name"):
-                    tool_calls_info.append(
-                        (call.get("name"), call.get("args", {}), call.get("output"))
-                    )
+                    tool_calls_info.append((call.get("name"), call.get("args", {}), call.get("output")))
             if tool_calls_info:
                 tool_name, tool_args, tool_out = tool_calls_info[0]
             return tool_name, tool_args, tool_out, tool_calls_info
@@ -114,9 +108,7 @@ class StreamProcessor:
 
         return tool_name, tool_args, tool_out, tool_calls_info
 
-    def _extract_tool_calls_from_metadata(
-        self, metadata: dict[str, Any]
-    ) -> tuple[str | None, dict, Any, list]:
+    def _extract_tool_calls_from_metadata(self, metadata: dict[str, Any]) -> tuple[str | None, dict, Any, list]:
         """Extract tool calls from metadata structure."""
         tool_info = metadata.get("tool_info", {}) or {}
 
@@ -125,9 +117,7 @@ class StreamProcessor:
 
         return None, {}, None, []
 
-    def parse_tool_calls(
-        self, event: dict[str, Any]
-    ) -> tuple[str | None, Any, Any, list[tuple[str, Any, Any]]]:
+    def parse_tool_calls(self, event: dict[str, Any]) -> tuple[str | None, Any, Any, list[tuple[str, Any, Any]]]:
         """Parse tool call information from an event.
 
         Args:
@@ -166,9 +156,7 @@ class StreamProcessor:
         if context_id:
             self.last_event_time_by_ctx[context_id] = monotonic()
 
-    def should_insert_thinking_gap(
-        self, task_id: str | None, context_id: str | None, think_threshold: float
-    ) -> bool:
+    def should_insert_thinking_gap(self, task_id: str | None, context_id: str | None, think_threshold: float) -> bool:
         """Determine if a thinking gap should be inserted.
 
         Args:

glaip_sdk/utils/rendering/renderer/toggle.py

@@ -159,9 +159,7 @@ class TranscriptToggleController:
             return
 
         self._stop_event.clear()
-        self._poll_thread = threading.Thread(
-            target=self._poll_loop, args=(renderer,), daemon=True
-        )
+        self._poll_thread = threading.Thread(target=self._poll_loop, args=(renderer,), daemon=True)
         self._poll_thread.start()
 
     def _stop_polling_thread(self) -> None:

glaip_sdk/utils/rendering/step_tree_state.py

@@ -20,9 +20,7 @@ class StepTreeState:
     root_order: list[str] = field(default_factory=list)
     child_map: dict[str, list[str]] = field(default_factory=dict)
     buffered_children: dict[str, list[str]] = field(default_factory=dict)
-    running_by_context: dict[tuple[str | None, str | None], set[str]] = field(
-        default_factory=dict
-    )
+    running_by_context: dict[tuple[str | None, str | None], set[str]] = field(default_factory=dict)
     retained_ids: set[str] = field(default_factory=set)
     step_index: dict[str, Step] = field(default_factory=dict)
     pending_branch_failures: set[str] = field(default_factory=set)

glaip_sdk/utils/rendering/steps.py

@@ -104,9 +104,7 @@ class StepManager:
         Returns:
             The Step instance (new or existing)
         """
-        existing = self.find_running(
-            task_id=task_id, context_id=context_id, kind=kind, name=name
-        )
+        existing = self.find_running(task_id=task_id, context_id=context_id, kind=kind, name=name)
         if existing:
             if args and existing.args != args:
                 existing.args = args
@@ -228,18 +226,12 @@ class StepManager:
         self.state.pending_branch_failures.discard(step_id)
         self.state.discard_running(step_id)
 
-        self.key_index = {
-            key: sid for key, sid in self.key_index.items() if sid != step_id
-        }
+        self.key_index = {key: sid for key, sid in self.key_index.items() if sid != step_id}
         for key, last_sid in self._last_running.copy().items():
             if last_sid == step_id:
                 self._last_running.pop(key, None)
 
-        aliases = [
-            alias
-            for alias, target in self._step_aliases.items()
-            if alias == step_id or target == step_id
-        ]
+        aliases = [alias for alias, target in self._step_aliases.items() if alias == step_id or target == step_id]
         for alias in aliases:
             self._step_aliases.pop(alias, None)
 
@@ -321,9 +313,7 @@ class StepManager:
         Raises:
             RuntimeError: If no matching step is found
         """
-        st = self.find_running(
-            task_id=task_id, context_id=context_id, kind=kind, name=name
-        )
+        st = self.find_running(task_id=task_id, context_id=context_id, kind=kind, name=name)
         if not st:
             # Try to find any existing step with matching parameters, even if not running
             for sid in reversed(list(self._iter_all_steps())):
@@ -340,9 +330,7 @@ class StepManager:
 
             # If still no step found, create a new one
             if not st:
-                st = self.start_or_get(
-                    task_id=task_id, context_id=context_id, kind=kind, name=name
-                )
+                st = self.start_or_get(task_id=task_id, context_id=context_id, kind=kind, name=name)
 
         if output:
             st.output = output
@@ -457,18 +445,14 @@ class StepManager:
         return cloned
 
     @staticmethod
-    def _copy_tool_call_field(
-        call: dict[str, Any], target: dict[str, Any], field: str
-    ) -> None:
+    def _copy_tool_call_field(call: dict[str, Any], target: dict[str, Any], field: str) -> None:
         """Copy a field from the tool call when it exists."""
         value = call.get(field)
         if value:
             target[field] = value
 
     @staticmethod
-    def _derive_call_step_id(
-        call: dict[str, Any], base_step_id: str, index: int
-    ) -> str:
+    def _derive_call_step_id(call: dict[str, Any], base_step_id: str, index: int) -> str:
         """Determine the per-call step identifier."""
         call_id = call.get("id")
         if isinstance(call_id, str):
@@ -495,15 +479,11 @@ class StepManager:
         self._link_step(step, parent_id)
 
         self.state.retained_ids.add(step.step_id)
-        step.display_label = self._compose_display_label(
-            step.kind, tool_name, args, metadata
-        )
+        step.display_label = self._compose_display_label(step.kind, tool_name, args, metadata)
         self._flush_buffered_children(step.step_id)
         self._apply_pending_branch_flags(step.step_id)
 
-        status = self._normalise_status(
-            metadata.get("status"), event.get("status"), event.get("task_state")
-        )
+        status = self._normalise_status(metadata.get("status"), event.get("status"), event.get("task_state"))
         status = self._apply_failure_state(step, status, event)
 
         server_time = self._coerce_server_time(metadata.get("time"))
@@ -530,9 +510,7 @@ class StepManager:
         self._prune_steps()
         return step
 
-    def _parse_event_payload(
-        self, event: dict[str, Any]
-    ) -> tuple[dict[str, Any], str, dict[str, Any], dict[str, Any]]:
+    def _parse_event_payload(self, event: dict[str, Any]) -> tuple[dict[str, Any], str, dict[str, Any], dict[str, Any]]:
         metadata = event.get("metadata") or {}
         if not isinstance(metadata, dict):
             raise ValueError("Step event missing metadata payload")
@@ -553,9 +531,7 @@ class StepManager:
 
         return metadata, step_id, tool_info, args
 
-    def _resolve_tool_name(
-        self, tool_info: dict[str, Any], metadata: dict[str, Any], step_id: str
-    ) -> str:
+    def _resolve_tool_name(self, tool_info: dict[str, Any], metadata: dict[str, Any], step_id: str) -> str:
         name = tool_info.get("name")
         if not name:
             call = self._first_tool_call(tool_info)
@@ -601,12 +577,8 @@ class StepManager:
     ) -> Step:
         existing = self.by_id.get(step_id)
         if existing:
-            return self._update_existing_step(
-                existing, kind, tool_name, event, metadata, args
-            )
-        return self._create_step_from_event(
-            step_id, kind, tool_name, event, metadata, args
-        )
+            return self._update_existing_step(existing, kind, tool_name, event, metadata, args)
+        return self._create_step_from_event(step_id, kind, tool_name, event, metadata, args)
 
     def _create_step_from_event(
         self,
@@ -621,12 +593,8 @@ class StepManager:
             step_id=step_id,
             kind=kind,
             name=tool_name or step_id,
-            task_id=self._coalesce_metadata_value(
-                "task_id", event, metadata, fallback=None
-            ),
-            context_id=self._coalesce_metadata_value(
-                "context_id", event, metadata, fallback=None
-            ),
+            task_id=self._coalesce_metadata_value("task_id", event, metadata, fallback=None),
+            context_id=self._coalesce_metadata_value("context_id", event, metadata, fallback=None),
             args=args or {},
         )
         self.by_id[step_id] = step
@@ -646,20 +614,12 @@ class StepManager:
         step.name = tool_name or step.name
         if args:
             step.args = args
-        step.task_id = self._coalesce_metadata_value(
-            "task_id", event, metadata, fallback=step.task_id
-        )
-        step.context_id = self._coalesce_metadata_value(
-            "context_id", event, metadata, fallback=step.context_id
-        )
+        step.task_id = self._coalesce_metadata_value("task_id", event, metadata, fallback=step.task_id)
+        step.context_id = self._coalesce_metadata_value("context_id", event, metadata, fallback=step.context_id)
         return step
 
-    def _apply_failure_state(
-        self, step: Step, status: str, event: dict[str, Any]
-    ) -> str:
-        failure_reason = self._extract_failure_reason(
-            status, event.get("task_state"), event.get("content")
-        )
+    def _apply_failure_state(self, step: Step, status: str, event: dict[str, Any]) -> str:
+        failure_reason = self._extract_failure_reason(status, event.get("task_state"), event.get("content"))
         if not failure_reason:
             step.status = status
             return status
@@ -679,9 +639,7 @@ class StepManager:
         args: dict[str, Any],
         server_time: float | None,
     ) -> None:
-        duration_ms, duration_source = self._resolve_duration_from_event(
-            tool_info, args
-        )
+        duration_ms, duration_source = self._resolve_duration_from_event(tool_info, args)
         if duration_ms is not None:
             step.duration_ms = duration_ms
             step.duration_source = duration_source
@@ -750,6 +708,8 @@ class StepManager:
             return "delegate"
         if tool.startswith("agent_"):
             return "agent"
+        if kind == "agent_step":
+            return "tool" if tool else "agent_step"
         return kind or "tool"
 
     def _clean_kind(self, metadata_kind: Any) -> str:
@@ -763,9 +723,7 @@ class StepManager:
     def _is_delegate_tool(self, tool: str) -> bool:
         return tool.startswith(("delegate_to_", "delegate-", "delegate ", "delegate_"))
 
-    def _is_top_level_agent(
-        self, tool_name: str | None, metadata: dict[str, Any], kind: str
-    ) -> bool:
+    def _is_top_level_agent(self, tool_name: str | None, metadata: dict[str, Any], kind: str) -> bool:
         if kind != "agent_step":
             return False
         agent_name = metadata.get("agent_name")
@@ -864,9 +822,7 @@ class StepManager:
         content: Any,
     ) -> str | None:
         failure_states = {"failed", "stopped", "error"}
-        task_state_str = (
-            (task_state or "").lower() if isinstance(task_state, str) else ""
-        )
+        task_state_str = (task_state or "").lower() if isinstance(task_state, str) else ""
         if status in failure_states or task_state_str in failure_states:
             if isinstance(content, str) and content.strip():
                 return content.strip()
@@ -893,15 +849,11 @@ class StepManager:
 
         return None, None
 
-    def _determine_parent_id(
-        self, step: Step, metadata: dict[str, Any], parent_hint: str | None
-    ) -> str | None:
+    def _determine_parent_id(self, step: Step, metadata: dict[str, Any], parent_hint: str | None) -> str | None:
         scope_parent = self._lookup_scope_parent(metadata, step)
         candidate = scope_parent or parent_hint
         if candidate == step.step_id:
-            logger.debug(
-                "Step %s cannot parent itself; dropping parent hint", candidate
-            )
+            logger.debug("Step %s cannot parent itself; dropping parent hint", candidate)
             return None
         return candidate
 
@@ -926,9 +878,7 @@ class StepManager:
         self._detach_from_current_parent(step)
         self._attach_to_parent(step, parent_id)
 
-    def _sanitize_parent_reference(
-        self, step: Step, parent_id: str | None
-    ) -> str | None:
+    def _sanitize_parent_reference(self, step: Step, parent_id: str | None) -> str | None:
         """Guard against self-referential parent assignments."""
         if parent_id != step.step_id:
             return parent_id
@@ -1053,9 +1003,7 @@ class StepManager:
         except (TypeError, ValueError):
             return None
 
-    def _update_server_timestamps(
-        self, step: Step, server_time: float | None, status: str
-    ) -> None:
+    def _update_server_timestamps(self, step: Step, server_time: float | None, status: str) -> None:
         if server_time is None:
             return
         if status == "running" and step.server_started_at is None:
@@ -1065,9 +1013,7 @@ class StepManager:
             if step.server_started_at is None:
                 step.server_started_at = server_time
 
-    def _calculate_server_duration(
-        self, step: Step, server_time: float | None
-    ) -> int | None:
+    def _calculate_server_duration(self, step: Step, server_time: float | None) -> int | None:
         start = step.server_started_at
         end = server_time if server_time is not None else step.server_finished_at
         if start is None or end is None:

glaip_sdk/utils/resource_refs.py

@@ -95,9 +95,7 @@ def extract_names(items: list[str | Any] | None) -> list[str]:
     return names
 
 
-def find_by_name(
-    items: list[Any], name: str, case_sensitive: bool = False
-) -> list[Any]:
+def find_by_name(items: list[Any], name: str, case_sensitive: bool = False) -> list[Any]:
     """Filter items by name with optional case sensitivity.
 
     This is a common pattern used across different clients for client-side
@@ -165,16 +163,12 @@ def validate_name_format(name: str, resource_type: str = "resource") -> str:
 
     # Check for valid characters (alphanumeric, hyphens, underscores)
     if not re.match(r"^[a-zA-Z0-9_-]+$", cleaned_name):
-        raise ValueError(
-            f"{display_type} name can only contain letters, numbers, hyphens, and underscores"
-        )
+        raise ValueError(f"{display_type} name can only contain letters, numbers, hyphens, and underscores")
 
     return cleaned_name
 
 
-def validate_name_uniqueness(
-    name: str, existing_names: list[str], resource_type: str = "resource"
-) -> None:
+def validate_name_uniqueness(name: str, existing_names: list[str], resource_type: str = "resource") -> None:
     """Validate that a resource name is unique.
 
     Args:
@@ -186,7 +180,4 @@ def validate_name_uniqueness(
         ValueError: If name is not unique
     """
     if name.lower() in [existing.lower() for existing in existing_names]:
-        raise ValueError(
-            f"A {resource_type.lower()} named '{name}' already exists. "
-            "Please choose a unique name."
-        )
+        raise ValueError(f"A {resource_type.lower()} named '{name}' already exists. Please choose a unique name.")

glaip_sdk/utils/serialization.py

@@ -67,20 +67,12 @@ def read_yaml(file_path: Path) -> dict[str, Any]:
         data = yaml.safe_load(f)
 
     # Handle instruction_lines array format for user-friendly YAML
-    if (
-        isinstance(data, dict)
-        and "instruction_lines" in data
-        and isinstance(data["instruction_lines"], list)
-    ):
+    if isinstance(data, dict) and "instruction_lines" in data and isinstance(data["instruction_lines"], list):
         data["instruction"] = "\n\n".join(data["instruction_lines"])
         del data["instruction_lines"]
 
     # Handle instruction as list from YAML export (convert back to string)
-    if (
-        isinstance(data, dict)
-        and "instruction" in data
-        and isinstance(data["instruction"], list)
-    ):
+    if isinstance(data, dict) and "instruction" in data and isinstance(data["instruction"], list):
         data["instruction"] = "\n\n".join(data["instruction"])
 
     return data
@@ -98,9 +90,7 @@ def write_yaml(file_path: Path, data: dict[str, Any]) -> None:
     class LiteralString(str):
         pass
 
-    def literal_string_representer(
-        dumper: yaml.Dumper, data: "LiteralString"
-    ) -> yaml.nodes.Node:
+    def literal_string_representer(dumper: yaml.Dumper, data: "LiteralString") -> yaml.nodes.Node:
         # Use literal block scalar (|) for multiline strings to preserve formatting
         if "\n" in data:
             return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
@@ -115,9 +105,7 @@ def write_yaml(file_path: Path, data: dict[str, Any]) -> None:
         data["instruction"] = LiteralString(data["instruction"])
 
     with open(file_path, "w", encoding="utf-8") as f:
-        yaml.dump(
-            data, f, default_flow_style=False, allow_unicode=True, sort_keys=False
-        )
+        yaml.dump(data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
 
 
 def load_resource_from_file(file_path: Path) -> dict[str, Any]:
@@ -137,15 +125,10 @@ def load_resource_from_file(file_path: Path) -> dict[str, Any]:
     elif file_path.suffix.lower() == ".json":
         return read_json(file_path)
     else:
-        raise ValueError(
-            f"Unsupported file format: {file_path.suffix}. "
-            f"Only JSON and YAML files are supported."
-        )
+        raise ValueError(f"Unsupported file format: {file_path.suffix}. Only JSON and YAML files are supported.")
 
 
-def write_resource_export(
-    file_path: Path, data: dict[str, Any], format: str = "json"
-) -> None:
+def write_resource_export(file_path: Path, data: dict[str, Any], format: str = "json") -> None:
     """Write resource export data to file.
 
     Args:
@@ -190,13 +173,8 @@ def collect_attributes_for_export(resource: Any) -> dict[str, Any]:
     data.
     """
     mapping = _coerce_resource_to_mapping(resource)
-    if (
-        mapping is None
-    ):  # pragma: no cover - defensive fallback when attribute introspection fails
-        items = (
-            (name, _safe_getattr(resource, name))
-            for name in _iter_public_attribute_names(resource)
-        )
+    if mapping is None:  # pragma: no cover - defensive fallback when attribute introspection fails
+        items = ((name, _safe_getattr(resource, name)) for name in _iter_public_attribute_names(resource))
     else:
         items = mapping.items()
 
@@ -249,9 +227,7 @@ def _coerce_resource_to_mapping(resource: Any) -> dict[str, Any] | None:
     try:
         if hasattr(resource, "__dict__"):
             return dict(resource.__dict__)
-    except (
-        Exception
-    ):  # pragma: no cover - pathological objects can still defeat coercion
+    except Exception:  # pragma: no cover - pathological objects can still defeat coercion
         return None
 
     return None
@@ -284,9 +260,7 @@ def _iter_public_attribute_names(resource: Any) -> Iterable[str]:
     return iter(names)
 
 
-def _collect_from_dict(
-    resource: Any, collect_func: Callable[[Iterable[str]], None]
-) -> None:
+def _collect_from_dict(resource: Any, collect_func: Callable[[Iterable[str]], None]) -> None:
     """Safely collect attribute names from __dict__."""
     try:
         if hasattr(resource, "__dict__"):
@@ -297,18 +271,14 @@ def _collect_from_dict(
         pass
 
 
-def _collect_from_annotations(
-    resource: Any, collect_func: Callable[[Iterable[str]], None]
-) -> None:
+def _collect_from_annotations(resource: Any, collect_func: Callable[[Iterable[str]], None]) -> None:
     """Safely collect attribute names from __annotations__."""
     annotations = getattr(resource, "__annotations__", {})
     if annotations:
         collect_func(annotations.keys())
 
 
-def _collect_from_dir(
-    resource: Any, collect_func: Callable[[Iterable[str]], None]
-) -> None:
+def _collect_from_dir(resource: Any, collect_func: Callable[[Iterable[str]], None]) -> None:
     """Safely collect attribute names from dir()."""
     try:
         collect_func(name for name in dir(resource) if not name.startswith("__"))
@@ -387,9 +357,7 @@ def build_mcp_export_payload(
         ImportError: If required modules (auth helpers) are not available
     """
     auth_module = importlib.import_module("glaip_sdk.cli.auth")
-    prepare_authentication_export = getattr(
-        auth_module, "prepare_authentication_export"
-    )
+    prepare_authentication_export = auth_module.prepare_authentication_export
 
     # Start with model dump (excludes None values automatically)
     payload = mcp.model_dump(exclude_none=True)
@@ -435,4 +403,4 @@ def validate_json_string(json_str: str) -> dict[str, Any]:
     try:
         return json.loads(json_str)
     except json.JSONDecodeError as e:
-        raise ValueError(f"Invalid JSON: {e}")
+        raise ValueError(f"Invalid JSON: {e}") from e

glaip_sdk/utils/validation.py

@@ -155,13 +155,13 @@ def coerce_timeout(value: Any) -> int:
         try:
             fval = float(value)
             return validate_timeout(int(fval))
-        except ValueError:
-            raise ValueError(f"Invalid timeout value: {value}")
+        except ValueError as err:
+            raise ValueError(f"Invalid timeout value: {value}") from err
     else:
         try:
             return validate_timeout(int(value))
-        except (TypeError, ValueError):
-            raise ValueError(f"Invalid timeout value: {value}")
+        except (TypeError, ValueError) as err:
+            raise ValueError(f"Invalid timeout value: {value}") from err
 
 
 def validate_file_path(file_path: str | Path, must_exist: bool = True) -> Path:

{glaip_sdk-0.1.0.dist-info → glaip_sdk-0.1.1.dist-info}/METADATA

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