glaip-sdk 0.6.10__py3-none-any.whl → 0.6.11__py3-none-any.whl

glaip_sdk/client/agents.py

@@ -453,13 +453,11 @@ class AgentClient(BaseClient):
         Returns:
             Final text string.
         """
+        from glaip_sdk.client.run_rendering import finalize_render_manager  # noqa: PLC0415
+
         manager = self._get_renderer_manager()
-        return manager.finalize_renderer(
-            renderer,
-            final_text,
-            stats_usage,
-            started_monotonic,
-            finished_monotonic,
+        return finalize_render_manager(
+            manager, renderer, final_text, stats_usage, started_monotonic, finished_monotonic
         )
 
     def _get_tool_client(self) -> ToolClient:

glaip_sdk/client/run_rendering.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import json
 import logging
-from collections.abc import Callable
+from collections.abc import AsyncIterable, Callable
 from time import monotonic
 from typing import Any
 
@@ -163,6 +163,261 @@ class AgentRunRenderingManager:
         finished_monotonic = monotonic()
         return final_text, stats_usage, started_monotonic, finished_monotonic
 
+    async def async_process_stream_events(
+        self,
+        event_stream: AsyncIterable[dict[str, Any]],
+        renderer: RichStreamRenderer,
+        meta: dict[str, Any],
+        *,
+        skip_final_render: bool = True,
+    ) -> tuple[str, dict[str, Any], float | None, float | None]:
+        """Process streaming events from an async event source.
+
+        This method provides unified stream processing for both remote (HTTP)
+        and local (LangGraph) agent execution, ensuring consistent behavior.
+
+        Args:
+            event_stream: Async iterable yielding SSE-like event dicts.
+                Each event should have a "data" key with JSON string, or be
+                a pre-parsed dict with "content", "metadata", etc.
+            renderer: Renderer to use for displaying events.
+            meta: Metadata dictionary for renderer context.
+            skip_final_render: If True, skip rendering final_response events
+                (they are rendered separately via finalize_renderer).
+
+        Returns:
+            Tuple of (final_text, stats_usage, started_monotonic, finished_monotonic).
+        """
+        final_text = ""
+        stats_usage: dict[str, Any] = {}
+        started_monotonic: float | None = None
+        last_rendered_content: str | None = None
+
+        controller = getattr(renderer, "transcript_controller", None)
+        if controller and getattr(controller, "enabled", False):
+            controller.on_stream_start(renderer)
+
+        try:
+            async for event in event_stream:
+                if started_monotonic is None:
+                    started_monotonic = monotonic()
+
+                # Parse event if needed (handles both raw SSE and pre-parsed dicts)
+                parsed_event = self._parse_event(event)
+                if parsed_event is None:
+                    continue
+
+                # Process the event and update accumulators
+                final_text, stats_usage = self._handle_parsed_event(
+                    parsed_event,
+                    renderer,
+                    final_text,
+                    stats_usage,
+                    meta,
+                    skip_final_render=skip_final_render,
+                    last_rendered_content=last_rendered_content,
+                )
+
+                # Track last rendered content to avoid duplicates
+                content_str = self._extract_content_string(parsed_event)
+                if content_str:
+                    last_rendered_content = content_str
+
+                if controller and getattr(controller, "enabled", False):
+                    controller.poll(renderer)
+        finally:
+            if controller and getattr(controller, "enabled", False):
+                controller.on_stream_complete()
+
+        finished_monotonic = monotonic()
+        return final_text, stats_usage, started_monotonic, finished_monotonic
+
+    def _parse_event(self, event: dict[str, Any]) -> dict[str, Any] | None:
+        """Parse an SSE event dict into a usable format.
+
+        Args:
+            event: Raw event dict, either with "data" key (SSE format) or
+                pre-parsed with "content", "metadata", etc.
+
+        Returns:
+            Parsed event dict, or None if parsing fails.
+        """
+        if "data" in event:
+            try:
+                return json.loads(event["data"])
+            except json.JSONDecodeError:
+                self._logger.debug("Non-JSON SSE fragment skipped")
+                return None
+        # Already parsed (e.g., from local runner)
+        return event if event else None
+
+    def _handle_parsed_event(
+        self,
+        ev: dict[str, Any],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        meta: dict[str, Any],
+        *,
+        skip_final_render: bool = True,
+        last_rendered_content: str | None = None,
+    ) -> tuple[str, dict[str, Any]]:
+        """Handle a parsed event and update accumulators.
+
+        Args:
+            ev: Parsed event dictionary.
+            renderer: Renderer instance.
+            final_text: Current accumulated final text.
+            stats_usage: Usage statistics dictionary.
+            meta: Metadata dictionary.
+            skip_final_render: If True, skip rendering final_response events.
+            last_rendered_content: Last rendered content to avoid duplicates.
+
+        Returns:
+            Tuple of (updated_final_text, updated_stats_usage).
+        """
+        kind = self._get_event_kind(ev)
+
+        # Dispatch to specialized handlers based on event kind
+        handler = self._get_event_handler(kind, ev)
+        if handler:
+            return handler(ev, renderer, final_text, stats_usage, meta, skip_final_render)
+
+        # Default: handle content events
+        return self._handle_content_event_async(ev, renderer, final_text, stats_usage, last_rendered_content)
+
+    def _get_event_handler(
+        self,
+        kind: str | None,
+        ev: dict[str, Any],
+    ) -> Callable[..., tuple[str, dict[str, Any]]] | None:
+        """Get the appropriate handler for an event kind.
+
+        Args:
+            kind: Event kind string.
+            ev: Event dictionary (for checking is_final flag).
+
+        Returns:
+            Handler function or None for default content handling.
+        """
+        if kind == "usage":
+            return self._handle_usage_event
+        if kind == "final_response" or ev.get("is_final"):
+            return self._handle_final_response_event
+        if kind == "run_info":
+            return self._handle_run_info_event_wrapper
+        if kind in ("artifact", "status_update"):
+            return self._handle_render_only_event
+        return None
+
+    def _handle_usage_event(
+        self,
+        ev: dict[str, Any],
+        _renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        _meta: dict[str, Any],
+        _skip_final_render: bool,
+    ) -> tuple[str, dict[str, Any]]:
+        """Handle usage events."""
+        stats_usage.update(ev.get("usage") or {})
+        return final_text, stats_usage
+
+    def _handle_final_response_event(
+        self,
+        ev: dict[str, Any],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        _meta: dict[str, Any],
+        skip_final_render: bool,
+    ) -> tuple[str, dict[str, Any]]:
+        """Handle final_response events."""
+        content = ev.get("content")
+        if content:
+            final_text = str(content)
+        if not skip_final_render:
+            renderer.on_event(ev)
+        return final_text, stats_usage
+
+    def _handle_run_info_event_wrapper(
+        self,
+        ev: dict[str, Any],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        meta: dict[str, Any],
+        _skip_final_render: bool,
+    ) -> tuple[str, dict[str, Any]]:
+        """Handle run_info events."""
+        self._handle_run_info_event(ev, meta, renderer)
+        return final_text, stats_usage
+
+    def _handle_render_only_event(
+        self,
+        ev: dict[str, Any],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        _meta: dict[str, Any],
+        _skip_final_render: bool,
+    ) -> tuple[str, dict[str, Any]]:
+        """Handle events that only need rendering (artifact, status_update)."""
+        renderer.on_event(ev)
+        return final_text, stats_usage
+
+    def _handle_content_event_async(
+        self,
+        ev: dict[str, Any],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        last_rendered_content: str | None,
+    ) -> tuple[str, dict[str, Any]]:
+        """Handle content events with deduplication."""
+        content = ev.get("content")
+        if content:
+            content_str = str(content)
+            if not content_str.startswith("Artifact received:"):
+                if content_str != last_rendered_content:
+                    renderer.on_event(ev)
+                final_text = content_str
+        else:
+            renderer.on_event(ev)
+        return final_text, stats_usage
+
+    def _get_event_kind(self, ev: dict[str, Any]) -> str | None:
+        """Extract normalized event kind from parsed event.
+
+        Args:
+            ev: Parsed event dictionary.
+
+        Returns:
+            Event kind string or None.
+        """
+        metadata = ev.get("metadata") or {}
+        kind = metadata.get("kind")
+        if kind:
+            return str(kind)
+        event_type = ev.get("event_type")
+        return str(event_type) if event_type else None
+
+    def _extract_content_string(self, event: dict[str, Any]) -> str | None:
+        """Extract textual content from a parsed event.
+
+        Args:
+            event: Parsed event dictionary.
+
+        Returns:
+            Content string or None.
+        """
+        if not event:
+            return None
+        content = event.get("content")
+        if content:
+            return str(content)
+        return None
+
     def _capture_request_id(
         self,
         stream_response: httpx.Response,
@@ -413,3 +668,33 @@ def compute_timeout_seconds(kwargs: dict[str, Any]) -> float:
         if not specified in kwargs.
     """
     return kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
+
+
+def finalize_render_manager(
+    manager: AgentRunRenderingManager,
+    renderer: RichStreamRenderer,
+    final_text: str,
+    stats_usage: dict[str, Any],
+    started_monotonic: float | None,
+    finished_monotonic: float | None,
+) -> str:
+    """Helper to finalize renderer via manager and return final text.
+
+    Args:
+        manager: The rendering manager instance.
+        renderer: Renderer to finalize.
+        final_text: Final text content.
+        stats_usage: Usage statistics dictionary.
+        started_monotonic: Start time (monotonic).
+        finished_monotonic: Finish time (monotonic).
+
+    Returns:
+        Final text string.
+    """
+    return manager.finalize_renderer(
+        renderer,
+        final_text,
+        stats_usage,
+        started_monotonic,
+        finished_monotonic,
+    )

glaip_sdk/runner/langgraph.py

@@ -20,25 +20,52 @@ from __future__ import annotations
 import asyncio
 import inspect
 from dataclasses import dataclass
+import logging
 from typing import TYPE_CHECKING, Any
 
+from gllm_core.utils import LoggerManager
+
 from glaip_sdk.runner.base import BaseRunner
 from glaip_sdk.runner.deps import (
     check_local_runtime_available,
     get_local_runtime_missing_message,
 )
-from glaip_sdk.utils.a2a import A2AEventStreamProcessor
-from gllm_core.utils import LoggerManager
+from glaip_sdk.client.run_rendering import AgentRunRenderingManager
 
 if TYPE_CHECKING:
     from langchain_core.messages import BaseMessage
 
     from glaip_sdk.agents.base import Agent
 
-logger = LoggerManager().get_logger(__name__)
 
-# Default A2A event processor
-_event_processor = A2AEventStreamProcessor()
+_AIP_LOGS_SWALLOWED = False
+
+
+def _swallow_aip_logs(level: int = logging.ERROR) -> None:
+    """Consume noisy AIPAgents logs once (opt-in via runner flag)."""
+    global _AIP_LOGS_SWALLOWED
+    if _AIP_LOGS_SWALLOWED:
+        return
+    prefixes = ("aip_agents.",)
+
+    def _silence(name: str) -> None:
+        lg = logging.getLogger(name)
+        lg.handlers = [logging.NullHandler()]
+        lg.propagate = False
+        lg.setLevel(level)
+
+    # Silence any already-registered loggers under the given prefixes
+    for logger_name in logging.root.manager.loggerDict:
+        if any(logger_name.startswith(prefix) for prefix in prefixes):
+            _silence(logger_name)
+
+    # Also set the base prefix loggers so future children inherit silence
+    for prefix in prefixes:
+        _silence(prefix.rstrip("."))
+    _AIP_LOGS_SWALLOWED = True
+
+
+logger = LoggerManager().get_logger(__name__)
 
 
 def _convert_chat_history_to_messages(
@@ -81,9 +108,10 @@ def _convert_chat_history_to_messages(
 class LangGraphRunner(BaseRunner):
     """Runner implementation using aip-agents LangGraphReactAgent.
 
-    MVP scope:
-    - Execute via `LangGraphReactAgent.arun_a2a_stream()`
-    - Extract and return final text from the emitted `final_response` event
+    Current behavior:
+    - Execute via `LangGraphReactAgent.arun_sse_stream()` (normalized SSE-compatible stream)
+    - Route all events through `AgentRunRenderingManager.async_process_stream_events`
+      for unified rendering between local and remote agents
 
     Attributes:
         default_model: Model name to use when agent.model is not set.
@@ -99,6 +127,8 @@ class LangGraphRunner(BaseRunner):
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
         chat_history: list[dict[str, str]] | None = None,
+        *,
+        swallow_aip_logs: bool = True,
         **kwargs: Any,
     ) -> str:
         """Execute agent synchronously and return final response text.
@@ -113,6 +143,9 @@ class LangGraphRunner(BaseRunner):
             chat_history: Optional list of prior conversation messages.
                 Each message is a dict with "role" and "content" keys.
                 Defaults to None.
+            swallow_aip_logs: When True (default), silence noisy logs from aip-agents,
+                gllm_inference, OpenAILMInvoker, and httpx. Set to False to honor user
+                logging configuration.
             **kwargs: Additional keyword arguments passed to the backend.
 
         Returns:
@@ -141,6 +174,7 @@ class LangGraphRunner(BaseRunner):
             verbose=verbose,
             runtime_config=runtime_config,
             chat_history=chat_history,
+            swallow_aip_logs=swallow_aip_logs,
             **kwargs,
         )
 
@@ -153,6 +187,8 @@ class LangGraphRunner(BaseRunner):
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
         chat_history: list[dict[str, str]] | None = None,
+        *,
+        swallow_aip_logs: bool = True,
         **kwargs: Any,
     ) -> str:
         """Execute agent asynchronously and return final response text.
@@ -167,6 +203,7 @@ class LangGraphRunner(BaseRunner):
             chat_history: Optional list of prior conversation messages.
                 Each message is a dict with "role" and "content" keys.
                 Defaults to None.
+            swallow_aip_logs: When True (default), silence noisy AIPAgents logs.
             **kwargs: Additional keyword arguments passed to the backend.
 
         Returns:
@@ -181,6 +218,7 @@ class LangGraphRunner(BaseRunner):
             verbose=verbose,
             runtime_config=runtime_config,
             chat_history=chat_history,
+            swallow_aip_logs=swallow_aip_logs,
             **kwargs,
         )
 
@@ -191,6 +229,8 @@ class LangGraphRunner(BaseRunner):
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
         chat_history: list[dict[str, str]] | None = None,
+        *,
+        swallow_aip_logs: bool = True,
         **kwargs: Any,
     ) -> str:
         """Internal async implementation of agent execution.
@@ -201,11 +241,16 @@ class LangGraphRunner(BaseRunner):
             verbose: If True, emit debug trace output during execution.
             runtime_config: Optional runtime configuration for tools, MCPs, etc.
             chat_history: Optional list of prior conversation messages.
+            swallow_aip_logs: When True (default), silence noisy AIPAgents logs.
             **kwargs: Additional keyword arguments passed to the backend.
 
         Returns:
             The final response text from the agent.
         """
+        # Optionally swallow noisy AIPAgents logs
+        if swallow_aip_logs:
+            _swallow_aip_logs()
+
         # Build the local LangGraphReactAgent from the glaip_sdk Agent
         local_agent = self.build_langgraph_agent(agent, runtime_config=runtime_config)
 
@@ -219,15 +264,42 @@ class LangGraphRunner(BaseRunner):
                 agent.name,
             )
 
-        # Collect A2AEvents from the stream and extract final response
-        events: list[dict[str, Any]] = []
+        # Use shared render manager for unified processing
+        render_manager = AgentRunRenderingManager(logger)
+        renderer = render_manager.create_renderer(kwargs.get("renderer"), verbose=verbose)
+        meta = render_manager.build_initial_metadata(agent.name, message, kwargs)
+        render_manager.start_renderer(renderer, meta)
+
+        try:
+            # Use shared async stream processor for unified event handling
+            (
+                final_text,
+                stats_usage,
+                started_monotonic,
+                finished_monotonic,
+            ) = await render_manager.async_process_stream_events(
+                local_agent.arun_sse_stream(message, **kwargs),
+                renderer,
+                meta,
+                skip_final_render=True,
+            )
+        except KeyboardInterrupt:
+            try:
+                renderer.close()
+            finally:
+                raise
+        except Exception:
+            try:
+                renderer.close()
+            finally:
+                raise
 
-        async for event in local_agent.arun_a2a_stream(message, **kwargs):
-            if verbose:
-                self._log_event(event)
-            events.append(event)
+        # Use shared finalizer to avoid code duplication
+        from glaip_sdk.client.run_rendering import finalize_render_manager  # noqa: PLC0415
 
-        return _event_processor.extract_final_response(events)
+        return finalize_render_manager(
+            render_manager, renderer, final_text, stats_usage, started_monotonic, finished_monotonic
+        )
 
     def build_langgraph_agent(
         self,
@@ -249,6 +321,7 @@ class LangGraphRunner(BaseRunner):
             ValueError: If agent has unsupported tools, MCPs, or sub-agents for local mode.
         """
         from aip_agents.agent import LangGraphReactAgent  # noqa: PLC0415
+
         from glaip_sdk.runner.tool_adapter import LangChainToolAdapter  # noqa: PLC0415
 
         # Adapt tools for local execution
@@ -572,6 +645,9 @@ class LangGraphRunner(BaseRunner):
             direct_params["planning"] = agent_config["planning"]
 
         # Kwargs parameters (passed through **kwargs to BaseAgent)
+        if "enable_pii" in agent_config:
+            kwargs_params["enable_pii"] = agent_config["enable_pii"]
+
         if "memory" in agent_config:
             # Map "memory" to "memory_backend" for aip-agents compatibility
             kwargs_params["memory_backend"] = agent_config["memory"]

{glaip_sdk-0.6.10.dist-info → glaip_sdk-0.6.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: glaip-sdk
-Version: 0.6.10
+Version: 0.6.11
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher
@@ -13,10 +13,11 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: dev
 Provides-Extra: memory
 Provides-Extra: privacy
-Requires-Dist: aip-agents-binary (>=0.5.1)
-Requires-Dist: aip-agents[memory] (>=0.5.1) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "memory")
-Requires-Dist: aip-agents[privacy] (>=0.5.1) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "privacy")
+Requires-Dist: aip-agents-binary (>=0.5.4)
+Requires-Dist: aip-agents[memory] (>=0.5.4) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "memory")
+Requires-Dist: aip-agents[privacy] (>=0.5.4) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "privacy")
 Requires-Dist: click (>=8.2.0,<8.3.0)
+Requires-Dist: en-core-web-sm ; extra == "privacy"
 Requires-Dist: gllm-core-binary (>=0.1.0)
 Requires-Dist: gllm-tools-binary (>=0.1.3)
 Requires-Dist: httpx (>=0.28.1)

{glaip_sdk-0.6.10.dist-info → glaip_sdk-0.6.11.dist-info}/RECORD

@@ -62,11 +62,11 @@ glaip_sdk/cli/validators.py,sha256=d-kq4y7HWMo6Gc7wLXWUsCt8JwFvJX_roZqRm1Nko1I,5
 glaip_sdk/client/__init__.py,sha256=F-eE_dRSzA0cc1it06oi0tZetZBHmSUjWSHGhJMLCls,263
 glaip_sdk/client/_agent_payloads.py,sha256=cH7CvNRn0JvudwKLr072E7W2QGWO9r-4xDxWMvXoPKE,17865
 glaip_sdk/client/agent_runs.py,sha256=tZSFEZZ3Yx0uYRgnwkLe-X0TlmgKJQ-ivzb6SrVnxY8,4862
-glaip_sdk/client/agents.py,sha256=33Wr5BYLN6uSN_Vwdine-9KKT030nDnsEArytN9g0lc,47580
+glaip_sdk/client/agents.py,sha256=75uDLN85Smf67rw-jFhlVKyiToicAfcFyJHSvWJkAww,47631
 glaip_sdk/client/base.py,sha256=BhNaC2TJJ2jVWRTYmfxD3WjYgAyIuWNz9YURdNXXjJo,18245
 glaip_sdk/client/main.py,sha256=RTREAOgGouYm4lFKkpNBQ9dmxalnBsIpSSaQLWVFSmU,9054
 glaip_sdk/client/mcps.py,sha256=gFRuLOGeh6ieIhR4PeD6yNVT6NhvUMTqPq9iuu1vkAY,13019
-glaip_sdk/client/run_rendering.py,sha256=ubBO-NzyZoYRELNwxVvrQFRGQVJCuLfqqJNiXrBZDoQ,14223
+glaip_sdk/client/run_rendering.py,sha256=j0BTDfy13lFX-B4T-Own-NtmqefoRGQ4M5DM6QRkiTs,24109
 glaip_sdk/client/shared.py,sha256=esHlsR0LEfL-pFDaWebQjKKOLl09jsRY-2pllBUn4nU,522
 glaip_sdk/client/tools.py,sha256=kK0rBwX1e_5AlGQRjlO6rNz6gDlohhXWdlxN9AwotdE,22585
 glaip_sdk/client/validators.py,sha256=ioF9VCs-LG2yLkaRDd7Hff74lojDZZ0_Q3CiLbdm1RY,8381
@@ -92,7 +92,7 @@ glaip_sdk/rich_components.py,sha256=44Z0V1ZQleVh9gUDGwRR5mriiYFnVGOhm7fFxZYbP8c,
 glaip_sdk/runner/__init__.py,sha256=8RrngoGfpF8x9X27RPdX4gJjch75ZvhtVt_6UV0ULLQ,1615
 glaip_sdk/runner/base.py,sha256=KIjcSAyDCP9_mn2H4rXR5gu1FZlwD9pe0gkTBmr6Yi4,2663
 glaip_sdk/runner/deps.py,sha256=3ZDWyvWu4LFJOGHd18tv3VzVo8NY5gb1VeZIelMknyI,3934
-glaip_sdk/runner/langgraph.py,sha256=N9jhuCI-7dS6gzrsKzG6xT3CGWKuo7GEpEwfszgORVo,26050
+glaip_sdk/runner/langgraph.py,sha256=97fCY4BwBj-APID3e4qQUUwXLEDbrxTyTqHhN2Z7RcA,28811
 glaip_sdk/runner/mcp_adapter/__init__.py,sha256=Rdttfg3N6kg3-DaTCKqaGXKByZyBt0Mwf6FV8s_5kI8,462
 glaip_sdk/runner/mcp_adapter/base_mcp_adapter.py,sha256=ic56fKgb3zgVZZQm3ClWUZi7pE1t4EVq8mOg6AM6hdA,1374
 glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py,sha256=b58GuadPz7q7aXoJyTYs0eeJ_oqp-wLR1tcr_5cbV1s,9723
@@ -153,7 +153,7 @@ glaip_sdk/utils/serialization.py,sha256=z-qpvWLSBrGK3wbUclcA1UIKLXJedTnMSwPdq-FF
 glaip_sdk/utils/sync.py,sha256=3VKqs1UfNGWSobgRXohBKP7mMMzdUW3SU0bJQ1uxOgw,4872
 glaip_sdk/utils/tool_detection.py,sha256=g410GNug_PhLye8rd9UU-LVFIKq3jHPbmSItEkLxPTc,807
 glaip_sdk/utils/validation.py,sha256=hB_k3lvHdIFUiSwHStrC0Eqnhx0OG2UvwqASeem0HuQ,6859
-glaip_sdk-0.6.10.dist-info/METADATA,sha256=_jG2ijWHtyGN1NgL1F9l-D5iG2EEv87RzWcp6aI2jxE,7920
-glaip_sdk-0.6.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-glaip_sdk-0.6.10.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
-glaip_sdk-0.6.10.dist-info/RECORD,,
+glaip_sdk-0.6.11.dist-info/METADATA,sha256=QVzKd6VTTlmr4-YA5D_ECf2w5XM14RAPpcT9RZq5Lms,7971
+glaip_sdk-0.6.11.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+glaip_sdk-0.6.11.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
+glaip_sdk-0.6.11.dist-info/RECORD,,