gumloop 0.3.3__tar.gz → 0.3.5__tar.gz

{gumloop-0.3.3 → gumloop-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gumloop
-Version: 0.3.3
+Version: 0.3.5
 Summary: Python client for the Gumloop API
 Project-URL: Homepage, https://github.com/gumloop/gumloop-py
 Project-URL: Bug Tracker, https://github.com/gumloop/gumloop-py/issues
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
+Requires-Dist: click>=8.0
 Requires-Dist: httpx-sse>=0.4.0
 Requires-Dist: httpx>=0.24.1
 Requires-Dist: keyring>=24

{gumloop-0.3.3 → gumloop-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gumloop"
-version = "0.3.3"
+version = "0.3.5"
 description = "Python client for the Gumloop API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,6 +28,7 @@ dependencies = [
     "pydantic>=2.0.0",
     "questionary>=2.0",
     "rich",
+    "click>=8.0",
     "typer>=0.25.1",
 ]
 

{gumloop-0.3.3 → gumloop-0.3.5}/src/gumloop/__init__.py

@@ -6,7 +6,7 @@ from gumloop.errors import AuthenticationError
 from gumloop.errors import GumloopError
 from gumloop.oauth import OAuth
 
-__version__ = "0.3.3"
+__version__ = "0.3.5"
 __all__ = [
     "APIStatusError",
     "AsyncGumloop",

gumloop-0.3.5/src/gumloop/_auth.py

@@ -0,0 +1,35 @@
+"""Credential resolution shared by the sync and async transports."""
+
+from __future__ import annotations
+
+import os
+
+from gumloop.errors import AuthenticationError
+
+
+class EnvToken(str):
+    """Access token sourced from ``GUMLOOP_ACCESS_TOKEN``.
+
+    Stays live: ``current()`` returns the env var's present value, so
+    platform-rotated tokens (e.g. per-call sandbox credentials) are picked up
+    on every request. Explicit tokens are plain strings and never change.
+    """
+
+    @classmethod
+    def from_env(cls) -> EnvToken | None:
+        token = os.environ.get("GUMLOOP_ACCESS_TOKEN")
+        return cls(token) if token else None
+
+    def current(self) -> str:
+        return os.environ.get("GUMLOOP_ACCESS_TOKEN") or str(self)
+
+
+def auth_headers(access_token: str | None, user_id: str | None) -> dict[str, str]:
+    if isinstance(access_token, EnvToken):
+        access_token = access_token.current()
+    if not access_token:
+        raise AuthenticationError("access_token, api_key, or GUMLOOP_ACCESS_TOKEN is required")
+    headers = {"Authorization": f"Bearer {access_token}"}
+    if user_id:
+        headers["x-auth-key"] = user_id
+    return headers

{gumloop-0.3.3 → gumloop-0.3.5}/src/gumloop/_client.py

@@ -7,6 +7,7 @@ from typing import Any
 
 import httpx
 
+from gumloop._auth import EnvToken
 from gumloop._http import AsyncHttpClient
 from gumloop._http import HttpClient
 from gumloop.oauth import OAuth
@@ -59,7 +60,7 @@ class Gumloop:
         stream_timeout: float | None = DEFAULT_STREAM_TIMEOUT,
     ) -> None:
         self.api_key = api_key
-        self.access_token = access_token or api_key or os.environ.get("GUMLOOP_ACCESS_TOKEN")
+        self.access_token = access_token or api_key or EnvToken.from_env()
         # Personal Gumloop API keys are user-scoped; the backend uses the
         # x-auth-key header to look up the owner's stored secret. OAuth
         # callers omit it because the bearer token already identifies them.
@@ -115,7 +116,7 @@ class AsyncGumloop:
         stream_timeout: float | None = DEFAULT_STREAM_TIMEOUT,
     ) -> None:
         self.api_key = api_key
-        self.access_token = access_token or api_key or os.environ.get("GUMLOOP_ACCESS_TOKEN")
+        self.access_token = access_token or api_key or EnvToken.from_env()
         self.user_id = user_id or os.environ.get("GUMLOOP_USER_ID")
         # Defaults to production; GUMLOOP_BASE_URL is an optional override.
         self.base_url = (base_url or os.environ.get("GUMLOOP_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")

{gumloop-0.3.3 → gumloop-0.3.5}/src/gumloop/_http.py

@@ -13,7 +13,7 @@ from httpx_sse import ServerSentEvent
 from pydantic import BaseModel
 from pydantic import ValidationError
 
-from gumloop.errors import AuthenticationError
+from gumloop._auth import auth_headers
 from gumloop.errors import to_api_error
 from gumloop.types import StreamEvent
 
@@ -23,15 +23,6 @@ _DONE_SENTINEL = "[DONE]"
 _T = TypeVar("_T", bound=BaseModel)
 
 
-def _auth_headers(access_token: str | None, user_id: str | None) -> dict[str, str]:
-    if not access_token:
-        raise AuthenticationError("access_token, api_key, or GUMLOOP_ACCESS_TOKEN is required")
-    headers = {"Authorization": f"Bearer {access_token}"}
-    if user_id:
-        headers["x-auth-key"] = user_id
-    return headers
-
-
 def _omit_none_params(params: Mapping[str, Any] | None) -> dict[str, Any] | None:
     # Backend treats absent ``?foo`` and ``?foo=`` as different signals
     # ("not provided" vs "empty string"); drop None values so the wire URL
@@ -110,6 +101,9 @@ class HttpClient:
     ) -> Any:
         return self._request("PATCH", path, json=json, data=_omit_none_params(data), files=files)
 
+    def put(self, path: str, *, json: Any = None) -> Any:
+        return self._request("PUT", path, json=json)
+
     def delete(self, path: str) -> Any:
         return self._request("DELETE", path)
 
@@ -117,7 +111,7 @@ class HttpClient:
         # Endpoints whose streaming variant lives on the stream host (e.g. chat
         # completions) must accept their unary counterparts at the same host —
         # the api host has no handler for them.
-        headers = _auth_headers(self.access_token, self.user_id)
+        headers = auth_headers(self.access_token, self.user_id)
         headers["Content-Type"] = "application/json"
         response = self._client.post(
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -137,7 +131,7 @@ class HttpClient:
         json: Any = None,
         params: Mapping[str, Any] | None = None,
     ) -> Iterator[StreamEvent]:
-        headers = {**_auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
+        headers = {**auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
         with self._client.stream(
             method,
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -163,7 +157,7 @@ class HttpClient:
     ) -> Iterator[_T]:
         # Skips the StreamEvent envelope and honors OpenRouter's `data: [DONE]`
         # terminator. Unparseable events (keep-alives, comments) are skipped.
-        headers = {**_auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
+        headers = {**auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
         with self._client.stream(
             method,
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -191,7 +185,7 @@ class HttpClient:
     def _request(self, method: str, path: str, **kwargs: Any) -> Any:
         # Headers are rebuilt per request so ``access_token`` / ``user_id``
         # can be rotated on a live client without reconstructing it.
-        headers = _auth_headers(self.access_token, self.user_id)
+        headers = auth_headers(self.access_token, self.user_id)
         if not kwargs.get("files"):
             headers["Content-Type"] = "application/json"
         response = self._client.request(method, path, headers=headers, **kwargs)
@@ -251,11 +245,14 @@ class AsyncHttpClient:
     ) -> Any:
         return await self._request("PATCH", path, json=json, data=_omit_none_params(data), files=files)
 
+    async def put(self, path: str, *, json: Any = None) -> Any:
+        return await self._request("PUT", path, json=json)
+
     async def delete(self, path: str) -> Any:
         return await self._request("DELETE", path)
 
     async def post_to_stream_host(self, path: str, *, json: Any = None) -> Any:
-        headers = _auth_headers(self.access_token, self.user_id)
+        headers = auth_headers(self.access_token, self.user_id)
         headers["Content-Type"] = "application/json"
         response = await self._client.post(
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -275,7 +272,7 @@ class AsyncHttpClient:
         json: Any = None,
         params: Mapping[str, Any] | None = None,
     ) -> AsyncIterator[StreamEvent]:
-        headers = {**_auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
+        headers = {**auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
         async with self._client.stream(
             method,
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -299,7 +296,7 @@ class AsyncHttpClient:
         json: Any = None,
         params: Mapping[str, Any] | None = None,
     ) -> AsyncIterator[_T]:
-        headers = {**_auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
+        headers = {**auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
         async with self._client.stream(
             method,
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -325,7 +322,7 @@ class AsyncHttpClient:
                     continue
 
     async def _request(self, method: str, path: str, **kwargs: Any) -> Any:
-        headers = _auth_headers(self.access_token, self.user_id)
+        headers = auth_headers(self.access_token, self.user_id)
         if not kwargs.get("files"):
             headers["Content-Type"] = "application/json"
         response = await self._client.request(method, path, headers=headers, **kwargs)

{gumloop-0.3.3 → gumloop-0.3.5}/src/gumloop/cli/commands/agents.py

@@ -144,6 +144,10 @@ def create_agent(
         str | None,
         typer.Option("--tools-file", help="Path to a JSON file containing the tools array."),
     ] = None,
+    skill_ids: Annotated[
+        str | None,
+        typer.Option("--skill-ids", help="Comma-separated ids of existing skills to attach."),
+    ] = None,
     json_output: Annotated[
         bool,
         typer.Option("--json", help="Print the raw SDK response as JSON."),
@@ -186,6 +190,12 @@ def create_agent(
                     raise GumloopError("Tools JSON must be an array at the top level.")
                 tools = parsed
 
+        parsed_skill_ids = (
+            [skill_id.strip() for skill_id in skill_ids.split(",") if skill_id.strip()]
+            if skill_ids is not None
+            else None
+        )
+
         response = cli.call_with_refresh(
             lambda client: client.agents.create(
                 name=name,
@@ -193,6 +203,7 @@ def create_agent(
                 description=description,
                 system_prompt=resolved_prompt,
                 tools=tools,
+                skill_ids=parsed_skill_ids,
                 team_id=cli.effective_team_id,
             )
         )
@@ -233,11 +244,23 @@ def update_agent(
     ] = None,
     tools_json: Annotated[
         str | None,
-        typer.Option("--tools-json", help="Inline JSON array of tool config objects."),
+        typer.Option(
+            "--tools-json",
+            help=(
+                "Inline JSON array of tool config objects."
+                " (legacy: replaces the entire tools list; prefer attach-mcp-server/detach-mcp-server)"
+            ),
+        ),
     ] = None,
     tools_file: Annotated[
         str | None,
-        typer.Option("--tools-file", help="Path to a JSON file containing the tools array."),
+        typer.Option(
+            "--tools-file",
+            help=(
+                "Path to a JSON file containing the tools array."
+                " (legacy: replaces the entire tools list; prefer attach-mcp-server/detach-mcp-server)"
+            ),
+        ),
     ] = None,
     is_active: Annotated[
         bool | None,
@@ -303,3 +326,125 @@ def update_agent(
         return
 
     console.print(f"[green]Updated agent[/green] {agent_id}")
+
+
+@agents_app.command(
+    "attach-skills",
+    epilog="Example:\n  gumloop agents attach-skills agent_abc skill_1 skill_2",
+)
+def attach_skills(
+    ctx: typer.Context,
+    agent_id: Annotated[str, typer.Argument(help="ID of the agent to attach skills to.")],
+    skill_ids: Annotated[list[str], typer.Argument(help="One or more skill ids to attach.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the raw SDK response as JSON."),
+    ] = False,
+) -> None:
+    """Attach one or more skills to an agent (idempotent)."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(lambda client: client.agents.attach_skills(agent_id, skill_ids))
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    console.print(f"[green]Attached[/green] {len(response.attached)} skill(s) to {agent_id}")
+    if response.already_attached:
+        console.print(f"  Already attached: {', '.join(response.already_attached)}", markup=False, highlight=False)
+
+
+@agents_app.command(
+    "detach-skills",
+    epilog="Example:\n  gumloop agents detach-skills agent_abc skill_1 skill_2",
+)
+def detach_skills(
+    ctx: typer.Context,
+    agent_id: Annotated[str, typer.Argument(help="ID of the agent to detach skills from.")],
+    skill_ids: Annotated[list[str], typer.Argument(help="One or more skill ids to detach.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the raw SDK response as JSON."),
+    ] = False,
+) -> None:
+    """Detach one or more skills from an agent (idempotent)."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(lambda client: client.agents.detach_skills(agent_id, skill_ids))
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    console.print(f"[green]Detached[/green] {len(response.detached)} skill(s) from {agent_id}")
+    if response.already_detached:
+        console.print(f"  Already detached: {', '.join(response.already_detached)}", markup=False, highlight=False)
+
+
+@agents_app.command(
+    "attach-mcp-server",
+    epilog="Example:\n  gumloop agents attach-mcp-server agent_abc gmail --approval-mode off",
+)
+def attach_mcp_server(
+    ctx: typer.Context,
+    agent_id: Annotated[str, typer.Argument(help="ID of the agent to attach the MCP server to.")],
+    server_id: Annotated[str, typer.Argument(help="ID of the MCP server to attach.")],
+    approval_mode: Annotated[
+        str | None,
+        typer.Option("--approval-mode", help="Tool-call approval mode for this server."),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the raw SDK response as JSON."),
+    ] = False,
+) -> None:
+    """Attach an MCP server to an agent, or update its config (idempotent upsert)."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(
+            lambda client: client.agents.attach_mcp_server(agent_id, server_id, approval_mode=approval_mode)
+        )
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    verb = "Attached" if response.created else "Updated"
+    console.print(f"[green]{verb}[/green] MCP server {escape_markup(server_id)} on {agent_id}")
+    if response.auth_status:
+        console.print(f"  Auth status: {response.auth_status}", markup=False, highlight=False)
+
+
+@agents_app.command(
+    "detach-mcp-server",
+    epilog="Example:\n  gumloop agents detach-mcp-server agent_abc gmail",
+)
+def detach_mcp_server(
+    ctx: typer.Context,
+    agent_id: Annotated[str, typer.Argument(help="ID of the agent to detach the MCP server from.")],
+    server_id: Annotated[str, typer.Argument(help="ID of the MCP server to detach.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the raw SDK response as JSON."),
+    ] = False,
+) -> None:
+    """Detach an MCP server from an agent (idempotent)."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(lambda client: client.agents.detach_mcp_server(agent_id, server_id))
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    console.print(f"[green]Detached[/green] MCP server {escape_markup(server_id)} from {agent_id}")
+    console.print(f"  detached: {'true' if response.detached else 'false'}", markup=False, highlight=False)

{gumloop-0.3.3 → gumloop-0.3.5}/src/gumloop/resources/agents.py

@@ -1,19 +1,29 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
+from collections.abc import Sequence
 from typing import Any
 
 from gumloop._http import AsyncHttpClient
 from gumloop._http import HttpClient
 from gumloop.types import AgentCreateRequest
 from gumloop.types import AgentListResponse
+from gumloop.types import AgentMcpServerDetachResponse
+from gumloop.types import AgentMcpServerResponse
+from gumloop.types import AgentMcpServersResponse
 from gumloop.types import AgentResponse
+from gumloop.types import AgentSkillsResponse
 from gumloop.types import AgentUpdateRequest
 from gumloop.types import EvaluationConfigResponse
 from gumloop.types import EvaluationConfigUpdateRequest
 from gumloop.types import EvaluationResultListResponse
 from gumloop.types import EvaluationResultResponse
 from gumloop.types import ModelListResponse
+from gumloop.types import SkillListResponse
+
+
+def _skill_id_list(skill_ids: str | Sequence[str]) -> list[str]:
+    return [skill_ids] if isinstance(skill_ids, str) else list(skill_ids)
 
 
 class Agents:
@@ -49,10 +59,48 @@ class Agents:
         request: AgentUpdateRequest | Mapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AgentResponse:
+        """``tools`` replaces the entire list when provided (legacy bulk path); prefer
+        attach_mcp_server/detach_mcp_server for individual MCP servers and
+        attach_skills/detach_skills for skills."""
         return AgentResponse.model_validate(
             self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
         )
 
+    def attach_skills(self, agent_id: str, skill_ids: str | Sequence[str]) -> AgentSkillsResponse:
+        """Attach skills to an agent. Idempotent: safe to retry, already-attached ids are reported."""
+        return AgentSkillsResponse.model_validate(
+            self._client.patch(f"agents/{agent_id}/skills", json={"attach": _skill_id_list(skill_ids)})
+        )
+
+    def detach_skills(self, agent_id: str, skill_ids: str | Sequence[str]) -> AgentSkillsResponse:
+        """Detach skills from an agent. Idempotent: safe to retry, already-detached ids are reported."""
+        return AgentSkillsResponse.model_validate(
+            self._client.patch(f"agents/{agent_id}/skills", json={"detach": _skill_id_list(skill_ids)})
+        )
+
+    def list_skills(self, agent_id: str, **kwargs: Any) -> SkillListResponse:
+        return SkillListResponse.model_validate(
+            self._client.get("skills", params={"agent_id": agent_id, **kwargs})
+        )
+
+    def attach_mcp_server(self, agent_id: str, server_id: str, **config: Any) -> AgentMcpServerResponse:
+        """Attach an MCP server, or update its config if already attached (idempotent upsert)."""
+        return AgentMcpServerResponse.model_validate(
+            self._client.put(
+                f"agents/{agent_id}/mcp-servers/{server_id}",
+                json={k: v for k, v in config.items() if v is not None},
+            )
+        )
+
+    def detach_mcp_server(self, agent_id: str, server_id: str) -> AgentMcpServerDetachResponse:
+        """Detach an MCP server from an agent. Idempotent: safe to retry."""
+        return AgentMcpServerDetachResponse.model_validate(
+            self._client.delete(f"agents/{agent_id}/mcp-servers/{server_id}")
+        )
+
+    def list_mcp_servers(self, agent_id: str) -> AgentMcpServersResponse:
+        return AgentMcpServersResponse.model_validate(self._client.get(f"agents/{agent_id}/mcp-servers"))
+
     def get_evaluation_config(self, agent_id: str) -> EvaluationConfigResponse:
         return EvaluationConfigResponse.model_validate(self._client.get(f"agents/{agent_id}/evaluation-config"))
 
@@ -133,9 +181,43 @@ class AsyncAgents:
         request: AgentUpdateRequest | Mapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AgentResponse:
+        """``tools`` replaces the entire list when provided (legacy bulk path); prefer
+        attach_mcp_server/detach_mcp_server for individual MCP servers and
+        attach_skills/detach_skills for skills."""
         data = await self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
         return AgentResponse.model_validate(data)
 
+    async def attach_skills(self, agent_id: str, skill_ids: str | Sequence[str]) -> AgentSkillsResponse:
+        """Attach skills to an agent. Idempotent: safe to retry, already-attached ids are reported."""
+        data = await self._client.patch(f"agents/{agent_id}/skills", json={"attach": _skill_id_list(skill_ids)})
+        return AgentSkillsResponse.model_validate(data)
+
+    async def detach_skills(self, agent_id: str, skill_ids: str | Sequence[str]) -> AgentSkillsResponse:
+        """Detach skills from an agent. Idempotent: safe to retry, already-detached ids are reported."""
+        data = await self._client.patch(f"agents/{agent_id}/skills", json={"detach": _skill_id_list(skill_ids)})
+        return AgentSkillsResponse.model_validate(data)
+
+    async def list_skills(self, agent_id: str, **kwargs: Any) -> SkillListResponse:
+        data = await self._client.get("skills", params={"agent_id": agent_id, **kwargs})
+        return SkillListResponse.model_validate(data)
+
+    async def attach_mcp_server(self, agent_id: str, server_id: str, **config: Any) -> AgentMcpServerResponse:
+        """Attach an MCP server, or update its config if already attached (idempotent upsert)."""
+        data = await self._client.put(
+            f"agents/{agent_id}/mcp-servers/{server_id}",
+            json={k: v for k, v in config.items() if v is not None},
+        )
+        return AgentMcpServerResponse.model_validate(data)
+
+    async def detach_mcp_server(self, agent_id: str, server_id: str) -> AgentMcpServerDetachResponse:
+        """Detach an MCP server from an agent. Idempotent: safe to retry."""
+        data = await self._client.delete(f"agents/{agent_id}/mcp-servers/{server_id}")
+        return AgentMcpServerDetachResponse.model_validate(data)
+
+    async def list_mcp_servers(self, agent_id: str) -> AgentMcpServersResponse:
+        data = await self._client.get(f"agents/{agent_id}/mcp-servers")
+        return AgentMcpServersResponse.model_validate(data)
+
     async def get_evaluation_config(self, agent_id: str) -> EvaluationConfigResponse:
         data = await self._client.get(f"agents/{agent_id}/evaluation-config")
         return EvaluationConfigResponse.model_validate(data)

{gumloop-0.3.3 → gumloop-0.3.5}/src/gumloop/types.py

@@ -53,6 +53,7 @@ class AgentCreateRequest(_Model):
     system_prompt: str | None = None
     tools: list[dict[str, Any]] = Field(default_factory=list)
     resources: list[dict[str, Any]] = Field(default_factory=list)
+    skill_ids: list[str] | None = None
     metadata: dict[str, Any] | None = None
     folder_id: str | None = None
     is_active: bool = True
@@ -80,6 +81,7 @@ class Agent(_Model):
     is_active: bool = False
     tools: list[dict[str, Any]] = Field(default_factory=list)
     resources: list[dict[str, Any]] = Field(default_factory=list)
+    skill_ids: list[str] | None = None
     metadata: dict[str, Any] = Field(default_factory=dict)
     model_name: str | None = None
     system_prompt: str | None = None
@@ -90,6 +92,33 @@ class Agent(_Model):
     creator: CreatorPayload | None = None
 
 
+class AgentSkillsResponse(_Model):
+    agent_id: str
+    skill_ids: list[str] = Field(default_factory=list)
+    attached: list[str] = Field(default_factory=list)
+    detached: list[str] = Field(default_factory=list)
+    already_attached: list[str] = Field(default_factory=list)
+    already_detached: list[str] = Field(default_factory=list)
+
+
+class AgentMcpServerResponse(_Model):
+    agent_id: str
+    mcp_server: dict[str, Any] = Field(default_factory=dict)
+    created: bool = False
+    auth_status: str | None = None
+
+
+class AgentMcpServerDetachResponse(_Model):
+    agent_id: str
+    server_id: str
+    detached: bool = False
+
+
+class AgentMcpServersResponse(_Model):
+    agent_id: str
+    mcp_servers: list[dict[str, Any]] = Field(default_factory=list)
+
+
 class AgentResponse(_Model):
     agent: Agent
 

{gumloop-0.3.3 → gumloop-0.3.5}/tests/cli/test_agents.py

@@ -123,6 +123,73 @@ def test_agents_update_only_sends_specified_fields(cli_runner: CliRunner) -> Non
     assert sent == {"name": "Renamed", "is_active": False}
 
 
+@respx.mock
+def test_agents_attach_skills_command(cli_runner: CliRunner) -> None:
+    route = respx.patch(f"{API_BASE}/agents/agent_abc/skills").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_abc", "attached": ["s1", "s2"]})
+    )
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["agents", "attach-skills", "agent_abc", "s1", "s2"])
+
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls[0].request.content) == {"attach": ["s1", "s2"]}
+
+
+@respx.mock
+def test_agents_detach_skills_command(cli_runner: CliRunner) -> None:
+    route = respx.patch(f"{API_BASE}/agents/agent_abc/skills").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_abc", "detached": ["s1"]})
+    )
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["agents", "detach-skills", "agent_abc", "s1"])
+
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls[0].request.content) == {"detach": ["s1"]}
+
+
+@respx.mock
+def test_agents_attach_mcp_server_command(cli_runner: CliRunner) -> None:
+    route = respx.put(f"{API_BASE}/agents/agent_abc/mcp-servers/gmail").mock(
+        return_value=httpx.Response(
+            200, json={"agent_id": "agent_abc", "created": True, "auth_status": "connected"}
+        )
+    )
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(
+        app, ["agents", "attach-mcp-server", "agent_abc", "gmail", "--approval-mode", "off"]
+    )
+
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls[0].request.content) == {"approval_mode": "off"}
+    assert "connected" in result.output
+
+
+@respx.mock
+def test_agents_detach_mcp_server_command(cli_runner: CliRunner) -> None:
+    route = respx.delete(f"{API_BASE}/agents/agent_abc/mcp-servers/gmail").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_abc", "server_id": "gmail", "detached": True})
+    )
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["agents", "detach-mcp-server", "agent_abc", "gmail"])
+
+    assert result.exit_code == 0, result.output
+    assert route.call_count == 1
+    assert "true" in result.output
+
+
+@respx.mock
+def test_agents_update_rejects_skill_ids_option(cli_runner: CliRunner) -> None:
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["agents", "update", "agent_abc", "--skill-ids", "s1"])
+
+    assert result.exit_code != 0
+
+
 @respx.mock
 def test_agents_create_uses_effective_team_id(cli_runner: CliRunner, monkeypatch) -> None:
     route = respx.post(f"{API_BASE}/agents").mock(