gumloop 0.3.0__tar.gz → 0.3.1__tar.gz

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

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

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

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

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

@@ -51,7 +51,7 @@ class Gumloop:
         *,
         access_token: str | None = None,
         user_id: str | None = None,
-        base_url: str = DEFAULT_BASE_URL,
+        base_url: str | None = None,
         stream_base_url: str | None = None,
         timeout: float = DEFAULT_TIMEOUT,
         stream_timeout: float | None = DEFAULT_STREAM_TIMEOUT,
@@ -62,7 +62,8 @@ class Gumloop:
         # x-auth-key header to look up the owner's stored secret. OAuth
         # callers omit it because the bearer token already identifies them.
         self.user_id = user_id or os.environ.get("GUMLOOP_USER_ID")
-        self.base_url = base_url.rstrip("/")
+        # 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("/")
         self.stream_base_url = (stream_base_url or _derive_stream_base_url(self.base_url)).rstrip("/")
         self.timeout = timeout
         self.stream_timeout = stream_timeout
@@ -105,7 +106,7 @@ class AsyncGumloop:
         *,
         access_token: str | None = None,
         user_id: str | None = None,
-        base_url: str = DEFAULT_BASE_URL,
+        base_url: str | None = None,
         stream_base_url: str | None = None,
         timeout: float = DEFAULT_TIMEOUT,
         stream_timeout: float | None = DEFAULT_STREAM_TIMEOUT,
@@ -113,7 +114,8 @@ class AsyncGumloop:
         self.api_key = api_key
         self.access_token = access_token or api_key or os.environ.get("GUMLOOP_ACCESS_TOKEN")
         self.user_id = user_id or os.environ.get("GUMLOOP_USER_ID")
-        self.base_url = base_url.rstrip("/")
+        # 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("/")
         self.stream_base_url = (stream_base_url or _derive_stream_base_url(self.base_url)).rstrip("/")
         self.timeout = timeout
         self.stream_timeout = stream_timeout

{gumloop-0.3.0 → gumloop-0.3.1}/src/gumloop/cli/commands/mcp.py

@@ -140,7 +140,7 @@ def call_tool(
     ] = None,
     json_output: Annotated[
         bool,
-        typer.Option("--json", help="Print the raw SDK response as JSON."),
+        typer.Option("--json", help="Print the tool response as JSON, decoding JSON text content when possible."),
     ] = False,
 ) -> None:
     """Execute an MCP tool on a server."""
@@ -160,7 +160,7 @@ def call_tool(
         exit_with_error(error, json_output=json_output)
 
     if json_output:
-        print_json(response)
+        print_json(response.model_dump_decoded_content())
         return
 
     # markup=False on remote fields stops MCP server output from rendering
@@ -176,10 +176,183 @@ def call_tool(
         console.print(f"  status: {result.status}", markup=False, highlight=False)
         if result.error:
             console.print(f"  error: {result.error}", markup=False, highlight=False)
-        content = result.content
+        content = result.decoded_content
         if not content:
             continue
         if isinstance(content, str):
             console.print(content, markup=False, highlight=False)
         else:
             print_json(content)
+
+
+@mcp_app.command("resources", epilog="Example:\n  gumloop mcp resources gmail")
+def list_resources(
+    ctx: typer.Context,
+    server: Annotated[str, typer.Argument(help="MCP server id whose resources should be listed.")],
+    cursor: Annotated[str | None, typer.Option("--cursor", help="Pagination cursor from a previous page.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Print the raw SDK response as JSON.")] = False,
+) -> None:
+    """List the resources a connected MCP server exposes."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(
+            lambda client: client.mcp.list_resources(server, cursor=cursor, team_id=cli.effective_team_id)
+        )
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    if response.status and response.status != "connected":
+        status_text = escape_markup(response.status)
+        console.print(f"Server [bold]{escape_markup(server)}[/bold] is not connected ({status_text}).")
+        if response.gumloop_auth_url:
+            console.print(f"Connect here: {response.gumloop_auth_url}", markup=False, highlight=False)
+        return
+
+    if not response.resources:
+        console.print("No resources found.")
+        return
+
+    console.print("URI", "NAME", "MIME_TYPE", "DESCRIPTION", sep="\t", soft_wrap=True)
+    for resource in response.resources:
+        console.print(
+            resource.uri,
+            resource.name or "",
+            resource.mime_type or "",
+            resource.description or "",
+            sep="\t",
+            soft_wrap=True,
+        )
+    if response.next_cursor:
+        console.print(
+            f"\nMore results — next page: --cursor {response.next_cursor}",
+            markup=False,
+            highlight=False,
+        )
+
+
+@mcp_app.command("resource", epilog='Example:\n  gumloop mcp resource gmail "gmail://label/INBOX"')
+def read_resource(
+    ctx: typer.Context,
+    server: Annotated[str, typer.Argument(help="MCP server id (for example 'gmail').")],
+    uri: Annotated[str, typer.Argument(help="Resource URI to read (for example 'gmail://label/INBOX').")],
+    json_output: Annotated[bool, typer.Option("--json", help="Print the raw SDK response as JSON.")] = False,
+) -> None:
+    """Read a single MCP resource by URI."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(
+            lambda client: client.mcp.get_resource(server, uri, team_id=cli.effective_team_id)
+        )
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    text = response.text
+    if text is not None:
+        console.print(text, markup=False, highlight=False)
+        return
+    # Binary or empty contents: fall back to the structured payload.
+    if not response.contents:
+        console.print("(no content)")
+        return
+    print_json(response)
+
+
+@mcp_app.command("prompts", epilog="Example:\n  gumloop mcp prompts gmail")
+def list_prompts(
+    ctx: typer.Context,
+    server: Annotated[str, typer.Argument(help="MCP server id whose prompts should be listed.")],
+    json_output: Annotated[bool, typer.Option("--json", help="Print the raw SDK response as JSON.")] = False,
+) -> None:
+    """List the prompts a connected MCP server exposes."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(lambda client: client.mcp.list_prompts(server, team_id=cli.effective_team_id))
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    if response.status and response.status != "connected":
+        status_text = escape_markup(response.status)
+        console.print(f"Server [bold]{escape_markup(server)}[/bold] is not connected ({status_text}).")
+        if response.gumloop_auth_url:
+            console.print(f"Connect here: {response.gumloop_auth_url}", markup=False, highlight=False)
+        return
+
+    if not response.prompts:
+        console.print("No prompts found.")
+        return
+
+    console.print("NAME", "ARGUMENTS", "DESCRIPTION", sep="\t", soft_wrap=True)
+    for prompt in response.prompts:
+        # A trailing * marks a required argument.
+        args = ", ".join(f"{arg.name}*" if arg.required else arg.name for arg in prompt.arguments)
+        console.print(prompt.name, args, prompt.description or "", sep="\t", soft_wrap=True)
+
+
+@mcp_app.command(
+    "prompt",
+    epilog=(
+        "Examples:\n"
+        '  gumloop mcp prompt gmail summarize_thread --args-json \'{"thread_id": "abc"}\'\n'
+        "  gumloop mcp prompt gmail summarize_thread --args-file ./args.json"
+    ),
+)
+def get_prompt(
+    ctx: typer.Context,
+    server: Annotated[str, typer.Argument(help="MCP server id (for example 'gmail').")],
+    name: Annotated[str, typer.Argument(help="Prompt name on that server.")],
+    args_json: Annotated[
+        str | None,
+        typer.Option("--args-json", help="Inline JSON object of prompt arguments."),
+    ] = None,
+    args_file: Annotated[
+        str | None,
+        typer.Option("--args-file", help="Path to a file containing the JSON arguments."),
+    ] = None,
+    args_stdin: Annotated[
+        str | None,
+        typer.Option("--args", help="Use '-' to read JSON arguments from stdin.", metavar="-"),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print the prompt response as JSON."),
+    ] = False,
+) -> None:
+    """Get (render) an MCP prompt with arguments."""
+    cli: CliContext = ctx.obj
+    try:
+        arguments = resolve_json_args(inline=args_json, file_path=args_file, stdin_marker=args_stdin)
+        response = cli.call_with_refresh(
+            lambda client: client.mcp.get_prompt(server, name, arguments, team_id=cli.effective_team_id)
+        )
+    except GumloopError as error:
+        exit_with_error(error, json_output=json_output)
+
+    if json_output:
+        print_json(response)
+        return
+
+    if response.description:
+        console.print(response.description, markup=False, highlight=False)
+    if not response.messages:
+        console.print("(no messages)")
+        return
+    for message in response.messages:
+        role = message.role or ""
+        console.print(f"[bold]{escape_markup(role)}[/bold]", markup=True, highlight=False)
+        text = message.content.get("text") if isinstance(message.content, dict) else None
+        if text:
+            console.print(text, markup=False, highlight=False)
+        else:
+            print_json(message.content)

{gumloop-0.3.0 → gumloop-0.3.1}/src/gumloop/resources/mcp.py

@@ -6,6 +6,10 @@ from typing import Any
 from gumloop._http import AsyncHttpClient
 from gumloop._http import HttpClient
 from gumloop.types import McpExecuteResponse
+from gumloop.types import McpPromptResponse
+from gumloop.types import McpPromptsResponse
+from gumloop.types import McpResourceReadResponse
+from gumloop.types import McpResourcesResponse
 from gumloop.types import McpServerResponse
 from gumloop.types import McpServersResponse
 from gumloop.types import McpToolCallRequest
@@ -42,6 +46,44 @@ class MCP:
             self._client.get(f"mcp/servers/{server_id}/tools", params={"team_id": team_id, **kwargs})
         )
 
+    def list_resources(
+        self, server_id: str, *, cursor: str | None = None, team_id: str | None = None, **kwargs: Any
+    ) -> McpResourcesResponse:
+        return McpResourcesResponse.model_validate(
+            self._client.get(
+                f"mcp/servers/{server_id}/resources",
+                params={"cursor": cursor, "team_id": team_id, **kwargs},
+            )
+        )
+
+    def get_resource(
+        self, server_id: str, uri: str, *, team_id: str | None = None, **kwargs: Any
+    ) -> McpResourceReadResponse:
+        return McpResourceReadResponse.model_validate(
+            self._client.get(
+                f"mcp/servers/{server_id}/resources/read",
+                params={"uri": uri, "team_id": team_id, **kwargs},
+            )
+        )
+
+    def list_prompts(self, server_id: str, *, team_id: str | None = None, **kwargs: Any) -> McpPromptsResponse:
+        return McpPromptsResponse.model_validate(
+            self._client.get(f"mcp/servers/{server_id}/prompts", params={"team_id": team_id, **kwargs})
+        )
+
+    def get_prompt(
+        self,
+        server_id: str,
+        name: str,
+        arguments: dict[str, Any] | None = None,
+        *,
+        team_id: str | None = None,
+    ) -> McpPromptResponse:
+        body: dict[str, Any] = {"name": name, "arguments": arguments or {}}
+        if team_id is not None:
+            body["team_id"] = team_id
+        return McpPromptResponse.model_validate(self._client.post(f"mcp/servers/{server_id}/prompts/get", json=body))
+
     def execute(
         self,
         server_id: str,
@@ -84,6 +126,42 @@ class AsyncMCP:
         data = await self._client.get(f"mcp/servers/{server_id}/tools", params={"team_id": team_id, **kwargs})
         return McpToolsResponse.model_validate(data)
 
+    async def list_resources(
+        self, server_id: str, *, cursor: str | None = None, team_id: str | None = None, **kwargs: Any
+    ) -> McpResourcesResponse:
+        data = await self._client.get(
+            f"mcp/servers/{server_id}/resources",
+            params={"cursor": cursor, "team_id": team_id, **kwargs},
+        )
+        return McpResourcesResponse.model_validate(data)
+
+    async def get_resource(
+        self, server_id: str, uri: str, *, team_id: str | None = None, **kwargs: Any
+    ) -> McpResourceReadResponse:
+        data = await self._client.get(
+            f"mcp/servers/{server_id}/resources/read",
+            params={"uri": uri, "team_id": team_id, **kwargs},
+        )
+        return McpResourceReadResponse.model_validate(data)
+
+    async def list_prompts(self, server_id: str, *, team_id: str | None = None, **kwargs: Any) -> McpPromptsResponse:
+        data = await self._client.get(f"mcp/servers/{server_id}/prompts", params={"team_id": team_id, **kwargs})
+        return McpPromptsResponse.model_validate(data)
+
+    async def get_prompt(
+        self,
+        server_id: str,
+        name: str,
+        arguments: dict[str, Any] | None = None,
+        *,
+        team_id: str | None = None,
+    ) -> McpPromptResponse:
+        body: dict[str, Any] = {"name": name, "arguments": arguments or {}}
+        if team_id is not None:
+            body["team_id"] = team_id
+        data = await self._client.post(f"mcp/servers/{server_id}/prompts/get", json=body)
+        return McpPromptResponse.model_validate(data)
+
     async def execute(
         self,
         server_id: str,

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 from typing import Literal
 
@@ -300,6 +301,20 @@ class McpToolCallResult(_Model):
     content: list[Any] | None = None
     error: dict[str, Any] | None = None
 
+    @property
+    def decoded_content(self) -> list[Any] | None:
+        """Each content string JSON-decoded; plain text passes through. guMCP returns
+        one string per TextContent, usually a JSON dump but sometimes plain text."""
+        if self.content is None:
+            return None
+        decoded: list[Any] = []
+        for item in self.content:
+            try:
+                decoded.append(json.loads(item) if isinstance(item, str) else item)
+            except json.JSONDecodeError:
+                decoded.append(item)
+        return decoded
+
 
 class McpServersResponse(_Model):
     servers: list[McpServer] = Field(default_factory=list)
@@ -318,3 +333,96 @@ class McpToolsResponse(_Model):
 
 class McpExecuteResponse(_Model):
     results: list[McpToolCallResult] = Field(default_factory=list)
+
+    def model_dump_decoded_content(self) -> dict[str, Any]:
+        payload = self.model_dump(mode="json")
+        results = payload.get("results")
+        if not isinstance(results, list):
+            return payload
+        for index, result in enumerate(self.results):
+            if index < len(results) and isinstance(results[index], dict):
+                results[index]["content"] = result.decoded_content
+        return payload
+
+
+# ---------------------------------------------------------------------------
+# MCP resource types
+# ---------------------------------------------------------------------------
+
+
+class McpResource(_Model):
+    uri: str
+    name: str | None = None
+    title: str | None = None
+    description: str | None = None
+    mime_type: str | None = None
+    size: int | None = None
+    server_id: str | None = None
+
+
+class McpResourcesResponse(_Model):
+    resources: list[McpResource] = Field(default_factory=list)
+    server_id: str | None = None
+    status: str | None = None
+    gumloop_auth_url: str | None = None
+    next_cursor: str | None = None
+
+
+class McpResourceContent(_Model):
+    uri: str | None = None
+    mime_type: str | None = None
+    # A content item is either text or a base64 blob.
+    text: str | None = None
+    blob: str | None = None
+
+
+class McpResourceReadResponse(_Model):
+    server_id: str | None = None
+    uri: str | None = None
+    contents: list[McpResourceContent] = Field(default_factory=list)
+
+    @property
+    def text(self) -> str | None:
+        """All text contents joined with newlines, or None if the resource is
+        binary/empty. Most resources are a single text blob, so this is the value
+        callers usually want — parallels ``McpToolCallResult.decoded_content``."""
+        parts = [content.text for content in self.contents if content.text]
+        return "\n".join(parts) if parts else None
+
+
+# ---------------------------------------------------------------------------
+# MCP prompt types
+# ---------------------------------------------------------------------------
+
+
+class McpPromptArgument(_Model):
+    name: str
+    description: str | None = None
+    required: bool | None = None
+
+
+class McpPrompt(_Model):
+    name: str
+    description: str | None = None
+    arguments: list[McpPromptArgument] = Field(default_factory=list)
+    server_id: str | None = None
+
+
+class McpPromptsResponse(_Model):
+    prompts: list[McpPrompt] = Field(default_factory=list)
+    server_id: str | None = None
+    status: str | None = None
+    gumloop_auth_url: str | None = None
+
+
+class McpPromptMessage(_Model):
+    role: str | None = None
+    # content is {type, text, resource?, ...} — kept open across MCP content variants.
+    content: dict[str, Any] = Field(default_factory=dict)
+
+
+class McpPromptResponse(_Model):
+    server_id: str | None = None
+    name: str | None = None
+    description: str | None = None
+    messages: list[McpPromptMessage] = Field(default_factory=list)

{gumloop-0.3.0 → gumloop-0.3.1}/tests/cli/test_mcp.py

@@ -163,3 +163,101 @@ def test_mcp_call_rejects_multiple_args_input_modes(cli_runner: CliRunner, tmp_p
     )
 
     assert result.exit_code == 1
+
+
+@respx.mock
+def test_mcp_resources_lists_rich_fields(cli_runner: CliRunner) -> None:
+    payload = {
+        "server_id": "gmail",
+        "status": "connected",
+        "resources": [
+            {"uri": "gmail://label/INBOX", "name": "Inbox", "mime_type": "application/json", "description": "Primary"}
+        ],
+    }
+    respx.get(f"{API_BASE}/mcp/servers/gmail/resources").mock(return_value=httpx.Response(200, json=payload))
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["mcp", "resources", "gmail"])
+
+    assert result.exit_code == 0
+    assert "gmail://label/INBOX" in result.output
+    assert "application/json" in result.output
+
+
+@respx.mock
+def test_mcp_resources_shows_auth_url_when_not_connected(cli_runner: CliRunner) -> None:
+    payload = {
+        "server_id": "gmail",
+        "status": "unauthenticated",
+        "gumloop_auth_url": "https://example.com/settings/profile/apps?server=gmail",
+        "resources": [],
+    }
+    respx.get(f"{API_BASE}/mcp/servers/gmail/resources").mock(return_value=httpx.Response(200, json=payload))
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["mcp", "resources", "gmail"])
+
+    assert result.exit_code == 0
+    assert "not connected" in result.output
+    assert "https://example.com/settings/profile/apps?server=gmail" in result.output
+
+
+@respx.mock
+def test_mcp_resource_prints_text_content(cli_runner: CliRunner) -> None:
+    payload = {
+        "server_id": "gmail",
+        "uri": "gmail://label/INBOX",
+        "contents": [{"mime_type": "text/plain", "text": "hello world"}],
+    }
+    route = respx.get(f"{API_BASE}/mcp/servers/gmail/resources/read").mock(
+        return_value=httpx.Response(200, json=payload)
+    )
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["mcp", "resource", "gmail", "gmail://label/INBOX"])
+
+    assert result.exit_code == 0
+    assert "hello world" in result.output
+    assert route.calls[0].request.url.params["uri"] == "gmail://label/INBOX"
+
+
+@respx.mock
+def test_mcp_prompts_lists_arguments(cli_runner: CliRunner) -> None:
+    payload = {
+        "server_id": "gmail",
+        "status": "connected",
+        "prompts": [
+            {
+                "name": "summarize",
+                "description": "Summarize a thread",
+                "arguments": [{"name": "thread_id", "required": True}],
+            }
+        ],
+    }
+    respx.get(f"{API_BASE}/mcp/servers/gmail/prompts").mock(return_value=httpx.Response(200, json=payload))
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["mcp", "prompts", "gmail"])
+
+    assert result.exit_code == 0
+    assert "summarize" in result.output
+    assert "thread_id*" in result.output  # trailing * marks a required argument
+
+
+@respx.mock
+def test_mcp_prompt_posts_args_and_prints_messages(cli_runner: CliRunner) -> None:
+    payload = {
+        "server_id": "gmail",
+        "name": "summarize",
+        "description": "Summarize a thread",
+        "messages": [{"role": "user", "content": {"type": "text", "text": "Please summarize"}}],
+    }
+    route = respx.post(f"{API_BASE}/mcp/servers/gmail/prompts/get").mock(return_value=httpx.Response(200, json=payload))
+    save_credentials(Credentials(api_key="key"))
+
+    result = cli_runner.invoke(app, ["mcp", "prompt", "gmail", "summarize", "--args-json", '{"thread_id": "abc"}'])
+
+    assert result.exit_code == 0
+    assert "Please summarize" in result.output
+    sent = route.calls[0].request.content
+    assert b'"thread_id": "abc"' in sent or b'"thread_id":"abc"' in sent

gumloop-0.3.1/tests/sdk/test_mcp.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import asyncio
+
+import httpx
+import pytest
+import respx
+
+from gumloop import AsyncGumloop
+from gumloop import Gumloop
+from tests.sdk.helpers import API_BASE
+from tests.sdk.helpers import request_json
+
+
+@respx.mock
+def test_mcp_list_servers_and_get_server_routes(client: Gumloop) -> None:
+    list_route = respx.get(f"{API_BASE}/mcp/servers").mock(return_value=httpx.Response(200, json={"servers": []}))
+    get_route = respx.get(f"{API_BASE}/mcp/servers/gmail").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "server": {"server_id": "gmail", "type": "gumcp", "status": "ok", "gumloop_auth_url": "u"},
+            },
+        )
+    )
+
+    assert client.mcp.list_servers(team_id="team_123").servers == []
+    assert client.mcp.get_server("gmail", team_id="team_123").server.server_id == "gmail"
+    assert list_route.calls[0].request.url.params["team_id"] == "team_123"
+    assert get_route.calls[0].request.url.params["team_id"] == "team_123"
+
+
+@respx.mock
+def test_mcp_list_tools_uses_server_path(client: Gumloop) -> None:
+    route = respx.get(f"{API_BASE}/mcp/servers/gmail/tools").mock(
+        return_value=httpx.Response(200, json={"tools": [], "server_id": "gmail", "status": "connected"})
+    )
+
+    result = client.mcp.list_tools("gmail", team_id="team_123")
+
+    assert result.tools == []
+    assert result.server_id == "gmail"
+    assert result.status == "connected"
+    params = route.calls[0].request.url.params
+    assert params["team_id"] == "team_123"
+
+
+@respx.mock
+def test_mcp_execute_single_and_many_bodies(client: Gumloop) -> None:
+    route = respx.post(f"{API_BASE}/mcp/tools/call").mock(return_value=httpx.Response(200, json={"results": []}))
+
+    assert (
+        client.mcp.execute(
+            "gmail",
+            "read_emails",
+            {"max_results": 5},
+            team_id="team_123",
+        ).results
+        == []
+    )
+    assert request_json(route.calls[0].request) == {
+        "calls": [{"server_id": "gmail", "tool_name": "read_emails", "arguments": {"max_results": 5}}],
+        "team_id": "team_123",
+    }
+
+    calls = [
+        {
+            "ref": "emails",
+            "server_id": "gmail",
+            "tool_name": "read_emails",
+            "arguments": {"max_results": 5},
+        }
+    ]
+    assert client.mcp.execute_many(calls, team_id="team_123").results == []
+    assert request_json(route.calls[1].request) == {
+        "team_id": "team_123",
+        "calls": [
+            {
+                "ref": "emails",
+                "server_id": "gmail",
+                "tool_name": "read_emails",
+                "arguments": {"max_results": 5},
+            }
+        ],
+    }
+
+
+@respx.mock
+def test_mcp_execute_with_ref(client: Gumloop) -> None:
+    route = respx.post(f"{API_BASE}/mcp/tools/call").mock(return_value=httpx.Response(200, json={"results": []}))
+
+    client.mcp.execute("gmail", "read_emails", ref="my_ref")
+
+    call_body = request_json(route.calls[0].request)
+    assert call_body["calls"][0]["ref"] == "my_ref"
+
+
+def test_mcp_execute_many_rejects_empty_calls(client: Gumloop) -> None:
+    with pytest.raises(ValueError, match="empty"):
+        client.mcp.execute_many([])
+
+
+@respx.mock
+def test_async_mcp_methods() -> None:
+    respx.get(f"{API_BASE}/mcp/servers").mock(return_value=httpx.Response(200, json={"servers": []}))
+    respx.get(f"{API_BASE}/mcp/servers/gmail").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "server": {"server_id": "gmail", "type": "gumcp", "status": "ok", "gumloop_auth_url": "u"},
+            },
+        )
+    )
+    respx.get(f"{API_BASE}/mcp/servers/gmail/tools").mock(
+        return_value=httpx.Response(200, json={"tools": [], "server_id": "gmail", "status": "connected"})
+    )
+    respx.post(f"{API_BASE}/mcp/tools/call").mock(return_value=httpx.Response(200, json={"results": []}))
+
+    async def run() -> None:
+        async with AsyncGumloop(access_token="token") as client:
+            assert (await client.mcp.list_servers(team_id="team_123")).servers == []
+            assert (await client.mcp.get_server("gmail", team_id="team_123")).server.server_id == "gmail"
+            tools_resp = await client.mcp.list_tools("gmail", team_id="team_123")
+            assert tools_resp.tools == []
+            assert tools_resp.server_id == "gmail"
+            single = await client.mcp.execute(
+                "gmail",
+                "read_emails",
+                {"max_results": 5},
+                team_id="team_123",
+            )
+            assert single.results == []
+            batch = await client.mcp.execute_many(
+                [{"server_id": "gmail", "tool_name": "read_emails", "arguments": {}}],
+                team_id="team_123",
+            )
+            assert batch.results == []
+
+    asyncio.run(run())
+
+
+@respx.mock
+def test_mcp_list_and_read_resources(client: Gumloop) -> None:
+    list_route = respx.get(f"{API_BASE}/mcp/servers/gmail/resources").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "resources": [
+                    {
+                        "uri": "gmail://label/INBOX",
+                        "name": "Inbox",
+                        "description": "Primary",
+                        "mime_type": "application/json",
+                        "server_id": "gmail",
+                    }
+                ],
+                "server_id": "gmail",
+                "status": "connected",
+                "next_cursor": "c2",
+            },
+        )
+    )
+    read_route = respx.get(f"{API_BASE}/mcp/servers/gmail/resources/read").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "server_id": "gmail",
+                "uri": "gmail://label/INBOX",
+                "contents": [{"mime_type": "text/plain", "text": "a"}, {"text": "b"}],
+            },
+        )
+    )
+
+    listed = client.mcp.list_resources("gmail", cursor="c1", team_id="team_123")
+    assert listed.resources[0].uri == "gmail://label/INBOX"
+    assert listed.resources[0].mime_type == "application/json"
+    assert listed.next_cursor == "c2"
+    assert list_route.calls[0].request.url.params["cursor"] == "c1"
+    assert list_route.calls[0].request.url.params["team_id"] == "team_123"
+
+    read = client.mcp.get_resource("gmail", "gmail://label/INBOX", team_id="team_123")
+    assert read.text == "a\nb"  # the .text convenience joins text contents
+    assert read_route.calls[0].request.url.params["uri"] == "gmail://label/INBOX"
+
+
+@respx.mock
+def test_mcp_list_and_get_prompts(client: Gumloop) -> None:
+    list_route = respx.get(f"{API_BASE}/mcp/servers/gmail/prompts").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "prompts": [
+                    {
+                        "name": "summarize",
+                        "description": "d",
+                        "arguments": [{"name": "thread_id", "required": True}],
+                        "server_id": "gmail",
+                    }
+                ],
+                "server_id": "gmail",
+                "status": "connected",
+            },
+        )
+    )
+    get_route = respx.post(f"{API_BASE}/mcp/servers/gmail/prompts/get").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "server_id": "gmail",
+                "name": "summarize",
+                "description": "d",
+                "messages": [{"role": "user", "content": {"type": "text", "text": "hello"}}],
+            },
+        )
+    )
+
+    listed = client.mcp.list_prompts("gmail", team_id="team_123")
+    assert listed.prompts[0].name == "summarize"
+    assert listed.prompts[0].arguments[0].required is True
+    assert list_route.calls[0].request.url.params["team_id"] == "team_123"
+
+    got = client.mcp.get_prompt("gmail", "summarize", {"thread_id": "abc"}, team_id="team_123")
+    assert got.messages[0].content["text"] == "hello"
+    assert request_json(get_route.calls[0].request) == {
+        "name": "summarize",
+        "arguments": {"thread_id": "abc"},
+        "team_id": "team_123",
+    }
+
+
+@respx.mock
+def test_mcp_get_prompt_omits_team_id_when_absent(client: Gumloop) -> None:
+    route = respx.post(f"{API_BASE}/mcp/servers/gmail/prompts/get").mock(
+        return_value=httpx.Response(200, json={"server_id": "gmail", "name": "summarize", "messages": []})
+    )
+
+    client.mcp.get_prompt("gmail", "summarize")
+
+    assert request_json(route.calls[0].request) == {"name": "summarize", "arguments": {}}
+
+
+@respx.mock
+def test_async_mcp_resource_and_prompt_methods() -> None:
+    respx.get(f"{API_BASE}/mcp/servers/gmail/resources").mock(
+        return_value=httpx.Response(200, json={"resources": [], "server_id": "gmail", "status": "connected"})
+    )
+    respx.get(f"{API_BASE}/mcp/servers/gmail/resources/read").mock(
+        return_value=httpx.Response(200, json={"server_id": "gmail", "uri": "u", "contents": [{"text": "x"}]})
+    )
+    respx.get(f"{API_BASE}/mcp/servers/gmail/prompts").mock(
+        return_value=httpx.Response(200, json={"prompts": [], "server_id": "gmail", "status": "connected"})
+    )
+    respx.post(f"{API_BASE}/mcp/servers/gmail/prompts/get").mock(
+        return_value=httpx.Response(200, json={"server_id": "gmail", "name": "p", "messages": []})
+    )
+
+    async def run() -> None:
+        async with AsyncGumloop(access_token="token") as client:
+            assert (await client.mcp.list_resources("gmail", team_id="t")).resources == []
+            assert (await client.mcp.get_resource("gmail", "u", team_id="t")).text == "x"
+            assert (await client.mcp.list_prompts("gmail", team_id="t")).prompts == []
+            assert (await client.mcp.get_prompt("gmail", "p", {"a": 1}, team_id="t")).name == "p"
+
+    asyncio.run(run())

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

@@ -355,7 +355,7 @@ wheels = [
 
 [[package]]
 name = "gumloop"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

gumloop-0.3.0/tests/sdk/test_mcp.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-
-import httpx
-import pytest
-import respx
-
-from gumloop import AsyncGumloop
-from gumloop import Gumloop
-from tests.sdk.helpers import API_BASE
-from tests.sdk.helpers import request_json
-
-
-@respx.mock
-def test_mcp_list_servers_and_get_server_routes(client: Gumloop) -> None:
-    list_route = respx.get(f"{API_BASE}/mcp/servers").mock(return_value=httpx.Response(200, json={"servers": []}))
-    get_route = respx.get(f"{API_BASE}/mcp/servers/gmail").mock(
-        return_value=httpx.Response(
-            200,
-            json={
-                "server": {"server_id": "gmail", "type": "gumcp", "status": "ok", "gumloop_auth_url": "u"},
-            },
-        )
-    )
-
-    assert client.mcp.list_servers(team_id="team_123").servers == []
-    assert client.mcp.get_server("gmail", team_id="team_123").server.server_id == "gmail"
-    assert list_route.calls[0].request.url.params["team_id"] == "team_123"
-    assert get_route.calls[0].request.url.params["team_id"] == "team_123"
-
-
-@respx.mock
-def test_mcp_list_tools_uses_server_path(client: Gumloop) -> None:
-    route = respx.get(f"{API_BASE}/mcp/servers/gmail/tools").mock(
-        return_value=httpx.Response(200, json={"tools": [], "server_id": "gmail", "status": "connected"})
-    )
-
-    result = client.mcp.list_tools("gmail", team_id="team_123")
-
-    assert result.tools == []
-    assert result.server_id == "gmail"
-    assert result.status == "connected"
-    params = route.calls[0].request.url.params
-    assert params["team_id"] == "team_123"
-
-
-@respx.mock
-def test_mcp_execute_single_and_many_bodies(client: Gumloop) -> None:
-    route = respx.post(f"{API_BASE}/mcp/tools/call").mock(return_value=httpx.Response(200, json={"results": []}))
-
-    assert (
-        client.mcp.execute(
-            "gmail",
-            "read_emails",
-            {"max_results": 5},
-            team_id="team_123",
-        ).results
-        == []
-    )
-    assert request_json(route.calls[0].request) == {
-        "calls": [{"server_id": "gmail", "tool_name": "read_emails", "arguments": {"max_results": 5}}],
-        "team_id": "team_123",
-    }
-
-    calls = [
-        {
-            "ref": "emails",
-            "server_id": "gmail",
-            "tool_name": "read_emails",
-            "arguments": {"max_results": 5},
-        }
-    ]
-    assert client.mcp.execute_many(calls, team_id="team_123").results == []
-    assert request_json(route.calls[1].request) == {
-        "team_id": "team_123",
-        "calls": [
-            {
-                "ref": "emails",
-                "server_id": "gmail",
-                "tool_name": "read_emails",
-                "arguments": {"max_results": 5},
-            }
-        ],
-    }
-
-
-@respx.mock
-def test_mcp_execute_with_ref(client: Gumloop) -> None:
-    route = respx.post(f"{API_BASE}/mcp/tools/call").mock(return_value=httpx.Response(200, json={"results": []}))
-
-    client.mcp.execute("gmail", "read_emails", ref="my_ref")
-
-    call_body = request_json(route.calls[0].request)
-    assert call_body["calls"][0]["ref"] == "my_ref"
-
-
-def test_mcp_execute_many_rejects_empty_calls(client: Gumloop) -> None:
-    with pytest.raises(ValueError, match="empty"):
-        client.mcp.execute_many([])
-
-
-@respx.mock
-def test_async_mcp_methods() -> None:
-    respx.get(f"{API_BASE}/mcp/servers").mock(return_value=httpx.Response(200, json={"servers": []}))
-    respx.get(f"{API_BASE}/mcp/servers/gmail").mock(
-        return_value=httpx.Response(
-            200,
-            json={
-                "server": {"server_id": "gmail", "type": "gumcp", "status": "ok", "gumloop_auth_url": "u"},
-            },
-        )
-    )
-    respx.get(f"{API_BASE}/mcp/servers/gmail/tools").mock(
-        return_value=httpx.Response(200, json={"tools": [], "server_id": "gmail", "status": "connected"})
-    )
-    respx.post(f"{API_BASE}/mcp/tools/call").mock(return_value=httpx.Response(200, json={"results": []}))
-
-    async def run() -> None:
-        async with AsyncGumloop(access_token="token") as client:
-            assert (await client.mcp.list_servers(team_id="team_123")).servers == []
-            assert (await client.mcp.get_server("gmail", team_id="team_123")).server.server_id == "gmail"
-            tools_resp = await client.mcp.list_tools("gmail", team_id="team_123")
-            assert tools_resp.tools == []
-            assert tools_resp.server_id == "gmail"
-            single = await client.mcp.execute(
-                "gmail",
-                "read_emails",
-                {"max_results": 5},
-                team_id="team_123",
-            )
-            assert single.results == []
-            batch = await client.mcp.execute_many(
-                [{"server_id": "gmail", "tool_name": "read_emails", "arguments": {}}],
-                team_id="team_123",
-            )
-            assert batch.results == []
-
-    asyncio.run(run())