gumloop 0.3.1__tar.gz → 0.3.2__tar.gz

{gumloop-0.3.1 → gumloop-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gumloop
-Version: 0.3.1
+Version: 0.3.2
 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

{gumloop-0.3.1 → gumloop-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gumloop"
-version = "0.3.1"
+version = "0.3.2"
 description = "Python client for the Gumloop API"
 readme = "README.md"
 requires-python = ">=3.10"

{gumloop-0.3.1 → gumloop-0.3.2}/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.1"
+__version__ = "0.3.2"
 __all__ = [
     "APIStatusError",
     "AsyncGumloop",

{gumloop-0.3.1 → gumloop-0.3.2}/src/gumloop/_http.py

@@ -184,7 +184,7 @@ class HttpClient:
                     yield response_model.model_validate_json(event.data)
                 except ValidationError:
                     # Server-side mid-stream error frames or schema-drift events
-                    # land here. 
+                    # land here.
                     logger.debug("dropped non-%s SSE: %s", response_model.__name__, event.data)
                     continue
 
@@ -320,7 +320,7 @@ class AsyncHttpClient:
                     yield response_model.model_validate_json(event.data)
                 except ValidationError:
                     # Server-side mid-stream error frames or schema-drift events
-                    # land here. 
+                    # land here.
                     logger.debug("dropped non-%s SSE: %s", response_model.__name__, event.data)
                     continue
 

{gumloop-0.3.1 → gumloop-0.3.2}/src/gumloop/cli/commands/sessions.py

@@ -93,6 +93,99 @@ def create_session(
             console.print(f"  [{m.role or ''}] {content[:200]}", markup=False, highlight=False)
 
 
+@sessions_app.command(
+    "list",
+    epilog=(
+        "Examples:\n"
+        "  gumloop sessions list agent_abc --state completed --limit 50 --json\n"
+        "  gumloop sessions list agent_abc --search 'invoice' --sort oldest\n"
+        "  gumloop sessions list agent_abc --type api --creator user_123"
+    ),
+)
+def list_sessions(
+    ctx: typer.Context,
+    agent_id: Annotated[str, typer.Argument(help="Agent id whose sessions should be listed.")],
+    search: Annotated[
+        str | None,
+        typer.Option("--search", help="Search session name and content."),
+    ] = None,
+    state: Annotated[
+        str | None,
+        typer.Option("--state", help="Filter by state (e.g. completed, failed, processing, idle)."),
+    ] = None,
+    type_filter: Annotated[
+        str | None,
+        typer.Option("--type", help="Filter by session type (e.g. api, chat, slack)."),
+    ] = None,
+    creator: Annotated[
+        str | None,
+        typer.Option("--creator", help="Filter by creator user id."),
+    ] = None,
+    trigger_id: Annotated[
+        str | None,
+        typer.Option("--trigger-id", help="Filter by originating trigger id."),
+    ] = None,
+    sort_order: Annotated[
+        str | None,
+        typer.Option("--sort", help="Sort order (e.g. newest, oldest, credits_desc, name_asc)."),
+    ] = None,
+    limit: Annotated[
+        int | None,
+        typer.Option("--limit", help="Maximum number of sessions to return."),
+    ] = None,
+    cursor: Annotated[
+        str | None,
+        typer.Option("--cursor", help="Pagination cursor from a previous list call."),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the raw SDK response as JSON."),
+    ] = False,
+) -> None:
+    """List an agent's sessions with search, filters, and sort."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(
+            lambda client: client.sessions.list(
+                agent_id,
+                search=search,
+                state=state,
+                type=type_filter,
+                creator_user_id=creator,
+                trigger_id=trigger_id,
+                sort_order=sort_order,
+                page_size=limit,
+                cursor=cursor,
+            )
+        )
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    if not response.sessions:
+        console.print("No sessions found.")
+    else:
+        console.print("ID", "STATE", "TYPE", "NAME", "CREATED", sep="\t", soft_wrap=True)
+        for session in response.sessions:
+            console.print(
+                session.id,
+                session.state or "",
+                session.type or "",
+                session.name or "",
+                session.created_at or "",
+                sep="\t",
+                soft_wrap=True,
+                markup=False,
+                highlight=False,
+            )
+
+    if response.next_cursor:
+        console.print(f"\n[dim]Next cursor:[/dim] {escape_markup(response.next_cursor)}")
+
+
 @sessions_app.command("get", epilog="Example:\n  gumloop sessions get session_abc --json")
 def get_session(
     ctx: typer.Context,

gumloop-0.3.2/src/gumloop/resources/agents.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+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 AgentResponse
+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
+
+
+class Agents:
+    def __init__(self, client: HttpClient) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        search: str | None = None,
+        team_id: str | None = None,
+        **kwargs: Any,
+    ) -> AgentListResponse:
+        return AgentListResponse.model_validate(
+            self._client.get("agents", params={"search": search, "team_id": team_id, **kwargs})
+        )
+
+    def create(
+        self,
+        request: AgentCreateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentResponse:
+        return AgentResponse.model_validate(
+            self._client.post("agents", json=AgentCreateRequest.build(request, **kwargs))
+        )
+
+    def retrieve(self, agent_id: str) -> AgentResponse:
+        return AgentResponse.model_validate(self._client.get(f"agents/{agent_id}"))
+
+    def update(
+        self,
+        agent_id: str,
+        request: AgentUpdateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentResponse:
+        return AgentResponse.model_validate(
+            self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
+        )
+
+    def get_evaluation_config(self, agent_id: str) -> EvaluationConfigResponse:
+        return EvaluationConfigResponse.model_validate(self._client.get(f"agents/{agent_id}/evaluation-config"))
+
+    def update_evaluation_config(
+        self,
+        agent_id: str,
+        request: EvaluationConfigUpdateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> EvaluationConfigResponse:
+        """Partially update the evaluation config. Only the fields you send are changed;
+        omitted fields keep their current value. A provided list (criteria/tags/
+        data_points) replaces that list wholesale."""
+        return EvaluationConfigResponse.model_validate(
+            self._client.patch(
+                f"agents/{agent_id}/evaluation-config",
+                json=EvaluationConfigUpdateRequest.build(request, **kwargs),
+            )
+        )
+
+    def list_evaluations(
+        self,
+        agent_id: str,
+        *,
+        grade: str | None = None,
+        page_size: int | None = None,
+        cursor: str | None = None,
+        **kwargs: Any,
+    ) -> EvaluationResultListResponse:
+        return EvaluationResultListResponse.model_validate(
+            self._client.get(
+                f"agents/{agent_id}/evaluations",
+                params={"grade": grade, "page_size": page_size, "cursor": cursor, **kwargs},
+            )
+        )
+
+    def get_evaluation(self, agent_id: str, evaluation_id: str) -> EvaluationResultResponse:
+        return EvaluationResultResponse.model_validate(
+            self._client.get(f"agents/{agent_id}/evaluations/{evaluation_id}")
+        )
+
+
+class Models:
+    def __init__(self, client: HttpClient) -> None:
+        self._client = client
+
+    def list(self, **kwargs: Any) -> ModelListResponse:
+        return ModelListResponse.model_validate(self._client.get("models", params=kwargs))
+
+
+class AsyncAgents:
+    def __init__(self, client: AsyncHttpClient) -> None:
+        self._client = client
+
+    async def list(
+        self,
+        *,
+        search: str | None = None,
+        team_id: str | None = None,
+        **kwargs: Any,
+    ) -> AgentListResponse:
+        data = await self._client.get("agents", params={"search": search, "team_id": team_id, **kwargs})
+        return AgentListResponse.model_validate(data)
+
+    async def create(
+        self,
+        request: AgentCreateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentResponse:
+        data = await self._client.post("agents", json=AgentCreateRequest.build(request, **kwargs))
+        return AgentResponse.model_validate(data)
+
+    async def retrieve(self, agent_id: str) -> AgentResponse:
+        return AgentResponse.model_validate(await self._client.get(f"agents/{agent_id}"))
+
+    async def update(
+        self,
+        agent_id: str,
+        request: AgentUpdateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentResponse:
+        data = await self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
+        return AgentResponse.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)
+
+    async def update_evaluation_config(
+        self,
+        agent_id: str,
+        request: EvaluationConfigUpdateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> EvaluationConfigResponse:
+        """Partially update the evaluation config. Only the fields you send are changed;
+        omitted fields keep their current value. A provided list (criteria/tags/
+        data_points) replaces that list wholesale."""
+        data = await self._client.patch(
+            f"agents/{agent_id}/evaluation-config",
+            json=EvaluationConfigUpdateRequest.build(request, **kwargs),
+        )
+        return EvaluationConfigResponse.model_validate(data)
+
+    async def list_evaluations(
+        self,
+        agent_id: str,
+        *,
+        grade: str | None = None,
+        page_size: int | None = None,
+        cursor: str | None = None,
+        **kwargs: Any,
+    ) -> EvaluationResultListResponse:
+        data = await self._client.get(
+            f"agents/{agent_id}/evaluations",
+            params={"grade": grade, "page_size": page_size, "cursor": cursor, **kwargs},
+        )
+        return EvaluationResultListResponse.model_validate(data)
+
+    async def get_evaluation(self, agent_id: str, evaluation_id: str) -> EvaluationResultResponse:
+        data = await self._client.get(f"agents/{agent_id}/evaluations/{evaluation_id}")
+        return EvaluationResultResponse.model_validate(data)
+
+
+class AsyncModels:
+    def __init__(self, client: AsyncHttpClient) -> None:
+        self._client = client
+
+    async def list(self, **kwargs: Any) -> ModelListResponse:
+        return ModelListResponse.model_validate(await self._client.get("models", params=kwargs))

{gumloop-0.3.1 → gumloop-0.3.2}/src/gumloop/resources/sessions.py

@@ -11,6 +11,7 @@ from gumloop._http import AsyncHttpClient
 from gumloop._http import HttpClient
 from gumloop.types import SessionContinueRequest
 from gumloop.types import SessionCreateRequest
+from gumloop.types import SessionListResponse
 from gumloop.types import SessionResponse
 from gumloop.types import StreamEvent
 
@@ -19,6 +20,37 @@ class Sessions:
     def __init__(self, client: HttpClient) -> None:
         self._client = client
 
+    def list(
+        self,
+        agent_id: str,
+        *,
+        search: str | None = None,
+        state: str | None = None,
+        type: str | None = None,
+        creator_user_id: str | None = None,
+        trigger_id: str | None = None,
+        sort_order: str | None = None,
+        page_size: int | None = None,
+        cursor: str | None = None,
+        **kwargs: Any,
+    ) -> SessionListResponse:
+        return SessionListResponse.model_validate(
+            self._client.get(
+                f"agents/{agent_id}/sessions",
+                params={
+                    "search": search,
+                    "state": state,
+                    "type": type,
+                    "creator_user_id": creator_user_id,
+                    "trigger_id": trigger_id,
+                    "sort_order": sort_order,
+                    "page_size": page_size,
+                    "cursor": cursor,
+                    **kwargs,
+                },
+            )
+        )
+
     @overload
     def create(
         self,
@@ -117,6 +149,36 @@ class AsyncSessions:
     def __init__(self, client: AsyncHttpClient) -> None:
         self._client = client
 
+    async def list(
+        self,
+        agent_id: str,
+        *,
+        search: str | None = None,
+        state: str | None = None,
+        type: str | None = None,
+        creator_user_id: str | None = None,
+        trigger_id: str | None = None,
+        sort_order: str | None = None,
+        page_size: int | None = None,
+        cursor: str | None = None,
+        **kwargs: Any,
+    ) -> SessionListResponse:
+        data = await self._client.get(
+            f"agents/{agent_id}/sessions",
+            params={
+                "search": search,
+                "state": state,
+                "type": type,
+                "creator_user_id": creator_user_id,
+                "trigger_id": trigger_id,
+                "sort_order": sort_order,
+                "page_size": page_size,
+                "cursor": cursor,
+                **kwargs,
+            },
+        )
+        return SessionListResponse.model_validate(data)
+
     @overload
     async def create(
         self,

{gumloop-0.3.1 → gumloop-0.3.2}/src/gumloop/types.py

@@ -4,6 +4,7 @@ import json
 from typing import Any
 from typing import Literal
 
+from pydantic import AliasChoices
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
@@ -152,6 +153,8 @@ class MessagePayload(_Model):
 class Session(_Model):
     id: str
     agent_id: str
+    name: str | None = None
+    type: str | None = None
     state: str | None = None
     messages: list[MessagePayload] = Field(default_factory=list)
     created_at: str | None = None
@@ -169,6 +172,11 @@ class SessionResponse(_Model):
     queue_position: int | None = None
 
 
+class SessionListResponse(_Model):
+    sessions: list[Session] = Field(default_factory=list)
+    next_cursor: str | None = None
+
+
 class StreamEvent(_Model):
     type: str | None = None
     data: Any = None
@@ -426,3 +434,66 @@ class McpPromptResponse(_Model):
     name: str | None = None
     description: str | None = None
     messages: list[McpPromptMessage] = Field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Evaluation types
+# ---------------------------------------------------------------------------
+
+
+class EvaluationConfig(_Model):
+    agent_id: str
+    enabled: bool = False
+    is_active: bool = True
+    model_name: str | None = None
+    frequency: str | None = None
+    language: str | None = None
+    include_auto_tags: bool = False
+    interaction_types: list[Any] = Field(default_factory=list)
+    criteria: list[Any] = Field(default_factory=list)
+    tags: list[Any] = Field(default_factory=list)
+    data_points: list[Any] = Field(default_factory=list)
+    sentiment: dict[str, Any] | None = None
+    updated_ts: str | None = None
+
+
+class EvaluationConfigResponse(_Model):
+    config: EvaluationConfig
+
+
+class EvaluationConfigUpdateRequest(_Model):
+    enabled: bool | None = None
+    model_name: str | None = None
+    frequency: str | None = None
+    language: str | None = None
+    include_auto_tags: bool | None = None
+    interaction_types: list[Any] | None = None
+    criteria: list[Any] | None = None
+    tags: list[Any] | None = None
+    data_points: list[Any] | None = None
+    sentiment: dict[str, Any] | None = None
+
+
+class EvaluationResult(_Model):
+    evaluation_id: str
+    session_id: str = Field(validation_alias=AliasChoices("interaction_id", "session_id"))
+    agent_id: str
+    created_ts: str | None = None
+    # "completed" | "failed"; grade/call_successful are null when failed.
+    status: str | None = None
+    grade: str | None = None
+    call_successful: str | None = None
+    sentiment: str | None = None
+    summary: str | None = None
+    criteria_results: list[Any] = Field(default_factory=list)
+    data_results: list[Any] = Field(default_factory=list)
+    applied_tags: list[Any] = Field(default_factory=list)
+
+
+class EvaluationResultResponse(_Model):
+    evaluation: EvaluationResult | None = None
+
+
+class EvaluationResultListResponse(_Model):
+    evaluations: list[EvaluationResult] = Field(default_factory=list)
+    next_cursor: str | None = None

{gumloop-0.3.1 → gumloop-0.3.2}/tests/cli/test_sessions.py

@@ -59,6 +59,33 @@ def test_sessions_create_rejects_both_input_and_input_stdin(cli_runner: CliRunne
     assert result.exit_code != 0
 
 
+@respx.mock
+def test_sessions_list_forwards_filters(cli_runner: CliRunner) -> None:
+    route = respx.get(f"{API_BASE}/agents/agent_abc/sessions").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "sessions": [{"id": "session_xyz", "agent_id": "agent_abc", "state": "completed"}],
+                "next_cursor": None,
+            },
+        )
+    )
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(
+        app,
+        ["sessions", "list", "agent_abc", "--state", "completed", "--search", "x", "--sort", "oldest", "--limit", "5"],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "session_xyz" in result.output
+    params = route.calls[0].request.url.params
+    assert params["state"] == "completed"
+    assert params["search"] == "x"
+    assert params["sort_order"] == "oldest"
+    assert params["page_size"] == "5"
+
+
 @respx.mock
 def test_sessions_get_calls_per_session_endpoint(cli_runner: CliRunner) -> None:
     respx.get(f"{API_BASE}/sessions/session_xyz").mock(

{gumloop-0.3.1 → gumloop-0.3.2}/tests/sdk/test_agents.py

@@ -100,6 +100,106 @@ def test_models_list(client: Gumloop) -> None:
     assert client.models.list().model_groups[0]["id"] == "auto"
 
 
+@respx.mock
+def test_agents_get_evaluation_config(client: Gumloop) -> None:
+    respx.get(f"{API_BASE}/agents/agent_123/evaluation-config").mock(
+        return_value=httpx.Response(200, json={"config": {"agent_id": "agent_123", "enabled": False}})
+    )
+
+    result = client.agents.get_evaluation_config("agent_123")
+
+    assert result.config.agent_id == "agent_123"
+    assert result.config.enabled is False
+
+
+@respx.mock
+def test_agents_update_evaluation_config_patches_only_sent_fields(client: Gumloop) -> None:
+    route = respx.patch(f"{API_BASE}/agents/agent_123/evaluation-config").mock(
+        return_value=httpx.Response(200, json={"config": {"agent_id": "agent_123", "enabled": True}})
+    )
+
+    result = client.agents.update_evaluation_config("agent_123", enabled=True)
+
+    assert result.config.enabled is True
+    # PATCH merge: only the field we set goes on the wire — omitted fields aren't
+    # cleared client-side (the backend preserves them).
+    assert request_json(route.calls[0].request) == {"enabled": True}
+
+
+@respx.mock
+def test_agents_list_evaluations_sends_filters(client: Gumloop) -> None:
+    route = respx.get(f"{API_BASE}/agents/agent_123/evaluations").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "evaluations": [{"evaluation_id": "eval_1", "interaction_id": "i1", "agent_id": "agent_123"}],
+                "next_cursor": "cursor_2",
+            },
+        )
+    )
+
+    result = client.agents.list_evaluations("agent_123", grade="needs_review", page_size=10, cursor="cursor_1")
+
+    assert result.evaluations[0].evaluation_id == "eval_1"
+    assert result.next_cursor == "cursor_2"
+    params = route.calls[0].request.url.params
+    assert params["grade"] == "needs_review"
+    assert params["page_size"] == "10"
+    assert params["cursor"] == "cursor_1"
+
+
+@respx.mock
+def test_agents_get_evaluation(client: Gumloop) -> None:
+    respx.get(f"{API_BASE}/agents/agent_123/evaluations/eval_1").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "evaluation": {
+                    "evaluation_id": "eval_1",
+                    "interaction_id": "i1",
+                    "agent_id": "agent_123",
+                    "status": "completed",
+                    "grade": "pass",
+                }
+            },
+        )
+    )
+
+    result = client.agents.get_evaluation("agent_123", "eval_1")
+
+    assert result.evaluation is not None
+    assert result.evaluation.evaluation_id == "eval_1"
+    assert result.evaluation.status == "completed"
+    assert result.evaluation.grade == "pass"
+
+
+@respx.mock
+def test_async_agents_evaluation_methods() -> None:
+    respx.get(f"{API_BASE}/agents/agent_123/evaluation-config").mock(
+        return_value=httpx.Response(200, json={"config": {"agent_id": "agent_123"}})
+    )
+    respx.patch(f"{API_BASE}/agents/agent_123/evaluation-config").mock(
+        return_value=httpx.Response(200, json={"config": {"agent_id": "agent_123", "enabled": True}})
+    )
+    respx.get(f"{API_BASE}/agents/agent_123/evaluations").mock(
+        return_value=httpx.Response(200, json={"evaluations": []})
+    )
+    respx.get(f"{API_BASE}/agents/agent_123/evaluations/eval_1").mock(
+        return_value=httpx.Response(
+            200, json={"evaluation": {"evaluation_id": "eval_1", "interaction_id": "i1", "agent_id": "agent_123"}}
+        )
+    )
+
+    async def run() -> None:
+        async with AsyncGumloop(access_token="token") as client:
+            assert (await client.agents.get_evaluation_config("agent_123")).config.agent_id == "agent_123"
+            assert (await client.agents.update_evaluation_config("agent_123", enabled=True)).config.enabled is True
+            assert (await client.agents.list_evaluations("agent_123")).evaluations == []
+            assert (await client.agents.get_evaluation("agent_123", "eval_1")).evaluation.evaluation_id == "eval_1"
+
+    asyncio.run(run())
+
+
 @respx.mock
 def test_async_agents_models_and_user_methods() -> None:
     respx.get(f"{API_BASE}/agents").mock(return_value=httpx.Response(200, json={"agents": []}))

{gumloop-0.3.1 → gumloop-0.3.2}/tests/sdk/test_sessions.py

@@ -82,6 +82,44 @@ def test_sessions_retrieve_send_and_cancel_routes(client: Gumloop) -> None:
     assert request_json(cancel_route.calls[0].request) == {}
 
 
+@respx.mock
+def test_sessions_list_forwards_filters_and_returns_envelope(client: Gumloop) -> None:
+    route = respx.get(f"{API_BASE}/agents/agent_123/sessions").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "sessions": [
+                    {"id": "session_123", "agent_id": "agent_123", "name": "Run", "type": "api", "state": "completed"}
+                ],
+                "next_cursor": "next",
+            },
+        )
+    )
+
+    result = client.sessions.list(
+        "agent_123",
+        search="invoice",
+        state="completed",
+        type="api",
+        sort_order="oldest",
+        page_size=10,
+        cursor="prev",
+    )
+
+    assert [s.id for s in result.sessions] == ["session_123"]
+    assert result.sessions[0].type == "api"
+    assert result.next_cursor == "next"
+    params = route.calls[0].request.url.params
+    assert params["search"] == "invoice"
+    assert params["state"] == "completed"
+    assert params["type"] == "api"
+    assert params["sort_order"] == "oldest"
+    assert params["page_size"] == "10"
+    assert params["cursor"] == "prev"
+    assert "creator_user_id" not in params
+    assert "trigger_id" not in params
+
+
 def test_sessions_send_requires_input_or_message() -> None:
     client = Gumloop(access_token="token")
 
@@ -163,6 +201,9 @@ def test_async_sessions_methods() -> None:
             200, json={"session": {"id": "session_123", "agent_id": "agent_123", "state": "cancelled"}}
         )
     )
+    respx.get(f"{API_BASE}/agents/agent_123/sessions").mock(
+        return_value=httpx.Response(200, json={"sessions": [{"id": "session_123", "agent_id": "agent_123"}]})
+    )
 
     async def run() -> None:
         async with AsyncGumloop(access_token="token") as client:
@@ -170,6 +211,8 @@ def test_async_sessions_methods() -> None:
             assert (await client.sessions.retrieve("session_123")).session.id == "session_123"
             assert (await client.sessions.send("session_123", input="Hello")).session.id == "session_123"
             assert (await client.sessions.cancel("session_123")).session.id == "session_123"
+            listed = await client.sessions.list("agent_123", state="completed")
+            assert [s.id for s in listed.sessions] == ["session_123"]
 
     asyncio.run(run())
 

{gumloop-0.3.1 → gumloop-0.3.2}/uv.lock

@@ -328,7 +328,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -355,7 +355,7 @@ wheels = [
 
 [[package]]
 name = "gumloop"
-version = "0.3.1"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

gumloop-0.3.1/src/gumloop/resources/agents.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-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 AgentResponse
-from gumloop.types import AgentUpdateRequest
-from gumloop.types import ModelListResponse
-
-
-class Agents:
-    def __init__(self, client: HttpClient) -> None:
-        self._client = client
-
-    def list(
-        self,
-        *,
-        search: str | None = None,
-        team_id: str | None = None,
-        **kwargs: Any,
-    ) -> AgentListResponse:
-        return AgentListResponse.model_validate(
-            self._client.get("agents", params={"search": search, "team_id": team_id, **kwargs})
-        )
-
-    def create(
-        self,
-        request: AgentCreateRequest | Mapping[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> AgentResponse:
-        return AgentResponse.model_validate(
-            self._client.post("agents", json=AgentCreateRequest.build(request, **kwargs))
-        )
-
-    def retrieve(self, agent_id: str) -> AgentResponse:
-        return AgentResponse.model_validate(self._client.get(f"agents/{agent_id}"))
-
-    def update(
-        self,
-        agent_id: str,
-        request: AgentUpdateRequest | Mapping[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> AgentResponse:
-        return AgentResponse.model_validate(
-            self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
-        )
-
-
-class Models:
-    def __init__(self, client: HttpClient) -> None:
-        self._client = client
-
-    def list(self, **kwargs: Any) -> ModelListResponse:
-        return ModelListResponse.model_validate(self._client.get("models", params=kwargs))
-
-
-class AsyncAgents:
-    def __init__(self, client: AsyncHttpClient) -> None:
-        self._client = client
-
-    async def list(
-        self,
-        *,
-        search: str | None = None,
-        team_id: str | None = None,
-        **kwargs: Any,
-    ) -> AgentListResponse:
-        data = await self._client.get("agents", params={"search": search, "team_id": team_id, **kwargs})
-        return AgentListResponse.model_validate(data)
-
-    async def create(
-        self,
-        request: AgentCreateRequest | Mapping[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> AgentResponse:
-        data = await self._client.post("agents", json=AgentCreateRequest.build(request, **kwargs))
-        return AgentResponse.model_validate(data)
-
-    async def retrieve(self, agent_id: str) -> AgentResponse:
-        return AgentResponse.model_validate(await self._client.get(f"agents/{agent_id}"))
-
-    async def update(
-        self,
-        agent_id: str,
-        request: AgentUpdateRequest | Mapping[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> AgentResponse:
-        data = await self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
-        return AgentResponse.model_validate(data)
-
-
-class AsyncModels:
-    def __init__(self, client: AsyncHttpClient) -> None:
-        self._client = client
-
-    async def list(self, **kwargs: Any) -> ModelListResponse:
-        return ModelListResponse.model_validate(await self._client.get("models", params=kwargs))