glaip-sdk 0.0.20__py3-none-any.whl → 0.1.3__py3-none-any.whl

glaip_sdk/client/run_rendering.py

@@ -23,6 +23,54 @@ from glaip_sdk.utils.rendering.renderer import RichStreamRenderer
 from glaip_sdk.utils.rendering.renderer.config import RendererConfig
 
 
+def _coerce_to_string(value: Any) -> str:
+    """Return a best-effort string representation for transcripts."""
+    try:
+        return str(value)
+    except Exception:
+        return f"{value}"
+
+
+def _has_visible_text(value: Any) -> bool:
+    """Return True when the value is a non-empty string."""
+    return isinstance(value, str) and bool(value.strip())
+
+
+def _update_state_transcript(state: Any, text_value: str) -> bool:
+    """Inject transcript text into renderer state if possible."""
+    if state is None:
+        return False
+
+    updated = False
+
+    if hasattr(state, "final_text") and not _has_visible_text(getattr(state, "final_text", "")):
+        try:
+            state.final_text = text_value
+            updated = True
+        except Exception:
+            pass
+
+    buffer = getattr(state, "buffer", None)
+    if isinstance(buffer, list) and not any(_has_visible_text(item) for item in buffer):
+        buffer.append(text_value)
+        updated = True
+
+    return updated
+
+
+def _update_renderer_transcript(renderer: Any, text_value: str) -> None:
+    """Populate the renderer (or its state) with the supplied text."""
+    state = getattr(renderer, "state", None)
+    if _update_state_transcript(state, text_value):
+        return
+
+    if hasattr(renderer, "final_text") and not _has_visible_text(getattr(renderer, "final_text", "")):
+        try:
+            renderer.final_text = text_value
+        except Exception:
+            pass
+
+
 class AgentRunRenderingManager:
     """Coordinate renderer creation and streaming event handling."""
 
@@ -79,7 +127,6 @@ class AgentRunRenderingManager:
         silent_config = RendererConfig(
             live=False,
             persist_live=False,
-            show_delegate_tool_panels=False,
             render_thinking=False,
         )
         return RichStreamRenderer(
@@ -92,7 +139,6 @@ class AgentRunRenderingManager:
         minimal_config = RendererConfig(
             live=False,
             persist_live=False,
-            show_delegate_tool_panels=False,
             render_thinking=False,
         )
         return RichStreamRenderer(
@@ -103,10 +149,7 @@ class AgentRunRenderingManager:
 
     def _create_verbose_renderer(self) -> RichStreamRenderer:
         verbose_config = RendererConfig(
-            theme="dark",
-            style="debug",
             live=False,
-            show_delegate_tool_panels=False,
             append_finished_snapshots=False,
         )
         return RichStreamRenderer(
@@ -139,17 +182,28 @@ class AgentRunRenderingManager:
 
         self._capture_request_id(stream_response, meta, renderer)
 
-        for event in iter_sse_events(stream_response, timeout_seconds, agent_name):
-            if started_monotonic is None:
-                started_monotonic = self._maybe_start_timer(event)
+        controller = getattr(renderer, "transcript_controller", None)
+        if controller and getattr(controller, "enabled", False):
+            controller.on_stream_start(renderer)
 
-            final_text, stats_usage = self._process_single_event(
-                event,
-                renderer,
-                final_text,
-                stats_usage,
-                meta,
-            )
+        try:
+            for event in iter_sse_events(stream_response, timeout_seconds, agent_name):
+                if started_monotonic is None:
+                    started_monotonic = self._maybe_start_timer(event)
+
+                final_text, stats_usage = self._process_single_event(
+                    event,
+                    renderer,
+                    final_text,
+                    stats_usage,
+                    meta,
+                )
+
+                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
@@ -160,9 +214,7 @@ class AgentRunRenderingManager:
         meta: dict[str, Any],
         renderer: RichStreamRenderer,
     ) -> None:
-        req_id = stream_response.headers.get(
-            "x-request-id"
-        ) or stream_response.headers.get("x-run-id")
+        req_id = stream_response.headers.get("x-request-id") or stream_response.headers.get("x-run-id")
         if req_id:
             meta["run_id"] = req_id
             renderer.on_start(meta)
@@ -194,19 +246,50 @@ class AgentRunRenderingManager:
         kind = (ev.get("metadata") or {}).get("kind")
         renderer.on_event(ev)
 
+        handled = self._handle_metadata_kind(
+            kind,
+            ev,
+            final_text,
+            stats_usage,
+            meta,
+            renderer,
+        )
+        if handled is not None:
+            return handled
+
+        if ev.get("content"):
+            final_text = self._handle_content_event(ev, final_text)
+
+        return final_text, stats_usage
+
+    def _handle_metadata_kind(
+        self,
+        kind: str | None,
+        ev: dict[str, Any],
+        final_text: str,
+        stats_usage: dict[str, Any],
+        meta: dict[str, Any],
+        renderer: RichStreamRenderer,
+    ) -> tuple[str, dict[str, Any]] | None:
+        """Process well-known metadata kinds and return updated state."""
         if kind == "artifact":
             return final_text, stats_usage
 
-        if kind == "final_response" and ev.get("content"):
-            final_text = ev.get("content", "")
-        elif ev.get("content"):
-            final_text = self._handle_content_event(ev, final_text)
-        elif kind == "usage":
+        if kind == "final_response":
+            content = ev.get("content")
+            if content:
+                return content, stats_usage
+            return final_text, stats_usage
+
+        if kind == "usage":
             stats_usage.update(ev.get("usage") or {})
-        elif kind == "run_info":
+            return final_text, stats_usage
+
+        if kind == "run_info":
             self._handle_run_info_event(ev, meta, renderer)
+            return final_text, stats_usage
 
-        return final_text, stats_usage
+        return None
 
     def _handle_content_event(self, ev: dict[str, Any], final_text: str) -> str:
         content = ev.get("content", "")
@@ -227,6 +310,14 @@ class AgentRunRenderingManager:
             meta["run_id"] = ev["run_id"]
             renderer.on_start(meta)
 
+    def _ensure_renderer_final_content(self, renderer: RichStreamRenderer, text: str) -> None:
+        """Populate renderer state with final output when the stream omits it."""
+        if not text:
+            return
+
+        text_value = _coerce_to_string(text)
+        _update_renderer_transcript(renderer, text_value)
+
     # --------------------------------------------------------------------- #
     # Finalisation helpers
     # --------------------------------------------------------------------- #
@@ -250,7 +341,7 @@ class AgentRunRenderingManager:
         if hasattr(renderer, "state") and hasattr(renderer.state, "buffer"):
             buffer_values = renderer.state.buffer
         elif hasattr(renderer, "buffer"):
-            buffer_values = getattr(renderer, "buffer")
+            buffer_values = renderer.buffer
 
         if buffer_values is not None:
             try:
@@ -258,6 +349,10 @@ class AgentRunRenderingManager:
             except TypeError:
                 rendered_text = ""
 
+        fallback_text = final_text or rendered_text
+        if fallback_text:
+            self._ensure_renderer_final_content(renderer, fallback_text)
+
         renderer.on_complete(st)
         return final_text or rendered_text or "No response content received."
 

glaip_sdk/client/tools.py

@@ -96,9 +96,7 @@ class ToolClient(BaseClient):
         """
         return os.path.splitext(os.path.basename(file_path))[0]
 
-    def _prepare_upload_data(
-        self, name: str, framework: str, description: str | None = None, **kwargs
-    ) -> dict:
+    def _prepare_upload_data(self, name: str, framework: str, description: str | None = None, **kwargs) -> dict:
         """Prepare upload data dictionary.
 
         Args:
@@ -217,29 +215,21 @@ class ToolClient(BaseClient):
         elif hasattr(current_tool, "description") and current_tool.description:
             update_data["description"] = current_tool.description
 
-    def _handle_tags_update(
-        self, update_data: dict[str, Any], kwargs: dict[str, Any], current_tool: Tool
-    ) -> None:
+    def _handle_tags_update(self, update_data: dict[str, Any], kwargs: dict[str, Any], current_tool: Tool) -> None:
         """Handle tags field in update payload."""
         if kwargs.get("tags"):
             if isinstance(kwargs["tags"], list):
-                update_data["tags"] = ",".join(
-                    str(tag).strip() for tag in kwargs["tags"]
-                )
+                update_data["tags"] = ",".join(str(tag).strip() for tag in kwargs["tags"])
             else:
                 update_data["tags"] = str(kwargs["tags"])
         elif hasattr(current_tool, "tags") and current_tool.tags:
             # Preserve existing tags if present
             if isinstance(current_tool.tags, list):
-                update_data["tags"] = ",".join(
-                    str(tag).strip() for tag in current_tool.tags
-                )
+                update_data["tags"] = ",".join(str(tag).strip() for tag in current_tool.tags)
             else:
                 update_data["tags"] = str(current_tool.tags)
 
-    def _handle_additional_kwargs(
-        self, update_data: dict[str, Any], kwargs: dict[str, Any]
-    ) -> None:
+    def _handle_additional_kwargs(self, update_data: dict[str, Any], kwargs: dict[str, Any]) -> None:
         """Handle additional kwargs in update payload."""
         excluded_keys = {
             "tags",
@@ -290,12 +280,8 @@ class ToolClient(BaseClient):
         update_data = {
             "name": name if name is not None else current_tool.name,
             "type": current_type,
-            "framework": kwargs.get(
-                "framework", getattr(current_tool, "framework", DEFAULT_TOOL_FRAMEWORK)
-            ),
-            "version": kwargs.get(
-                "version", getattr(current_tool, "version", DEFAULT_TOOL_VERSION)
-            ),
+            "framework": kwargs.get("framework", getattr(current_tool, "framework", DEFAULT_TOOL_FRAMEWORK)),
+            "version": kwargs.get("version", getattr(current_tool, "version", DEFAULT_TOOL_VERSION)),
         }
 
         # Handle description update
@@ -355,9 +341,7 @@ class ToolClient(BaseClient):
 
         try:
             # Prepare upload data
-            upload_data = self._prepare_upload_data(
-                name=name, framework=framework, description=description, **kwargs
-            )
+            upload_data = self._prepare_upload_data(name=name, framework=framework, description=description, **kwargs)
 
             # Upload file
             return self._upload_tool_file(temp_file_path, upload_data)

glaip_sdk/client/validators.py

@@ -39,9 +39,7 @@ class ResourceValidator:
         if len(found_tools) == 1:
             return str(found_tools[0].id)
         elif len(found_tools) > 1:
-            raise AmbiguousResourceError(
-                f"Multiple tools found with name '{tool_name}': {[t.id for t in found_tools]}"
-            )
+            raise AmbiguousResourceError(f"Multiple tools found with name '{tool_name}': {[t.id for t in found_tools]}")
         else:
             raise NotFoundError(f"Tool not found: {tool_name}")
 
@@ -51,9 +49,7 @@ class ResourceValidator:
         if len(found_tools) == 1:
             return str(found_tools[0].id)
         elif len(found_tools) > 1:
-            raise AmbiguousResourceError(
-                f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}"
-            )
+            raise AmbiguousResourceError(f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}")
         else:
             raise NotFoundError(f"Tool not found: {tool.name}")
 
@@ -73,9 +69,7 @@ class ResourceValidator:
         elif hasattr(tool, "name") and tool.name is not None:
             return self._resolve_tool_by_name_attribute(tool, client)
         else:
-            raise ValidationError(
-                f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute"
-            )
+            raise ValidationError(f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute")
 
     def _process_single_tool(self, tool: str | Tool, client: Any) -> str:
         """Process a single tool reference and return its ID."""
@@ -99,22 +93,14 @@ class ResourceValidator:
             try:
                 tool_id = cls()._process_single_tool(tool, client)
                 tool_ids.append(tool_id)
-            except (AmbiguousResourceError, NotFoundError) as e:
+            except (AmbiguousResourceError, NotFoundError) as err:
                 # Determine the tool name for the error message
-                tool_name = (
-                    tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
-                )
-                raise ValidationError(
-                    f"Failed to resolve tool name '{tool_name}' to ID: {e}"
-                )
-            except Exception as e:
+                tool_name = tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                raise ValidationError(f"Failed to resolve tool name '{tool_name}' to ID: {err}") from err
+            except Exception as err:
                 # For other exceptions, wrap them appropriately
-                tool_name = (
-                    tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
-                )
-                raise ValidationError(
-                    f"Failed to resolve tool name '{tool_name}' to ID: {e}"
-                )
+                tool_name = tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                raise ValidationError(f"Failed to resolve tool name '{tool_name}' to ID: {err}") from err
 
         return tool_ids
 
@@ -158,9 +144,7 @@ class ResourceValidator:
         elif hasattr(agent, "name") and agent.name is not None:
             return self._resolve_agent_by_name_attribute(agent, client)
         else:
-            raise ValidationError(
-                f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute"
-            )
+            raise ValidationError(f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute")
 
     def _process_single_agent(self, agent: str | Any, client: Any) -> str:
         """Process a single agent reference and return its ID."""
@@ -184,26 +168,14 @@ class ResourceValidator:
             try:
                 agent_id = cls()._process_single_agent(agent, client)
                 agent_ids.append(agent_id)
-            except (AmbiguousResourceError, NotFoundError) as e:
+            except (AmbiguousResourceError, NotFoundError) as err:
                 # Determine the agent name for the error message
-                agent_name = (
-                    agent
-                    if isinstance(agent, str)
-                    else getattr(agent, "name", str(agent))
-                )
-                raise ValidationError(
-                    f"Failed to resolve agent name '{agent_name}' to ID: {e}"
-                )
-            except Exception as e:
+                agent_name = agent if isinstance(agent, str) else getattr(agent, "name", str(agent))
+                raise ValidationError(f"Failed to resolve agent name '{agent_name}' to ID: {err}") from err
+            except Exception as err:
                 # For other exceptions, wrap them appropriately
-                agent_name = (
-                    agent
-                    if isinstance(agent, str)
-                    else getattr(agent, "name", str(agent))
-                )
-                raise ValidationError(
-                    f"Failed to resolve agent name '{agent_name}' to ID: {e}"
-                )
+                agent_name = agent if isinstance(agent, str) else getattr(agent, "name", str(agent))
+                raise ValidationError(f"Failed to resolve agent name '{agent_name}' to ID: {err}") from err
 
         return agent_ids
 
@@ -213,8 +185,8 @@ class ResourceValidator:
         for tool_id in tool_ids:
             try:
                 client.get_tool_by_id(tool_id)
-            except NotFoundError:
-                raise ValidationError(f"Tool not found: {tool_id}")
+            except NotFoundError as err:
+                raise ValidationError(f"Tool not found: {tool_id}") from err
 
     @classmethod
     def validate_agents_exist(cls, agent_ids: list[str], client: Any) -> None:
@@ -222,5 +194,5 @@ class ResourceValidator:
         for agent_id in agent_ids:
             try:
                 client.get_agent_by_id(agent_id)
-            except NotFoundError:
-                raise ValidationError(f"Agent not found: {agent_id}")
+            except NotFoundError as err:
+                raise ValidationError(f"Agent not found: {agent_id}") from err

glaip_sdk/exceptions.py

@@ -107,9 +107,7 @@ class AgentTimeoutError(TimeoutError):
             agent_name: Optional name of the agent that timed out
         """
         agent_info = f" for agent '{agent_name}'" if agent_name else ""
-        message = (
-            f"Agent execution timed out after {timeout_seconds} seconds{agent_info}"
-        )
+        message = f"Agent execution timed out after {timeout_seconds} seconds{agent_info}"
         super().__init__(message)
         self.timeout_seconds = timeout_seconds
         self.agent_name = agent_name

glaip_sdk/icons.py

@@ -5,10 +5,13 @@ Authors:
 """
 
 ICON_AGENT = "🤖"
-ICON_AGENT_STEP = "🧠"
+ICON_AGENT_STEP = "🤖"
 ICON_TOOL = "🔧"
-ICON_TOOL_STEP = "⚙️"
-ICON_DELEGATE = ICON_AGENT
+ICON_TOOL_STEP = "🔧"
+ICON_DELEGATE = ICON_AGENT_STEP
+ICON_STATUS_SUCCESS = "✓"
+ICON_STATUS_FAILED = "✗"
+ICON_STATUS_WARNING = "⚠"
 
 __all__ = [
     "ICON_AGENT",
@@ -16,4 +19,7 @@ __all__ = [
     "ICON_TOOL",
     "ICON_TOOL_STEP",
     "ICON_DELEGATE",
+    "ICON_STATUS_SUCCESS",
+    "ICON_STATUS_FAILED",
+    "ICON_STATUS_WARNING",
 ]

glaip_sdk/models.py

@@ -13,6 +13,9 @@ from pydantic import BaseModel
 
 from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
 
+_AGENT_CLIENT_REQUIRED_MSG = "No client available. Use client.get_agent_by_id() to get a client-connected agent."
+_MCP_CLIENT_REQUIRED_MSG = "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
+
 
 class Agent(BaseModel):
     """Agent model for API responses."""
@@ -27,9 +30,7 @@ class Agent(BaseModel):
     tools: list[dict[str, Any]] | None = None  # Backend returns ToolReference objects
     agents: list[dict[str, Any]] | None = None  # Backend returns AgentReference objects
     mcps: list[dict[str, Any]] | None = None  # Backend returns MCPReference objects
-    tool_configs: dict[str, Any] | None = (
-        None  # Backend returns tool configurations keyed by tool UUID
-    )
+    tool_configs: dict[str, Any] | None = None  # Backend returns tool configurations keyed by tool UUID
     agent_config: dict[str, Any] | None = None
     timeout: int = DEFAULT_AGENT_RUN_TIMEOUT
     metadata: dict[str, Any] | None = None
@@ -53,9 +54,7 @@ class Agent(BaseModel):
             **kwargs: Additional arguments passed to run_agent
         """
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         # Automatically pass the agent name for better renderer display
         kwargs.setdefault("agent_name", self.name)
         # Pass the agent's configured timeout if not explicitly overridden
@@ -80,9 +79,7 @@ class Agent(BaseModel):
             Exception: For other unexpected errors
         """
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         # Automatically pass the agent name for better context
         kwargs.setdefault("agent_name", self.name)
         # Pass the agent's configured timeout if not explicitly overridden
@@ -95,9 +92,7 @@ class Agent(BaseModel):
     def update(self, **kwargs) -> "Agent":
         """Update agent attributes."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         updated_agent = self._client.update_agent(self.id, **kwargs)
         # Update current instance with new data
         for key, value in updated_agent.model_dump().items():
@@ -108,9 +103,7 @@ class Agent(BaseModel):
     def delete(self) -> None:
         """Delete the agent."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_agent_by_id() to get a client-connected agent."
-            )
+            raise RuntimeError(_AGENT_CLIENT_REQUIRED_MSG)
         self._client.delete_agent(self.id)
 
 
@@ -149,16 +142,12 @@ class Tool(BaseModel):
         Pass 'file' parameter to update tool code via file upload.
         """
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_tool_by_id() to get a client-connected tool."
-            )
+            raise RuntimeError("No client available. Use client.get_tool_by_id() to get a client-connected tool.")
 
         # Check if file upload is requested
         if "file" in kwargs:
             file_path = kwargs.pop("file")  # Remove file from kwargs for metadata
-            updated_tool = self._client.tools.update_tool_via_file(
-                self.id, file_path, **kwargs
-            )
+            updated_tool = self._client.tools.update_tool_via_file(self.id, file_path, **kwargs)
         else:
             # Regular metadata update
             updated_tool = self._client.tools.update_tool(self.id, **kwargs)
@@ -172,9 +161,7 @@ class Tool(BaseModel):
     def delete(self) -> None:
         """Delete the tool."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_tool_by_id() to get a client-connected tool."
-            )
+            raise RuntimeError("No client available. Use client.get_tool_by_id() to get a client-connected tool.")
         self._client.delete_tool(self.id)
 
 
@@ -198,9 +185,7 @@ class MCP(BaseModel):
     def get_tools(self) -> list[dict[str, Any]]:
         """Get tools available from this MCP."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
-            )
+            raise RuntimeError(_MCP_CLIENT_REQUIRED_MSG)
         # This would delegate to the client's MCP tools endpoint
         # For now, return empty list as placeholder
         return []
@@ -208,9 +193,7 @@ class MCP(BaseModel):
     def update(self, **kwargs) -> "MCP":
         """Update MCP attributes."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
-            )
+            raise RuntimeError(_MCP_CLIENT_REQUIRED_MSG)
         updated_mcp = self._client.update_mcp(self.id, **kwargs)
         # Update current instance with new data
         for key, value in updated_mcp.model_dump().items():
@@ -221,9 +204,7 @@ class MCP(BaseModel):
     def delete(self) -> None:
         """Delete the MCP."""
         if not self._client:
-            raise RuntimeError(
-                "No client available. Use client.get_mcp_by_id() to get a client-connected MCP."
-            )
+            raise RuntimeError("No client available. Use client.get_mcp_by_id() to get a client-connected MCP.")
         self._client.delete_mcp(self.id)
 
 

glaip_sdk/payload_schemas/agent.py

@@ -60,9 +60,7 @@ AGENT_FIELD_RULES: Mapping[str, FieldRule] = {
 }
 
 
-def get_import_field_plan(
-    field_name: str, operation: AgentImportOperation
-) -> ImportFieldPlan:
+def get_import_field_plan(field_name: str, operation: AgentImportOperation) -> ImportFieldPlan:
     """Return the import handling plan for ``field_name`` under ``operation``.
 
     Unknown fields default to being copied as-is so new API fields propagate

glaip_sdk/utils/agent_config.py

@@ -54,17 +54,11 @@ def sanitize_agent_config(
         cfg = agent_config or {}
 
     if strip_lm_identity and isinstance(cfg, dict):
-        cfg = {
-            k: v
-            for k, v in cfg.items()
-            if k not in {"lm_provider", "lm_name", "lm_base_url"}
-        }
+        cfg = {k: v for k, v in cfg.items() if k not in {"lm_provider", "lm_name", "lm_base_url"}}
     return cfg
 
 
-def resolve_language_model_selection(
-    merged_data: dict[str, Any], cli_model: str | None
-) -> tuple[dict[str, Any], bool]:
+def resolve_language_model_selection(merged_data: dict[str, Any], cli_model: str | None) -> tuple[dict[str, Any], bool]:
     """Resolve language model selection from merged data and CLI args.
 
     Implements the LM selection priority:
@@ -98,17 +92,13 @@ def resolve_language_model_selection(
     # Priority 3: Legacy lm_name from agent_config
     agent_config = merged_data.get("agent_config") or {}
     if isinstance(agent_config, dict) and agent_config.get("lm_name"):
-        return {
-            "model": agent_config["lm_name"]
-        }, True  # Strip LM identity when extracting from agent_config
+        return {"model": agent_config["lm_name"]}, True  # Strip LM identity when extracting from agent_config
 
     # No LM selection found
     return {}, False
 
 
-def normalize_agent_config_for_import(
-    agent_data: dict[str, Any], cli_model: str | None = None
-) -> dict[str, Any]:
+def normalize_agent_config_for_import(agent_data: dict[str, Any], cli_model: str | None = None) -> dict[str, Any]:
     """Automatically normalize agent configuration by extracting LM settings from agent_config.
 
     This function addresses the common issue where exported agent configurations contain