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

glaip_sdk/cli/slash/session.py

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

glaip_sdk/client/agents.py

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

glaip_sdk/client/main.py

@@ -158,9 +158,9 @@ class Client(BaseClient):
         """Get tool script content."""
         return self.tools.get_tool_script(tool_id)
 
-    def update_tool_via_file(self, tool_id: str, file_path: str) -> Tool:
+    def update_tool_via_file(self, tool_id: str, file_path: str, **kwargs) -> Tool:
         """Update tool via file."""
-        return self.tools.update_tool_via_file(tool_id, file_path)
+        return self.tools.update_tool_via_file(tool_id, file_path, **kwargs)
 
     # MCPs
     def create_mcp(self, **kwargs) -> MCP:

glaip_sdk/client/tools.py

@@ -241,7 +241,15 @@ class ToolClient(BaseClient):
         self, update_data: dict[str, Any], kwargs: dict[str, Any]
     ) -> None:
         """Handle additional kwargs in update payload."""
-        excluded_keys = {"tags", "framework", "version"}
+        excluded_keys = {
+            "tags",
+            "framework",
+            "version",
+            "type",
+            "tool_type",
+            "name",
+            "description",
+        }
         for key, value in kwargs.items():
             if key not in excluded_keys:
                 update_data[key] = value
@@ -269,9 +277,19 @@ class ToolClient(BaseClient):
             - Handles metadata updates properly
         """
         # Prepare the update payload with current values as defaults
+        type_override = kwargs.pop("type", None)
+        if type_override is None:
+            type_override = kwargs.pop("tool_type", None)
+        current_type = (
+            type_override
+            or getattr(current_tool, "tool_type", None)
+            or getattr(current_tool, "type", None)
+            or DEFAULT_TOOL_TYPE
+        )
+
         update_data = {
             "name": name if name is not None else current_tool.name,
-            "type": DEFAULT_TOOL_TYPE,  # Required by backend
+            "type": current_type,
             "framework": kwargs.get(
                 "framework", getattr(current_tool, "framework", DEFAULT_TOOL_FRAMEWORK)
             ),
@@ -476,6 +494,19 @@ class ToolClient(BaseClient):
         # Validate file exists
         self._validate_and_read_file(file_path)
 
+        # Fetch current metadata to ensure required fields are preserved
+        current_tool = self.get_tool_by_id(tool_id)
+
+        payload_kwargs = kwargs.copy()
+        name = payload_kwargs.pop("name", None)
+        description = payload_kwargs.pop("description", None)
+        update_payload = self._build_update_payload(
+            current_tool=current_tool,
+            name=name,
+            description=description,
+            **payload_kwargs,
+        )
+
         try:
             # Prepare multipart upload
             with open(file_path, "rb") as fb:
@@ -491,7 +522,7 @@ class ToolClient(BaseClient):
                     "PUT",
                     TOOLS_UPLOAD_BY_ID_ENDPOINT_FMT.format(tool_id=tool_id),
                     files=files,
-                    data=kwargs,  # Pass kwargs directly as data
+                    data=update_payload,
                 )
 
             return Tool(**response)._set_client(self)

glaip_sdk/utils/agent_config.py

@@ -134,25 +134,51 @@ def normalize_agent_config_for_import(
     if not isinstance(agent_config, dict):
         return normalized_data
 
-    # Priority 1: CLI --model flag (highest priority)
+    # Apply normalization based on priority order
     if cli_model:
-        # When CLI model is specified, set it and don't extract from agent_config
-        normalized_data["model"] = cli_model
-        return normalized_data
+        return _apply_cli_model_override(normalized_data, cli_model)
 
-    # Priority 2: language_model_id already exists - clean up agent_config
     if normalized_data.get("language_model_id"):
-        # If language_model_id exists, we should still clean up any conflicting
-        # LM settings from agent_config to prevent backend validation errors
-        if isinstance(agent_config, dict):
-            # Remove LM identity keys from agent_config since language_model_id takes precedence
-            lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
-            for key in lm_keys_to_remove:
-                agent_config.pop(key, None)
-            normalized_data["agent_config"] = agent_config
+        return _cleanup_existing_language_model(normalized_data, agent_config)
+
+    return _extract_lm_from_agent_config(normalized_data, agent_config)
+
+
+def _apply_cli_model_override(normalized_data: dict, cli_model: str) -> dict:
+    """Apply CLI model override (highest priority)."""
+    normalized_data["model"] = cli_model
+    return normalized_data
+
+
+def _cleanup_existing_language_model(normalized_data: dict, agent_config: dict) -> dict:
+    """Clean up agent_config when language_model_id already exists."""
+    # Remove LM identity keys from agent_config since language_model_id takes precedence
+    lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
+    for key in lm_keys_to_remove:
+        agent_config.pop(key, None)
+    normalized_data["agent_config"] = agent_config
+    return normalized_data
+
+
+def _extract_lm_from_agent_config(normalized_data: dict, agent_config: dict) -> dict:
+    """Extract LM settings from agent_config (lowest priority)."""
+    extracted_lm = _extract_lm_settings(agent_config)
+
+    if not extracted_lm:
         return normalized_data
 
-    # Priority 3: Extract LM settings from agent_config
+    # Add extracted LM settings to top level
+    normalized_data.update(extracted_lm)
+
+    # Create sanitized agent_config (remove extracted LM settings but keep memory)
+    sanitized_config = _sanitize_agent_config(agent_config)
+    normalized_data["agent_config"] = sanitized_config
+
+    return normalized_data
+
+
+def _extract_lm_settings(agent_config: dict) -> dict[str, Any]:
+    """Extract LM settings from agent_config."""
     extracted_lm = {}
 
     # Extract lm_name if present
@@ -163,19 +189,16 @@ def normalize_agent_config_for_import(
     if "lm_provider" in agent_config:
         extracted_lm["lm_provider"] = agent_config["lm_provider"]
 
-    # If we extracted LM settings, update the normalized data
-    if extracted_lm:
-        # Add extracted LM settings to top level
-        normalized_data.update(extracted_lm)
+    return extracted_lm
 
-        # Create sanitized agent_config (remove extracted LM settings but keep memory)
-        sanitized_config = agent_config.copy()
 
-        # Remove LM identity keys but preserve memory and other settings
-        lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
-        for key in lm_keys_to_remove:
-            sanitized_config.pop(key, None)
+def _sanitize_agent_config(agent_config: dict) -> dict:
+    """Create sanitized agent_config by removing LM identity keys."""
+    sanitized_config = agent_config.copy()
 
-        normalized_data["agent_config"] = sanitized_config
+    # Remove LM identity keys but preserve memory and other settings
+    lm_keys_to_remove = {"lm_provider", "lm_name", "lm_base_url"}
+    for key in lm_keys_to_remove:
+        sanitized_config.pop(key, None)
 
-    return normalized_data
+    return sanitized_config

glaip_sdk/utils/rendering/formatting.py

@@ -57,41 +57,62 @@ def mask_secrets_in_string(text: str) -> str:
 def redact_sensitive(text: str | dict | list) -> str | dict | list:
     """Redact sensitive information in a string, dict, or list."""
     if isinstance(text, dict):
-        # Recursively process dictionary values
-        result = {}
-        for key, value in text.items():
-            # Check if the key itself is sensitive
-            key_lower = key.lower()
-            if any(
-                sensitive in key_lower
-                for sensitive in ["password", "secret", "token", "key", "api_key"]
-            ):
-                result[key] = "••••••"
-            elif isinstance(value, dict | list) or isinstance(value, str):
-                result[key] = redact_sensitive(value)
-            else:
-                result[key] = value
-        return result
+        return _redact_dict_values(text)
     elif isinstance(text, list):
-        # Recursively process list items
-        return [redact_sensitive(item) for item in text]
+        return _redact_list_items(text)
     elif isinstance(text, str):
-        # Process string - first mask secrets, then redact sensitive patterns
-        result = text
-        # First mask secrets
-        for pattern in SECRET_VALUE_PATTERNS:
-            result = re.sub(pattern, "••••••", result)
-        # Then redact sensitive patterns
-        result = re.sub(
-            SENSITIVE_PATTERNS,
-            lambda m: m.group(0).split("=")[0] + "=••••••",
-            result,
-        )
-        return result
+        return _redact_string_content(text)
     else:
         return text
 
 
+def _redact_dict_values(text: dict) -> dict:
+    """Recursively process dictionary values and redact sensitive keys."""
+    result = {}
+    for key, value in text.items():
+        if _is_sensitive_key(key):
+            result[key] = "••••••"
+        elif _should_recurse_redaction(value):
+            result[key] = redact_sensitive(value)
+        else:
+            result[key] = value
+    return result
+
+
+def _redact_list_items(text: list) -> list:
+    """Recursively process list items."""
+    return [redact_sensitive(item) for item in text]
+
+
+def _redact_string_content(text: str) -> str:
+    """Process string - first mask secrets, then redact sensitive patterns."""
+    result = text
+    # First mask secrets
+    for pattern in SECRET_VALUE_PATTERNS:
+        result = re.sub(pattern, "••••••", result)
+    # Then redact sensitive patterns
+    result = re.sub(
+        SENSITIVE_PATTERNS,
+        lambda m: m.group(0).split("=")[0] + "=••••••",
+        result,
+    )
+    return result
+
+
+def _is_sensitive_key(key: str) -> bool:
+    """Check if a key contains sensitive information."""
+    key_lower = key.lower()
+    return any(
+        sensitive in key_lower
+        for sensitive in ["password", "secret", "token", "key", "api_key"]
+    )
+
+
+def _should_recurse_redaction(value: Any) -> bool:
+    """Check if a value should be recursively processed."""
+    return isinstance(value, dict | list) or isinstance(value, str)
+
+
 def pretty_args(args: dict | None, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
     """Format arguments in a pretty way."""
     if not args: