gumloop 0.3.0__tar.gz → 0.3.2__tar.gz

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

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

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

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

{gumloop-0.3.0 → gumloop-0.3.2}/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.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.0 → gumloop-0.3.2}/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.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.0 → gumloop-0.3.2}/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,