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

glaip_sdk/client/_agent_payloads.py

@@ -348,9 +348,7 @@ class AgentCreateRequest:
             payload["tool_configs"] = _copy_structure(self.tool_configs)
 
         effective_agent_config = _sanitize_agent_config(self.agent_config)
-        effective_agent_config = _merge_execution_timeout(
-            effective_agent_config, self.timeout
-        )
+        effective_agent_config = _merge_execution_timeout(effective_agent_config, self.timeout)
         if effective_agent_config:
             payload["agent_config"] = effective_agent_config
 
@@ -407,31 +405,19 @@ __all__ = [
 ]
 
 
-def _build_base_update_payload(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _build_base_update_payload(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     return {
-        "name": request.name.strip()
-        if request.name is not None
-        else getattr(current_agent, "name", None),
+        "name": request.name.strip() if request.name is not None else getattr(current_agent, "name", None),
         "instruction": request.instruction.strip()
         if request.instruction is not None
         else getattr(current_agent, "instruction", None),
-        "type": request.agent_type
-        or getattr(current_agent, "type", None)
-        or DEFAULT_AGENT_TYPE,
-        "framework": request.framework
-        or getattr(current_agent, "framework", None)
-        or DEFAULT_AGENT_FRAMEWORK,
-        "version": request.version
-        or getattr(current_agent, "version", None)
-        or DEFAULT_AGENT_VERSION,
+        "type": request.agent_type or getattr(current_agent, "type", None) or DEFAULT_AGENT_TYPE,
+        "framework": request.framework or getattr(current_agent, "framework", None) or DEFAULT_AGENT_FRAMEWORK,
+        "version": request.version or getattr(current_agent, "version", None) or DEFAULT_AGENT_VERSION,
     }
 
 
-def _resolve_update_language_model_fields(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _resolve_update_language_model_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     fields = resolve_language_model_fields(
         model=request.model,
         language_model_id=request.language_model_id,
@@ -443,9 +429,7 @@ def _resolve_update_language_model_fields(
     return fields
 
 
-def _collect_optional_update_fields(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _collect_optional_update_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     result: dict[str, Any] = {}
 
     for field_name, value in (
@@ -483,9 +467,7 @@ def _collect_optional_update_fields(
     return result
 
 
-def _collect_relationship_fields(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _collect_relationship_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     return {
         "tools": _resolve_relation_ids(request.tools, current_agent, "tools"),
         "agents": _resolve_relation_ids(request.agents, current_agent, "agents"),
@@ -493,9 +475,7 @@ def _collect_relationship_fields(
     }
 
 
-def _resolve_agent_config_update(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any] | None:
+def _resolve_agent_config_update(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any] | None:
     effective_agent_config = _sanitize_agent_config(request.agent_config)
     if effective_agent_config is not None:
         return effective_agent_config

glaip_sdk/client/agents.py

@@ -34,7 +34,7 @@ from glaip_sdk.config.constants import (
     DEFAULT_AGENT_VERSION,
     DEFAULT_MODEL,
 )
-from glaip_sdk.exceptions import NotFoundError
+from glaip_sdk.exceptions import NotFoundError, ValidationError
 from glaip_sdk.models import Agent
 from glaip_sdk.payload_schemas.agent import list_server_only_fields
 from glaip_sdk.utils.agent_config import normalize_agent_config_for_import
@@ -97,9 +97,7 @@ def _merge_override_maps(
         for key, value in source.items():
             if value is None:
                 continue
-            merged[key] = (
-                _normalise_sequence(value) if key in _MERGED_SEQUENCE_FIELDS else value
-            )
+            merged[key] = _normalise_sequence(value) if key in _MERGED_SEQUENCE_FIELDS else value
     return merged
 
 
@@ -134,9 +132,7 @@ def _prepare_agent_metadata(value: Any) -> dict[str, Any]:
     return prepared
 
 
-def _load_agent_file_payload(
-    file_path: Path, *, model_override: str | None
-) -> dict[str, Any]:
+def _load_agent_file_payload(file_path: Path, *, model_override: str | None) -> dict[str, Any]:
     """Load agent configuration from disk and normalise legacy fields."""
     if not file_path.exists():
         raise FileNotFoundError(f"Agent configuration file not found: {file_path}")
@@ -168,9 +164,7 @@ def _prepare_import_payload(
     raw_definition = load_resource_from_file(file_path)
     original_refs = _extract_original_refs(raw_definition)
 
-    base_payload = _load_agent_file_payload(
-        file_path, model_override=overrides_dict.get("model")
-    )
+    base_payload = _load_agent_file_payload(file_path, model_override=overrides_dict.get("model"))
 
     cli_args = _build_cli_args(overrides_dict)
 
@@ -223,11 +217,7 @@ def _build_cli_args(overrides_dict: dict) -> dict[str, Any]:
 
 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
-    }
+    return {key: value for key, value in overrides_dict.items() if value is not None and key not in cli_args}
 
 
 def _remove_model_fields_if_needed(merged: dict, overrides_dict: dict) -> None:
@@ -278,9 +268,7 @@ class AgentClient(BaseClient):
         """
         if query is not None and kwargs:
             # Both query object and individual parameters provided
-            raise ValueError(
-                "Provide either `query` or individual filter arguments, not both."
-            )
+            raise ValueError("Provide either `query` or individual filter arguments, not both.")
 
         if query is None:
             # Create query from individual parameters for backward compatibility
@@ -339,7 +327,19 @@ class AgentClient(BaseClient):
 
     def get_agent_by_id(self, agent_id: str) -> Agent:
         """Get agent by ID."""
-        data = self._request("GET", f"/agents/{agent_id}")
+        try:
+            data = self._request("GET", f"/agents/{agent_id}")
+        except ValidationError as exc:
+            if exc.status_code == 422:
+                message = f"Agent '{agent_id}' not found"
+                raise NotFoundError(
+                    message,
+                    status_code=404,
+                    error_type=exc.error_type,
+                    payload=exc.payload,
+                    request_id=exc.request_id,
+                ) from exc
+            raise
 
         if isinstance(data, str):
             # Some backends may respond with plain text for missing agents.
@@ -372,9 +372,7 @@ class AgentClient(BaseClient):
             self._renderer_manager = manager
         return manager
 
-    def _create_renderer(
-        self, renderer: RichStreamRenderer | str | None, **kwargs: Any
-    ) -> RichStreamRenderer:
+    def _create_renderer(self, renderer: RichStreamRenderer | str | None, **kwargs: Any) -> RichStreamRenderer:
         manager = self._get_renderer_manager()
         verbose = kwargs.get("verbose", False)
         if isinstance(renderer, RichStreamRenderer) or hasattr(renderer, "on_start"):
@@ -506,9 +504,7 @@ class AgentClient(BaseClient):
             return entry_id
 
         if entry_name:
-            resolved, success = self._resolve_resource_by_name(
-                find_by_name, entry_name, singular, plural
-            )
+            resolved, success = self._resolve_resource_by_name(find_by_name, entry_name, singular, plural)
             return resolved if success else entry_name
 
         raise ValueError(f"{singular} references must include a valid ID or name.")
@@ -523,9 +519,7 @@ class AgentClient(BaseClient):
         return str(entry)
 
     @staticmethod
-    def _validate_resource_id(
-        fetch_by_id: Callable[[str], Any], candidate_id: str | None
-    ) -> str | None:
+    def _validate_resource_id(fetch_by_id: Callable[[str], Any], candidate_id: str | None) -> str | None:
         if not candidate_id:
             return None
         try:
@@ -547,21 +541,13 @@ class AgentClient(BaseClient):
             return entry_name, False
 
         if not matches:
-            raise ValueError(
-                f"{singular} '{entry_name}' not found in current workspace."
-            )
+            raise ValueError(f"{singular} '{entry_name}' not found in current workspace.")
         if len(matches) > 1:
-            exact = [
-                m
-                for m in matches
-                if getattr(m, "name", "").lower() == entry_name.lower()
-            ]
+            exact = [m for m in matches if getattr(m, "name", "").lower() == entry_name.lower()]
             if len(exact) == 1:
                 matches = exact
             else:
-                raise ValueError(
-                    f"Multiple {plural} named '{entry_name}'. Please disambiguate."
-                )
+                raise ValueError(f"Multiple {plural} named '{entry_name}'. Please disambiguate.")
         return str(matches[0].id), True
 
     def _resolve_tool_ids(
@@ -610,9 +596,7 @@ class AgentClient(BaseClient):
 
     def _create_agent_from_payload(self, payload: Mapping[str, Any]) -> "Agent":
         """Create an agent using a fully prepared payload mapping."""
-        known, extras = _split_known_and_extra(
-            payload, AgentCreateRequest.__dataclass_fields__
-        )
+        known, extras = _split_known_and_extra(payload, AgentCreateRequest.__dataclass_fields__)
 
         name = known.pop("name", None)
         instruction = known.pop("instruction", None)
@@ -721,9 +705,7 @@ class AgentClient(BaseClient):
         overrides = _merge_override_maps(base_overrides, kwargs)
 
         if file is not None:
-            payload = _prepare_import_payload(
-                Path(file).expanduser(), overrides, drop_model_fields=True
-            )
+            payload = _prepare_import_payload(Path(file).expanduser(), overrides, drop_model_fields=True)
             if overrides.get("model") is None:
                 payload.pop("model", None)
         else:
@@ -746,9 +728,7 @@ class AgentClient(BaseClient):
         payload: Mapping[str, Any],
     ) -> "Agent":
         """Update an agent using a prepared payload mapping."""
-        known, extras = _split_known_and_extra(
-            payload, AgentUpdateRequest.__dataclass_fields__
-        )
+        known, extras = _split_known_and_extra(payload, AgentUpdateRequest.__dataclass_fields__)
         _normalise_sequence_fields(known)
 
         tool_refs = extras.pop("_tool_refs", None)
@@ -818,9 +798,7 @@ class AgentClient(BaseClient):
         overrides = _merge_override_maps(base_overrides, kwargs)
 
         if file is not None:
-            payload = _prepare_import_payload(
-                Path(file).expanduser(), overrides, drop_model_fields=True
-            )
+            payload = _prepare_import_payload(Path(file).expanduser(), overrides, drop_model_fields=True)
         else:
             payload = overrides
 
@@ -882,9 +860,7 @@ class AgentClient(BaseClient):
                 payload["tty"] = True
             return payload, None, None, headers, None
 
-    def _get_timeout_values(
-        self, timeout: float | None, **kwargs: Any
-    ) -> tuple[float, float]:
+    def _get_timeout_values(self, timeout: float | None, **kwargs: Any) -> tuple[float, float]:
         """Get request timeout and execution timeout values.
 
         Args:
@@ -1009,9 +985,7 @@ class AgentClient(BaseClient):
             headers = {"Accept": SSE_CONTENT_TYPE}
             return payload, None, None, headers
 
-    def _create_async_client_config(
-        self, timeout: float | None, headers: dict | None
-    ) -> dict:
+    def _create_async_client_config(self, timeout: float | None, headers: dict | None) -> dict:
         """Create async client configuration with proper headers and timeout."""
         config = self._build_async_client(timeout or self.timeout)
         if headers:
@@ -1040,9 +1014,7 @@ class AgentClient(BaseClient):
         ) as stream_response:
             stream_response.raise_for_status()
 
-            async for event in aiter_sse_events(
-                stream_response, timeout_seconds, agent_name
-            ):
+            async for event in aiter_sse_events(stream_response, timeout_seconds, agent_name):
                 try:
                     chunk = json.loads(event["data"])
                     yield chunk
@@ -1077,9 +1049,7 @@ class AgentClient(BaseClient):
             Exception: For other unexpected errors
         """
         # Prepare request data
-        payload, data_payload, files_payload, headers = self._prepare_request_data(
-            message, files, **kwargs
-        )
+        payload, data_payload, files_payload, headers = self._prepare_request_data(message, files, **kwargs)
 
         # Create async client configuration
         async_client_config = self._create_async_client_config(timeout, headers)

glaip_sdk/client/base.py

@@ -151,12 +151,7 @@ class BaseClient:
     def timeout(self, value: float) -> None:
         """Set timeout and rebuild client."""
         self._timeout = value
-        if (
-            hasattr(self, "http_client")
-            and self.http_client
-            and not self._session_scoped
-            and not self._parent_client
-        ):
+        if hasattr(self, "http_client") and self.http_client and not self._session_scoped and not self._parent_client:
             self.http_client.close()
             self.http_client = self._build_client(value)
 
@@ -246,18 +241,14 @@ class BaseClient:
             client_log.debug(f"Response status: {response.status_code}")
             return response
         except httpx.ConnectError as e:
-            client_log.warning(
-                f"Connection error on {method} {endpoint}, retrying once: {e}"
-            )
+            client_log.warning(f"Connection error on {method} {endpoint}, retrying once: {e}")
             try:
                 response = self.http_client.request(method, endpoint, **kwargs)
-                client_log.debug(
-                    f"Retry successful, response status: {response.status_code}"
-                )
+                client_log.debug(f"Retry successful, response status: {response.status_code}")
                 return response
             except httpx.ConnectError:
                 client_log.error(f"Retry failed for {method} {endpoint}: {e}")
-                raise e
+                raise
 
     def _request(self, method: str, endpoint: str, **kwargs) -> Any:
         """Make HTTP request with error handling and unwrap success envelopes."""
@@ -381,9 +372,7 @@ class BaseClient:
             error_message = self._get_error_message(response)
             # Try to parse response content for payload
             parsed_content = self._parse_response_content(response)
-            self._raise_api_error(
-                response.status_code, error_message, payload=parsed_content
-            )
+            self._raise_api_error(response.status_code, error_message, payload=parsed_content)
             return None  # Won't be reached but helps with type checking
 
         parsed = self._parse_response_content(response)
@@ -435,12 +424,7 @@ class BaseClient:
 
     def close(self) -> None:
         """Close the HTTP client."""
-        if (
-            hasattr(self, "http_client")
-            and self.http_client
-            and not self._session_scoped
-            and not self._parent_client
-        ):
+        if hasattr(self, "http_client") and self.http_client and not self._session_scoped and not self._parent_client:
             self.http_client.close()
 
     def __enter__(self) -> "BaseClient":

glaip_sdk/client/mcps.py

@@ -179,9 +179,7 @@ class MCPClient(BaseClient):
         update_data = {
             "name": name if name is not None else current_mcp.name,
             "type": DEFAULT_MCP_TYPE,  # Required by backend, MCPs are always server type
-            "transport": kwargs.get(
-                "transport", getattr(current_mcp, "transport", DEFAULT_MCP_TRANSPORT)
-            ),
+            "transport": kwargs.get("transport", getattr(current_mcp, "transport", DEFAULT_MCP_TRANSPORT)),
         }
 
         # Handle description with proper None handling

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(
@@ -106,7 +152,6 @@ class AgentRunRenderingManager:
             theme="dark",
             style="debug",
             live=False,
-            show_delegate_tool_panels=False,
             append_finished_snapshots=False,
         )
         return RichStreamRenderer(
@@ -139,17 +184,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 +216,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 +248,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 +312,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 +343,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 +351,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)