gumloop 0.3.3__tar.gz → 0.3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gumloop
-Version: 0.3.3
+Version: 0.3.4
 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.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gumloop"
-version = "0.3.3"
+version = "0.3.4"
 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.4}/src/gumloop/_http.py

@@ -110,6 +110,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)
 
@@ -251,6 +254,9 @@ 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)
 

{gumloop-0.3.3 → gumloop-0.3.4}/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.4}/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.4}/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.4}/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(

{gumloop-0.3.3 → gumloop-0.3.4}/tests/integration/conftest.py

@@ -52,3 +52,38 @@ def dev_client(api_key: str, user_id: str) -> Gumloop:
     # prod yet, so blindly hitting the default URL would be all 404s.
     base_url = _required("GUMLOOP_BASE_URL")
     return Gumloop(api_key=api_key, user_id=user_id, base_url=base_url)
+
+
+_SKILL_MD = "---\nname: live-test-skill\ndescription: live test skill\n---\n\n# Live\nDo nothing."
+
+
+@pytest.fixture
+def make_skill(dev_client: Gumloop):
+    """Factory for live skills; deletes everything it created on teardown."""
+    created: list[str] = []
+
+    def _make(name: str = "live-skill"):
+        skill = dev_client.skills.create({"SKILL.md": _SKILL_MD}, name=name).skill
+        created.append(skill.id)
+        return skill
+
+    yield _make
+    for skill_id in created:
+        dev_client.skills.delete(skill_id)
+
+
+@pytest.fixture
+def make_agent(dev_client: Gumloop):
+    """Factory for live agents; deactivates everything it created on teardown."""
+    created: list[str] = []
+
+    def _make(**kwargs):
+        kwargs.setdefault("name", "Live Verb Agent")
+        kwargs.setdefault("model_name", "auto")
+        agent = dev_client.agents.create(**kwargs).agent
+        created.append(agent.id)
+        return agent
+
+    yield _make
+    for agent_id in created:
+        dev_client.agents.update(agent_id, is_active=False)

gumloop-0.3.4/tests/integration/test_live.py

@@ -0,0 +1,170 @@
+"""Live integration tests against the real Gumloop API. Each test skips
+when its required env var is missing."""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from gumloop import APIStatusError
+from gumloop import Gumloop
+from gumloop import GumloopClient
+
+
+def test_run_flow_completes_and_returns_outputs(live_client: GumloopClient, test_flow_id: str) -> None:
+    outputs = live_client.run_flow(test_flow_id, inputs={}, timeout=60.0)
+
+    assert isinstance(outputs, dict)
+
+
+def test_invalid_run_id_surfaces_an_error(live_client: GumloopClient) -> None:
+    with pytest.raises(httpx.HTTPStatusError):
+        live_client.get_run_status("does-not-exist-" + "0" * 16)
+
+
+def test_models_list_returns_model_groups_envelope(dev_client: Gumloop) -> None:
+    response = dev_client.models.list()
+
+    assert isinstance(response.model_groups, list)
+
+
+def test_teams_list_returns_teams_with_id_and_name(dev_client: Gumloop) -> None:
+    response = dev_client.teams.list()
+
+    assert isinstance(response.teams, list)
+    for team in response.teams:
+        assert team.id
+        assert team.name
+
+
+def test_agents_list_returns_paginated_envelope(dev_client: Gumloop) -> None:
+    response = dev_client.agents.list(page_size=5)
+
+    assert isinstance(response.agents, list)
+    # ``next_cursor`` can be None when there's a single page; just check it
+    # is the declared field rather than its truthiness.
+    assert hasattr(response, "next_cursor")
+
+
+def test_mcp_servers_list_returns_servers_envelope(dev_client: Gumloop) -> None:
+    response = dev_client.mcp.list_servers()
+
+    assert isinstance(response.servers, list)
+
+
+def test_skills_list_returns_paginated_envelope(dev_client: Gumloop) -> None:
+    response = dev_client.skills.list(page_size=5)
+
+    assert isinstance(response.skills, list)
+
+
+def test_dev_api_invalid_agent_id_raises_api_status_error(dev_client: Gumloop) -> None:
+    with pytest.raises(APIStatusError) as exc:
+        dev_client.agents.retrieve("agent_does_not_exist_" + "0" * 16)
+    assert exc.value.status_code in (403, 404)
+
+
+class TestAgentSkillAttachments:
+    def test_create_agent_attaches_initial_skills(self, dev_client: Gumloop, make_skill, make_agent) -> None:
+        skill = make_skill("live-skill-initial")
+
+        agent = make_agent(skill_ids=[skill.id])
+
+        assert agent.skill_ids == [skill.id]
+
+    def test_attach_skills_adds_without_touching_existing(self, dev_client: Gumloop, make_skill, make_agent) -> None:
+        existing, added = make_skill("live-skill-a"), make_skill("live-skill-b")
+        agent = make_agent(skill_ids=[existing.id])
+
+        response = dev_client.agents.attach_skills(agent.id, added.id)
+
+        assert response.attached == [added.id]
+        assert sorted(response.skill_ids) == sorted([existing.id, added.id])
+
+    def test_attach_replay_is_reported_not_errored(self, dev_client: Gumloop, make_skill, make_agent) -> None:
+        skill = make_skill()
+        agent = make_agent(skill_ids=[skill.id])
+
+        response = dev_client.agents.attach_skills(agent.id, skill.id)
+
+        assert response.attached == []
+        assert response.already_attached == [skill.id]
+
+    def test_unknown_skill_id_rejects_whole_batch(self, dev_client: Gumloop, make_skill, make_agent) -> None:
+        valid = make_skill()
+        agent = make_agent()
+
+        with pytest.raises(APIStatusError) as exc:
+            dev_client.agents.attach_skills(agent.id, [valid.id, "sk_does_not_exist"])
+
+        assert exc.value.code == "skill_not_found"
+        assert exc.value.details.get("skill_ids") == ["sk_does_not_exist"]
+        assert dev_client.agents.retrieve(agent.id).agent.skill_ids == []
+
+    def test_detach_skills_removes_and_replay_reports(self, dev_client: Gumloop, make_skill, make_agent) -> None:
+        keep, remove = make_skill("live-keep"), make_skill("live-remove")
+        agent = make_agent(skill_ids=[keep.id, remove.id])
+
+        response = dev_client.agents.detach_skills(agent.id, remove.id)
+
+        assert response.detached == [remove.id]
+        assert response.skill_ids == [keep.id]
+        assert dev_client.agents.detach_skills(agent.id, remove.id).already_detached == [remove.id]
+
+    def test_list_skills_returns_attached_set(self, dev_client: Gumloop, make_skill, make_agent) -> None:
+        skill = make_skill()
+        agent = make_agent(skill_ids=[skill.id])
+
+        listed = dev_client.agents.list_skills(agent.id)
+
+        assert [s.id for s in listed.skills] == [skill.id]
+
+
+class TestAgentMcpServers:
+    def test_attach_mcp_server_creates_catalog_entry(self, dev_client: Gumloop, make_agent) -> None:
+        agent = make_agent()
+
+        response = dev_client.agents.attach_mcp_server(agent.id, "gmail", approval_mode="off")
+
+        assert response.created is True
+        assert response.mcp_server.get("server_id") == "gmail"
+        assert response.mcp_server.get("approval_mode") == "off"
+
+    def test_attach_again_updates_config_in_place(self, dev_client: Gumloop, make_agent) -> None:
+        agent = make_agent()
+        dev_client.agents.attach_mcp_server(agent.id, "gmail", approval_mode="off")
+
+        response = dev_client.agents.attach_mcp_server(agent.id, "gmail", approval_mode="always")
+
+        assert response.created is False
+        assert response.mcp_server.get("approval_mode") == "always"
+
+    def test_identity_keys_cannot_be_spoofed_and_secrets_never_round_trip(
+        self, dev_client: Gumloop, make_agent,
+    ) -> None:
+        agent = make_agent()
+
+        response = dev_client.agents.attach_mcp_server(
+            agent.id, "gmail",
+            mcp_server_url="https://evil.example.com", secret_id="spoofed",
+        )
+
+        assert response.mcp_server.get("server_id") == "gmail"
+        assert "secret_id" not in response.mcp_server
+        assert response.mcp_server.get("mcp_server_url") is None
+
+    def test_unknown_server_id_is_a_loud_404(self, dev_client: Gumloop, make_agent) -> None:
+        agent = make_agent()
+
+        with pytest.raises(APIStatusError) as exc:
+            dev_client.agents.attach_mcp_server(agent.id, "not_a_real_server")
+
+        assert exc.value.code == "mcp_server_not_found"
+        assert exc.value.status_code == 404
+
+    def test_detach_mcp_server_is_idempotent(self, dev_client: Gumloop, make_agent) -> None:
+        agent = make_agent()
+        dev_client.agents.attach_mcp_server(agent.id, "gmail")
+
+        assert dev_client.agents.detach_mcp_server(agent.id, "gmail").detached is True
+        assert dev_client.agents.detach_mcp_server(agent.id, "gmail").detached is False

{gumloop-0.3.3 → gumloop-0.3.4}/tests/sdk/test_agents.py

@@ -93,6 +93,132 @@ def test_agents_retrieve_and_update_routes(client: Gumloop) -> None:
     }
 
 
+@respx.mock
+def test_agents_attach_skills_sends_only_attach_body(client: Gumloop) -> None:
+    route = respx.patch(f"{API_BASE}/agents/agent_123/skills").mock(
+        return_value=httpx.Response(
+            200, json={"agent_id": "agent_123", "skill_ids": ["s1", "s2"], "attached": ["s2"]}
+        )
+    )
+
+    result = client.agents.attach_skills("agent_123", ["s1", "s2"])
+
+    assert result.agent_id == "agent_123"
+    assert result.skill_ids == ["s1", "s2"]
+    assert result.attached == ["s2"]
+    assert request_json(route.calls[0].request) == {"attach": ["s1", "s2"]}
+
+
+@respx.mock
+def test_agents_attach_skills_coerces_bare_string(client: Gumloop) -> None:
+    route = respx.patch(f"{API_BASE}/agents/agent_123/skills").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "attached": ["s1"]})
+    )
+
+    client.agents.attach_skills("agent_123", "s1")
+
+    assert request_json(route.calls[0].request) == {"attach": ["s1"]}
+
+
+@respx.mock
+def test_agents_detach_skills_sends_only_detach_body(client: Gumloop) -> None:
+    route = respx.patch(f"{API_BASE}/agents/agent_123/skills").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "detached": ["s1"]})
+    )
+
+    result = client.agents.detach_skills("agent_123", "s1")
+
+    assert result.detached == ["s1"]
+    assert request_json(route.calls[0].request) == {"detach": ["s1"]}
+
+
+@respx.mock
+def test_agents_list_skills_sends_agent_id_param(client: Gumloop) -> None:
+    route = respx.get(f"{API_BASE}/skills").mock(return_value=httpx.Response(200, json={"skills": []}))
+
+    result = client.agents.list_skills("agent_123")
+
+    assert result.skills == []
+    assert route.calls[0].request.url.params["agent_id"] == "agent_123"
+
+
+@respx.mock
+def test_agents_attach_mcp_server_puts_config(client: Gumloop) -> None:
+    route = respx.put(f"{API_BASE}/agents/agent_123/mcp-servers/gmail").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "agent_id": "agent_123",
+                "mcp_server": {"type": "gumcp_server", "server_id": "gmail", "approval_mode": "off"},
+                "created": True,
+                "auth_status": "connected",
+            },
+        )
+    )
+
+    result = client.agents.attach_mcp_server("agent_123", "gmail", approval_mode="off")
+
+    assert result.created is True
+    assert result.auth_status == "connected"
+    assert result.mcp_server["server_id"] == "gmail"
+    assert request_json(route.calls[0].request) == {"approval_mode": "off"}
+
+
+@respx.mock
+def test_agents_detach_mcp_server(client: Gumloop) -> None:
+    route = respx.delete(f"{API_BASE}/agents/agent_123/mcp-servers/gmail").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "server_id": "gmail", "detached": True})
+    )
+
+    result = client.agents.detach_mcp_server("agent_123", "gmail")
+
+    assert result.detached is True
+    assert result.server_id == "gmail"
+    assert route.call_count == 1
+
+
+@respx.mock
+def test_agents_list_mcp_servers(client: Gumloop) -> None:
+    respx.get(f"{API_BASE}/agents/agent_123/mcp-servers").mock(
+        return_value=httpx.Response(
+            200, json={"agent_id": "agent_123", "mcp_servers": [{"server_id": "gmail"}]}
+        )
+    )
+
+    result = client.agents.list_mcp_servers("agent_123")
+
+    assert result.agent_id == "agent_123"
+    assert result.mcp_servers == [{"server_id": "gmail"}]
+
+
+@respx.mock
+def test_async_agents_skill_and_mcp_methods() -> None:
+    respx.patch(f"{API_BASE}/agents/agent_123/skills").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "attached": ["s1"]})
+    )
+    respx.get(f"{API_BASE}/skills").mock(return_value=httpx.Response(200, json={"skills": []}))
+    respx.put(f"{API_BASE}/agents/agent_123/mcp-servers/gmail").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "created": True})
+    )
+    respx.delete(f"{API_BASE}/agents/agent_123/mcp-servers/gmail").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "server_id": "gmail", "detached": True})
+    )
+    respx.get(f"{API_BASE}/agents/agent_123/mcp-servers").mock(
+        return_value=httpx.Response(200, json={"agent_id": "agent_123", "mcp_servers": []})
+    )
+
+    async def run() -> None:
+        async with AsyncGumloop(access_token="token") as client:
+            assert (await client.agents.attach_skills("agent_123", "s1")).attached == ["s1"]
+            assert (await client.agents.detach_skills("agent_123", ["s1"])).agent_id == "agent_123"
+            assert (await client.agents.list_skills("agent_123")).skills == []
+            assert (await client.agents.attach_mcp_server("agent_123", "gmail", approval_mode="off")).created is True
+            assert (await client.agents.detach_mcp_server("agent_123", "gmail")).detached is True
+            assert (await client.agents.list_mcp_servers("agent_123")).mcp_servers == []
+
+    asyncio.run(run())
+
+
 @respx.mock
 def test_models_list(client: Gumloop) -> None:
     respx.get(f"{API_BASE}/models").mock(return_value=httpx.Response(200, json={"model_groups": [{"id": "auto"}]}))

{gumloop-0.3.3 → gumloop-0.3.4}/uv.lock

@@ -355,9 +355,10 @@ wheels = [
 
 [[package]]
 name = "gumloop"
-version = "0.3.3"
+version = "0.3.4"
 source = { editable = "." }
 dependencies = [
+    { name = "click" },
     { name = "httpx" },
     { name = "httpx-sse" },
     { name = "keyring" },
@@ -387,6 +388,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "click", specifier = ">=8.0" },
     { name = "httpx", specifier = ">=0.24.1" },
     { name = "httpx-sse", specifier = ">=0.4.0" },
     { name = "keyring", specifier = ">=24" },

gumloop-0.3.3/tests/integration/test_live.py

@@ -1,64 +0,0 @@
-"""Live integration tests against the real Gumloop API. Each test skips
-when its required env var is missing."""
-
-from __future__ import annotations
-
-import httpx
-import pytest
-
-from gumloop import APIStatusError
-from gumloop import Gumloop
-from gumloop import GumloopClient
-
-
-def test_run_flow_completes_and_returns_outputs(live_client: GumloopClient, test_flow_id: str) -> None:
-    outputs = live_client.run_flow(test_flow_id, inputs={}, timeout=60.0)
-
-    assert isinstance(outputs, dict)
-
-
-def test_invalid_run_id_surfaces_an_error(live_client: GumloopClient) -> None:
-    with pytest.raises(httpx.HTTPStatusError):
-        live_client.get_run_status("does-not-exist-" + "0" * 16)
-
-
-def test_models_list_returns_model_groups_envelope(dev_client: Gumloop) -> None:
-    response = dev_client.models.list()
-
-    assert isinstance(response.model_groups, list)
-
-
-def test_teams_list_returns_teams_with_id_and_name(dev_client: Gumloop) -> None:
-    response = dev_client.teams.list()
-
-    assert isinstance(response.teams, list)
-    for team in response.teams:
-        assert team.id
-        assert team.name
-
-
-def test_agents_list_returns_paginated_envelope(dev_client: Gumloop) -> None:
-    response = dev_client.agents.list(page_size=5)
-
-    assert isinstance(response.agents, list)
-    # ``next_cursor`` can be None when there's a single page; just check it
-    # is the declared field rather than its truthiness.
-    assert hasattr(response, "next_cursor")
-
-
-def test_mcp_servers_list_returns_servers_envelope(dev_client: Gumloop) -> None:
-    response = dev_client.mcp.list_servers()
-
-    assert isinstance(response.servers, list)
-
-
-def test_skills_list_returns_paginated_envelope(dev_client: Gumloop) -> None:
-    response = dev_client.skills.list(page_size=5)
-
-    assert isinstance(response.skills, list)
-
-
-def test_dev_api_invalid_agent_id_raises_api_status_error(dev_client: Gumloop) -> None:
-    with pytest.raises(APIStatusError) as exc:
-        dev_client.agents.retrieve("agent_does_not_exist_" + "0" * 16)
-    assert exc.value.status_code in (403, 404)