gumloop 0.3.1__tar.gz → 0.3.3__tar.gz

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

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

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

{gumloop-0.3.1 → gumloop-0.3.3}/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.3"
 __all__ = [
     "APIStatusError",
     "AsyncGumloop",

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

@@ -15,12 +15,14 @@ from gumloop.resources import Agents
 from gumloop.resources import Artifacts
 from gumloop.resources import AsyncAgents
 from gumloop.resources import AsyncArtifacts
+from gumloop.resources import AsyncBrain
 from gumloop.resources import AsyncChat
 from gumloop.resources import AsyncMCP
 from gumloop.resources import AsyncModels
 from gumloop.resources import AsyncSessions
 from gumloop.resources import AsyncSkills
 from gumloop.resources import AsyncTeams
+from gumloop.resources import Brain
 from gumloop.resources import Chat
 from gumloop.resources import Models
 from gumloop.resources import Sessions
@@ -41,9 +43,9 @@ def _derive_stream_base_url(base_url: str) -> str:
 class Gumloop:
     """Sync Gumloop SDK client. Composes an :class:`HttpClient` with the
     resource classes (``agents``, ``sessions``, ``mcp``, ``teams``,
-    ``skills``, ``artifacts``, ``models``). The :attr:`oauth` attribute
-    holds OAuth helpers — kept off the transport because it bootstraps the
-    bearer token rather than consuming one."""
+    ``skills``, ``artifacts``, ``brain``, ``models``). The :attr:`oauth`
+    attribute holds OAuth helpers — kept off the transport because it
+    bootstraps the bearer token rather than consuming one."""
 
     def __init__(
         self,
@@ -85,6 +87,7 @@ class Gumloop:
         self.teams = Teams(self._http)
         self.skills = Skills(self._http)
         self.artifacts = Artifacts(self._http)
+        self.brain = Brain(self._http)
         self.oauth = OAuth(base_url=self.base_url, timeout=self.timeout)
 
     def close(self) -> None:
@@ -137,6 +140,7 @@ class AsyncGumloop:
         self.teams = AsyncTeams(self._http)
         self.skills = AsyncSkills(self._http)
         self.artifacts = AsyncArtifacts(self._http)
+        self.brain = AsyncBrain(self._http)
         self.oauth = OAuth(base_url=self.base_url, timeout=self.timeout)
 
     async def __aenter__(self) -> AsyncGumloop:

{gumloop-0.3.1 → gumloop-0.3.3}/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.3/src/gumloop/cli/commands/brain.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from gumloop import GumloopError
+from gumloop.cli.console import console
+from gumloop.cli.console import print_json
+from gumloop.cli.context import CliContext
+from gumloop.cli.errors import exit_with_error
+
+brain_app = typer.Typer(help="Search your Company Brain.", no_args_is_help=True, rich_markup_mode="rich")
+
+
+@brain_app.command(
+    "search",
+    epilog=(
+        "Examples:\n"
+        '  gumloop brain search "onboarding process"\n'
+        '  gumloop brain search "pricing" --limit 5 --source notion --json'
+    ),
+)
+def search_brain(
+    ctx: typer.Context,
+    query: Annotated[str, typer.Argument(help="Search query.")],
+    limit: Annotated[
+        int | None,
+        typer.Option("--limit", help="Maximum number of results to return (1-50)."),
+    ] = None,
+    source: Annotated[
+        list[str] | None,
+        typer.Option("--source", help="Filter by source type (repeatable), e.g. notion, google_drive, slack."),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the raw SDK response as JSON."),
+    ] = False,
+) -> None:
+    """Search indexed Company Brain sources."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(
+            lambda client: client.brain.search(query, limit=limit, source_type=source or None)
+        )
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    if not response.results:
+        console.print("No results found.")
+        return
+
+    console.print("SCORE", "SOURCE", "TITLE", "URL", sep="\t", soft_wrap=True)
+    for result in response.results:
+        console.print(
+            "" if result.score is None else f"{result.score:.3f}",
+            result.source or "",
+            result.title or "",
+            result.url or "",
+            sep="\t",
+            soft_wrap=True,
+        )

{gumloop-0.3.1 → gumloop-0.3.3}/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.1 → gumloop-0.3.3}/src/gumloop/cli/main.py

@@ -11,6 +11,7 @@ from gumloop.cli.commands.agents import agents_app
 from gumloop.cli.commands.artifacts import artifacts_app
 from gumloop.cli.commands.auth import login as login_command
 from gumloop.cli.commands.auth import logout as logout_command
+from gumloop.cli.commands.brain import brain_app
 from gumloop.cli.commands.chat import chat_app
 from gumloop.cli.commands.mcp import mcp_app
 from gumloop.cli.commands.sessions import sessions_app
@@ -97,6 +98,7 @@ app.add_typer(sessions_app, name="sessions")
 app.add_typer(skills_app, name="skills")
 app.add_typer(artifacts_app, name="artifacts")
 app.add_typer(chat_app, name="chat")
+app.add_typer(brain_app, name="brain")
 
 
 def _require_supported_platform() -> None:

{gumloop-0.3.1 → gumloop-0.3.3}/src/gumloop/resources/__init__.py

@@ -6,6 +6,8 @@ from gumloop.resources.agents import AsyncModels
 from gumloop.resources.agents import Models
 from gumloop.resources.artifacts import Artifacts
 from gumloop.resources.artifacts import AsyncArtifacts
+from gumloop.resources.brain import AsyncBrain
+from gumloop.resources.brain import Brain
 from gumloop.resources.chat import AsyncChat
 from gumloop.resources.chat import Chat
 from gumloop.resources.mcp import MCP
@@ -23,12 +25,14 @@ __all__ = [
     "Artifacts",
     "AsyncAgents",
     "AsyncArtifacts",
+    "AsyncBrain",
     "AsyncChat",
     "AsyncMCP",
     "AsyncModels",
     "AsyncSessions",
     "AsyncSkills",
     "AsyncTeams",
+    "Brain",
     "Chat",
     "Models",
     "Sessions",

gumloop-0.3.3/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.3/src/gumloop/resources/brain.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any
+
+from gumloop._http import AsyncHttpClient
+from gumloop._http import HttpClient
+from gumloop.types import BrainSearchRequest
+from gumloop.types import BrainSearchResponse
+
+
+class Brain:
+    def __init__(self, client: HttpClient) -> None:
+        self._client = client
+
+    def search(
+        self,
+        query: str,
+        *,
+        limit: int | None = None,
+        source_type: list[str] | None = None,
+        **kwargs: Any,
+    ) -> BrainSearchResponse:
+        return BrainSearchResponse.model_validate(
+            self._client.post(
+                "brain/search",
+                json=BrainSearchRequest.build(query=query, limit=limit, source_type=source_type, **kwargs),
+            )
+        )
+
+
+class AsyncBrain:
+    def __init__(self, client: AsyncHttpClient) -> None:
+        self._client = client
+
+    async def search(
+        self,
+        query: str,
+        *,
+        limit: int | None = None,
+        source_type: list[str] | None = None,
+        **kwargs: Any,
+    ) -> BrainSearchResponse:
+        data = await self._client.post(
+            "brain/search",
+            json=BrainSearchRequest.build(query=query, limit=limit, source_type=source_type, **kwargs),
+        )
+        return BrainSearchResponse.model_validate(data)

{gumloop-0.3.1 → gumloop-0.3.3}/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,