gumloop 0.5.4__tar.gz → 0.5.6__tar.gz

{gumloop-0.5.4 → gumloop-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gumloop
-Version: 0.5.4
+Version: 0.5.6
 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.5.4 → gumloop-0.5.6}/src/gumloop/_gumcp_transport.py

@@ -149,6 +149,7 @@ def _error_result(
 def _map_exception(exc: BaseException, *, ref: str, server_id: str, tool_name: str) -> McpToolCallResult:
     message = str(exc)
     lower = message.lower()
+    exc_name = type(exc).__name__
 
     if "credentials_not_found" in message or "authentication required" in lower:
         return _error_result(
@@ -163,6 +164,18 @@ def _map_exception(exc: BaseException, *, ref: str, server_id: str, tool_name: s
             details={"server_id": server_id, "tool_name": tool_name},
         )
 
+    if exc_name == "ToolResultError":
+        return _error_result(
+            ref=ref,
+            server_id=server_id,
+            tool_name=tool_name,
+            status="error",
+            code="mcp_tool_error",
+            message=message,
+            error_type="api_error",
+            details={"server_id": server_id, "tool_name": tool_name},
+        )
+
     if (
         "not permitted" in lower
         or "not allowed" in lower
@@ -215,7 +228,6 @@ def _map_exception(exc: BaseException, *, ref: str, server_id: str, tool_name: s
         )
 
     # Connection-class failures from gumcp_client.
-    exc_name = type(exc).__name__
     if exc_name in {"ConnectionError", "SessionError"} or "failed to connect" in lower:
         return _error_result(
             ref=ref,

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/_http.py

@@ -228,8 +228,11 @@ class HttpClient:
         *,
         json: Any = None,
         params: Mapping[str, Any] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
     ) -> Iterator[StreamEvent]:
         headers = {**auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
+        if extra_headers:
+            headers.update(extra_headers)
         with self._client.stream(
             method,
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -355,8 +358,16 @@ class AsyncHttpClient:
         json: Any = None,
         data: Mapping[str, Any] | None = None,
         files: list[tuple[str, Any]] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
     ) -> Any:
-        return await self._request("POST", path, json=json, data=_omit_none_params(data), files=files)
+        return await self._request(
+            "POST",
+            path,
+            json=json,
+            data=_omit_none_params(data),
+            files=files,
+            extra_headers=extra_headers,
+        )
 
     async def patch(
         self,
@@ -394,8 +405,11 @@ class AsyncHttpClient:
         *,
         json: Any = None,
         params: Mapping[str, Any] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
     ) -> AsyncIterator[StreamEvent]:
         headers = {**auth_headers(self.access_token, self.user_id), "Accept": "text/event-stream"}
+        if extra_headers:
+            headers.update(extra_headers)
         async with self._client.stream(
             method,
             f"{self._stream_base_url}/{path.lstrip('/')}",
@@ -444,10 +458,19 @@ class AsyncHttpClient:
                     logger.debug("dropped non-%s SSE: %s", response_model.__name__, event.data)
                     continue
 
-    async def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        extra_headers: Mapping[str, str] | None = None,
+        **kwargs: Any,
+    ) -> Any:
         headers = auth_headers(self.access_token, self.user_id)
         if not kwargs.get("files"):
             headers["Content-Type"] = "application/json"
+        if extra_headers:
+            headers.update(extra_headers)
         kwargs["params"] = self._scoped_params(kwargs.get("params"))
         response = await self._client.request(method, path, headers=headers, **kwargs)
         if response.status_code >= 400:

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.5.4"
+__version__ = "0.5.6"

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/cli/commands/agents.py

@@ -106,6 +106,8 @@ def get_agent(
         value = getattr(agent, field, None)
         if value not in (None, ""):
             console.print(f"  {field}: {value}", markup=False, highlight=False)
+    if agent.incognito.enforced:
+        console.print("  incognito: on (nothing is saved)", markup=False, highlight=False)
     if agent.system_prompt:
         console.print("  system_prompt:", markup=False, highlight=False)
         console.print(f"    {agent.system_prompt}", markup=False, highlight=False)
@@ -253,6 +255,13 @@ def create_agent(
         str | None,
         typer.Option("--skill-ids", help="Comma-separated ids of existing skills to attach."),
     ] = None,
+    incognito: Annotated[
+        bool,
+        typer.Option(
+            "--incognito",
+            help="Every session on the agent runs incognito (nothing is saved). Needs a role that allows it.",
+        ),
+    ] = False,
     json_output: Annotated[
         bool,
         typer.Option("--json", help="Print the raw SDK response as JSON."),
@@ -310,6 +319,7 @@ def create_agent(
                 tools=tools,
                 skill_ids=parsed_skill_ids,
                 team_id=cli.effective_team_id,
+                incognito=True if incognito else None,
             )
         )
     except GumloopError as error:
@@ -323,6 +333,8 @@ def create_agent(
     console.print(f"[green]Created agent[/green] {escape_markup(agent.id)}")
     if agent.name:
         console.print(f"  Name: {agent.name}", markup=False, highlight=False)
+    if agent.incognito.enforced:
+        console.print("  Incognito: on (nothing is saved)", markup=False, highlight=False)
 
 
 @agents_app.command(
@@ -371,6 +383,13 @@ def update_agent(
         bool | None,
         typer.Option("--is-active/--inactive", help="Mark the agent as active or inactive."),
     ] = None,
+    incognito: Annotated[
+        bool | None,
+        typer.Option(
+            "--incognito/--no-incognito",
+            help="Run every session on the agent incognito (nothing is saved), or stop. Needs a role that allows it.",
+        ),
+    ] = None,
     json_output: Annotated[
         bool,
         typer.Option("--json", help="Print the raw SDK response as JSON."),
@@ -411,18 +430,21 @@ def update_agent(
                     raise GumloopError("Tools JSON must be an array at the top level.")
                 tools = parsed
 
-        response = cli.call_with_refresh(
-            lambda client: client.agents.update(
-                agent_id,
-                name=name,
-                model_name=model,
-                description=description,
-                system_prompt=resolved_prompt,
-                tools=tools,
-                is_active=is_active,
-                team_id=cli.effective_team_id,
+        fields = {
+            "name": name,
+            "model_name": model,
+            "description": description,
+            "system_prompt": resolved_prompt,
+            "tools": tools,
+            "is_active": is_active,
+        }
+        response = None
+        if incognito is not None:
+            response = cli.call_with_refresh(lambda client: client.agents.set_incognito(agent_id, incognito))
+        if incognito is None or any(value is not None for value in fields.values()):
+            response = cli.call_with_refresh(
+                lambda client: client.agents.update(agent_id, team_id=cli.effective_team_id, **fields)
             )
-        )
     except GumloopError as error:
         exit_with_error(error, json_output=json_output)
 
@@ -431,6 +453,8 @@ def update_agent(
         return
 
     console.print(f"[green]Updated agent[/green] {agent_id}")
+    if incognito is not None:
+        console.print(f"  Incognito: {'on (nothing is saved)' if incognito else 'off'}", markup=False, highlight=False)
 
 
 @agents_app.command(

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/cli/commands/mcp.py

@@ -76,6 +76,26 @@ def get_server(
             console.print(f"  {field}: {value}", markup=False, highlight=False)
 
 
+@mcp_app.command("accounts")
+def list_accounts(
+    ctx: typer.Context,
+    server: Annotated[str, typer.Argument(help="MCP server id.")],
+    json_output: Annotated[bool, typer.Option("--json", help="Print the raw response as JSON.")] = False,
+) -> None:
+    """List connected accounts available for a tool call."""
+    cli: CliContext = ctx.obj
+    try:
+        response = cli.call_with_refresh(lambda client: client.mcp.list_accounts(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
+    console.print("ACCOUNT_ID", "LABEL", "DEFAULT", "IN_USE", sep="\t", soft_wrap=True)
+    for account in response.accounts:
+        console.print(account.id, account.label, str(account.is_default), str(account.in_use), sep="\t", markup=False)
+
+
 @mcp_app.command("tools", epilog="Example:\n  gumloop mcp tools gmail")
 def list_tools(
     ctx: typer.Context,
@@ -134,6 +154,7 @@ def call_tool(
         str | None,
         typer.Option("--args", help="Use '-' to read JSON arguments from stdin.", metavar="-"),
     ] = None,
+    account: Annotated[str | None, typer.Option("--account", help="Connected account id to use.")] = None,
     ref: Annotated[
         str | None,
         typer.Option("--ref", help="Optional ref string echoed back in the response."),
@@ -153,6 +174,7 @@ def call_tool(
                 tool,
                 arguments,
                 ref=ref,
+                account=account,
                 team_id=cli.effective_team_id,
             )
         )

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/cli/commands/sessions.py

@@ -47,6 +47,10 @@ def create_session(
         str | None,
         typer.Option("--name", help="Session name shown in the sidebar (1-256 characters)."),
     ] = None,
+    incognito: Annotated[
+        bool,
+        typer.Option("--incognito", help="Run the session incognito: nothing is saved."),
+    ] = False,
     json_output: Annotated[
         bool,
         typer.Option("--json", help="Print the raw SDK response as JSON."),
@@ -75,6 +79,7 @@ def create_session(
                     input=message,
                     session_id=session_id,
                     name=name,
+                    incognito=True if incognito else None,
                 )
             ),
         )
@@ -94,6 +99,8 @@ def create_session(
         value = getattr(session, field, None)
         if value not in (None, ""):
             console.print(f"  {field}: {value}", markup=False, highlight=False)
+    if session.incognito:
+        console.print("  incognito: on (nothing is saved)", markup=False, highlight=False)
     if session.messages:
         console.print(f"  messages: {len(session.messages)}")
         for m in session.messages[-5:]:
@@ -220,6 +227,8 @@ def get_session(
         value = getattr(session, field, None)
         if value not in (None, ""):
             console.print(f"  {field}: {value}", markup=False, highlight=False)
+    if session.incognito:
+        console.print("  incognito: on (nothing is saved)", markup=False, highlight=False)
     if session.messages:
         console.print(f"  messages: {len(session.messages)}")
         for m in session.messages[-5:]:
@@ -284,6 +293,8 @@ def send_session(
         value = getattr(session, field, None)
         if value not in (None, ""):
             console.print(f"  {field}: {value}", markup=False, highlight=False)
+    if session.incognito:
+        console.print("  incognito: on (nothing is saved)", markup=False, highlight=False)
     if session.messages:
         console.print(f"  messages: {len(session.messages)}")
         for m in session.messages[-5:]:

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/cli/plugin_assets/gumloop/skills/gumloop-cli/SKILL.md

@@ -102,3 +102,8 @@ Structured output: `--schema-file schema.json`. Stdin input: `--message-stdin -`
 - `sessions create`/`send` return the final response only; there is no token streaming in the CLI (the Python SDK's `client.sessions.stream()` has it).
 - Company Brain requires the Pro plan and consumes credits per search.
 - On headless Linux without a keychain, `gumloop login` refuses to run; use the environment variables above.
+
+
+## Connected account selection
+
+Use `gumloop mcp accounts <server> --json` to list available account IDs, then `gumloop mcp call <server> <tool> --account <id> --args-json '{...}'` to select one. IDs are stable credential IDs; labels are display-only. Account choice requires backend authorization and, for sandbox tokens, an account grant for that tool. Python supports `client.mcp.list_accounts(server_id)` and `client.mcp.execute(server_id, tool_name, arguments, account="id")`, including async clients and per-item `account` in `execute_many`. Account-selected calls use the backend HTTP API and require `GUMLOOP_ACCESS_TOKEN`; calls without an account retain direct guMCP transport when configured. Computer code must pass account IDs as literal strings so approval can bind them.

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/cli/plugin_assets/gumloop/skills/gumloop-cli/references/commands.md

@@ -31,11 +31,11 @@ gumloop agents versions <agent_id> [--limit n] [--cursor c] [--json]
 gumloop agents export <agent_id> <version_id> [-o file.json]
 gumloop agents create --name NAME --model MODEL [--description d]
     [--system-prompt s | --system-prompt-file f]
-    [--tools-json '[...]' | --tools-file f] [--json]
-gumloop agents update <agent_id> [same flags as create] [--is-active | --inactive]
+    [--tools-json '[...]' | --tools-file f] [--incognito] [--json]
+gumloop agents update <agent_id> [same flags as create] [--is-active | --inactive] [--incognito | --no-incognito]
 ```
 
-`--model` accepts `auto` or a slug like `anthropic/claude-sonnet-4`. To learn the tool-config shape, run `gumloop agents get <id> --json` on an existing agent and copy its `tools` array. `--inactive` retires the agent irreversibly.
+`--model` accepts `auto` or a slug like `anthropic/claude-sonnet-4`. To learn the tool-config shape, run `gumloop agents get <id> --json` on an existing agent and copy its `tools` array. `--inactive` retires the agent irreversibly. `--incognito` makes every session on the agent incognito (nothing is saved); it needs the Incognito agents role permission (separate from Incognito tasks), and on `create` a refusal leaves no agent behind.
 
 ## Models
 
@@ -51,7 +51,7 @@ cat task.txt | gumloop models route --input-stdin - --model gpt-5.6-luna --model
 ## Sessions
 
 ```bash
-gumloop sessions create <agent_id> [--input text | --input-stdin -] [--session-id id] [--name name] [--json]
+gumloop sessions create <agent_id> [--input text | --input-stdin -] [--session-id id] [--name name] [--incognito] [--json]
 gumloop sessions list <agent_id> [--search text] [--state s] [--type t] [--sort order] [--limit n] [--json]
 gumloop sessions get <session_id> [--json]          # --json returns the full transcript
 gumloop sessions send <session_id> [--input text | --input-stdin -] [--json]
@@ -127,3 +127,8 @@ gumloop sync --once --non-interactive # one-shot sync; requires GUMLOOP_API_KEY
 gumloop update                        # update the CLI in place
 gumloop plugin install gumloop        # install this skill into detected agent skill directories
 ```
+
+
+## Connected account selection
+
+Use `gumloop mcp accounts <server> --json` to list available account IDs, then `gumloop mcp call <server> <tool> --account <id> --args-json '{...}'` to select one. IDs are stable credential IDs; labels are display-only. Account choice requires backend authorization and, for sandbox tokens, an account grant for that tool. Python supports `client.mcp.list_accounts(server_id)` and `client.mcp.execute(server_id, tool_name, arguments, account="id")`, including async clients and per-item `account` in `execute_many`. Account-selected calls use the backend HTTP API and require `GUMLOOP_ACCESS_TOKEN`; calls without an account retain direct guMCP transport when configured. Computer code must pass account IDs as literal strings so approval can bind them.

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/resources/agents.py

@@ -184,6 +184,13 @@ class Agents:
             )
         )
 
+    def set_incognito(self, agent_id: str, enforced: bool) -> AgentResponse:
+        """Make every session on the agent incognito (nothing is saved), or stop doing so.
+        Needs the Incognito agents role permission (``organization_permission_required`` otherwise)."""
+        return AgentResponse.model_validate(
+            self._client.patch(f"agents/{agent_id}/incognito", json={"enforced": enforced})
+        )
+
     def list_knowledge_sources(self, agent_id: str) -> AgentKnowledgeSourcesResponse:
         return AgentKnowledgeSourcesResponse.model_validate(self._client.get(f"agents/{agent_id}/knowledge-sources"))
 
@@ -480,6 +487,12 @@ class AsyncAgents:
         )
         return AgentAbilitiesResponse.model_validate(data)
 
+    async def set_incognito(self, agent_id: str, enforced: bool) -> AgentResponse:
+        """Make every session on the agent incognito (nothing is saved), or stop doing so.
+        Needs the Incognito agents role permission (``organization_permission_required`` otherwise)."""
+        data = await self._client.patch(f"agents/{agent_id}/incognito", json={"enforced": enforced})
+        return AgentResponse.model_validate(data)
+
     async def list_knowledge_sources(self, agent_id: str) -> AgentKnowledgeSourcesResponse:
         data = await self._client.get(f"agents/{agent_id}/knowledge-sources")
         return AgentKnowledgeSourcesResponse.model_validate(data)

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/resources/mcp.py

@@ -7,11 +7,13 @@ from gumloop._gumcp_transport import GumcpTransport
 from gumloop._gumcp_transport import gumcp_env_ready
 from gumloop._http import AsyncHttpClient
 from gumloop._http import HttpClient
+from gumloop.errors import GumloopError
 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 McpServerAccountsResponse
 from gumloop.types import McpServerResponse
 from gumloop.types import McpServersResponse
 from gumloop.types import McpToolCallRequest
@@ -19,10 +21,10 @@ from gumloop.types import McpToolsResponse
 
 
 def _call_body(calls: Sequence[McpToolCallRequest | dict[str, Any]], team_id: str | None) -> dict[str, Any]:
-    # Backend enforces 1–5 calls; the lower bound is checked client-side so
-    # an empty list fails without a network round-trip.
     if not calls:
         raise ValueError("calls cannot be empty")
+    if len(calls) > 5:
+        raise ValueError("calls cannot exceed 5 items per request.")
     body: dict[str, Any] = {
         "calls": [c.model_dump(exclude_none=True) if isinstance(c, McpToolCallRequest) else dict(c) for c in calls],
     }
@@ -56,6 +58,10 @@ class MCP:
             self._client.get(f"mcp/servers/{server_id}", params={"team_id": team_id, **kwargs})
         )
 
+    def list_accounts(self, server_id: str, *, team_id: str | None = None) -> McpServerAccountsResponse:
+        data = self._client.get(f"mcp/servers/{server_id}/accounts", params={"team_id": team_id})
+        return McpServerAccountsResponse.model_validate(data)
+
     def list_tools(self, server_id: str, *, team_id: str | None = None, **kwargs: Any) -> McpToolsResponse:
         return McpToolsResponse.model_validate(
             self._client.get(f"mcp/servers/{server_id}/tools", params={"team_id": team_id, **kwargs})
@@ -108,20 +114,17 @@ class MCP:
         arguments: dict[str, Any] | None = None,
         *,
         ref: str | None = None,
+        account: str | None = None,
         team_id: str | None = None,
     ) -> McpExecuteResponse:
-        # Direct transport: team_id comes from the token.
-        transport = self._direct_transport()
-        if transport is not None:
-            return transport.execute(server_id, tool_name, arguments, ref=ref)
-        team_id = team_id if team_id is not None else self._client.team_id
         call = McpToolCallRequest(
             server_id=server_id,
             tool_name=tool_name,
             arguments=arguments or {},
             ref=ref,
+            account=account,
         )
-        return McpExecuteResponse.model_validate(self._client.post("mcp/tools/call", json=_call_body([call], team_id)))
+        return self.execute_many([call], team_id=team_id)
 
     def execute_many(
         self,
@@ -129,9 +132,30 @@ class MCP:
         *,
         team_id: str | None = None,
     ) -> McpExecuteResponse:
-        transport = self._direct_transport()
+        normalized = _call_body(calls, team_id)["calls"]
+        has_account = any(call.get("account") is not None for call in normalized)
+        if has_account and not self._client.access_token:
+            raise GumloopError("Account selection requires GUMLOOP_ACCESS_TOKEN for the backend HTTP API.")
+        transport = self._direct_transport() if any(call.get("account") is None for call in normalized) else None
         if transport is not None:
-            return transport.execute_many(calls)
+            for index, call in enumerate(normalized):
+                call["ref"] = call.get("ref") or str(index)
+            pinned = [(index, call) for index, call in enumerate(normalized) if call.get("account") is not None]
+            if not pinned:
+                return transport.execute_many(calls)
+            direct = [(index, call) for index, call in enumerate(normalized) if call.get("account") is None]
+            team_id = team_id if team_id is not None else self._client.team_id
+            data = self._client.post("mcp/tools/call", json=_call_body([call for _, call in pinned], team_id))
+            response = McpExecuteResponse.model_validate(data)
+            if len(response.results) != len(pinned):
+                raise GumloopError("Backend returned an unexpected number of account call results.")
+            indexed_results = list(zip((index for index, _ in pinned), response.results, strict=True))
+            if direct:
+                direct_response = transport.execute_many([call for _, call in direct])
+                if len(direct_response.results) != len(direct):
+                    raise GumloopError("guMCP returned an unexpected number of tool call results.")
+                indexed_results.extend(zip((index for index, _ in direct), direct_response.results, strict=True))
+            return McpExecuteResponse(results=[result for _, result in sorted(indexed_results)])
         team_id = team_id if team_id is not None else self._client.team_id
         return McpExecuteResponse.model_validate(self._client.post("mcp/tools/call", json=_call_body(calls, team_id)))
 
@@ -161,6 +185,10 @@ class AsyncMCP:
         data = await self._client.get(f"mcp/servers/{server_id}", params={"team_id": team_id, **kwargs})
         return McpServerResponse.model_validate(data)
 
+    async def list_accounts(self, server_id: str, *, team_id: str | None = None) -> McpServerAccountsResponse:
+        data = await self._client.get(f"mcp/servers/{server_id}/accounts", params={"team_id": team_id})
+        return McpServerAccountsResponse.model_validate(data)
+
     async def list_tools(self, server_id: str, *, team_id: str | None = None, **kwargs: Any) -> McpToolsResponse:
         data = await self._client.get(f"mcp/servers/{server_id}/tools", params={"team_id": team_id, **kwargs})
         return McpToolsResponse.model_validate(data)
@@ -210,21 +238,17 @@ class AsyncMCP:
         arguments: dict[str, Any] | None = None,
         *,
         ref: str | None = None,
+        account: str | None = None,
         team_id: str | None = None,
     ) -> McpExecuteResponse:
-        # Direct transport: team_id comes from the token.
-        transport = self._direct_transport()
-        if transport is not None:
-            return await transport.execute_async(server_id, tool_name, arguments, ref=ref)
-        team_id = team_id if team_id is not None else self._client.team_id
         call = McpToolCallRequest(
             server_id=server_id,
             tool_name=tool_name,
             arguments=arguments or {},
             ref=ref,
+            account=account,
         )
-        data = await self._client.post("mcp/tools/call", json=_call_body([call], team_id))
-        return McpExecuteResponse.model_validate(data)
+        return await self.execute_many([call], team_id=team_id)
 
     async def execute_many(
         self,
@@ -232,9 +256,30 @@ class AsyncMCP:
         *,
         team_id: str | None = None,
     ) -> McpExecuteResponse:
-        transport = self._direct_transport()
+        normalized = _call_body(calls, team_id)["calls"]
+        has_account = any(call.get("account") is not None for call in normalized)
+        if has_account and not self._client.access_token:
+            raise GumloopError("Account selection requires GUMLOOP_ACCESS_TOKEN for the backend HTTP API.")
+        transport = self._direct_transport() if any(call.get("account") is None for call in normalized) else None
         if transport is not None:
-            return await transport.execute_many_async(calls)
+            for index, call in enumerate(normalized):
+                call["ref"] = call.get("ref") or str(index)
+            pinned = [(index, call) for index, call in enumerate(normalized) if call.get("account") is not None]
+            if not pinned:
+                return await transport.execute_many_async(calls)
+            direct = [(index, call) for index, call in enumerate(normalized) if call.get("account") is None]
+            team_id = team_id if team_id is not None else self._client.team_id
+            data = await self._client.post("mcp/tools/call", json=_call_body([call for _, call in pinned], team_id))
+            response = McpExecuteResponse.model_validate(data)
+            if len(response.results) != len(pinned):
+                raise GumloopError("Backend returned an unexpected number of account call results.")
+            indexed_results = list(zip((index for index, _ in pinned), response.results, strict=True))
+            if direct:
+                direct_response = await transport.execute_many_async([call for _, call in direct])
+                if len(direct_response.results) != len(direct):
+                    raise GumloopError("guMCP returned an unexpected number of tool call results.")
+                indexed_results.extend(zip((index for index, _ in direct), direct_response.results, strict=True))
+            return McpExecuteResponse(results=[result for _, result in sorted(indexed_results)])
         team_id = team_id if team_id is not None else self._client.team_id
         data = await self._client.post("mcp/tools/call", json=_call_body(calls, team_id))
         return McpExecuteResponse.model_validate(data)

{gumloop-0.5.4 → gumloop-0.5.6}/src/gumloop/resources/sessions.py

@@ -59,6 +59,7 @@ class Sessions:
         request: SessionCreateRequest | Mapping[str, Any] | None = None,
         *,
         stream: Literal[True],
+        extra_headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> Iterator[StreamEvent]: ...
     @overload
@@ -68,18 +69,23 @@ class Sessions:
         request: SessionCreateRequest | Mapping[str, Any] | None = None,
         *,
         stream: Literal[False] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> SessionResponse: ...
     def create(
         self,
         agent_id: str,
         request: SessionCreateRequest | Mapping[str, Any] | None = None,
+        *,
+        extra_headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> SessionResponse | Iterator[StreamEvent]:
         body = SessionCreateRequest.build(request, **kwargs)
         if body.get("stream") is True:
-            return self._client.stream("POST", f"agents/{agent_id}/sessions", json=body)
-        return SessionResponse.model_validate(self._client.post(f"agents/{agent_id}/sessions", json=body))
+            return self._client.stream("POST", f"agents/{agent_id}/sessions", json=body, extra_headers=extra_headers)
+        return SessionResponse.model_validate(
+            self._client.post(f"agents/{agent_id}/sessions", json=body, extra_headers=extra_headers)
+        )
 
     def stream(
         self,
@@ -197,6 +203,7 @@ class AsyncSessions:
         request: SessionCreateRequest | Mapping[str, Any] | None = None,
         *,
         stream: Literal[True],
+        extra_headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[StreamEvent]: ...
     @overload
@@ -206,18 +213,21 @@ class AsyncSessions:
         request: SessionCreateRequest | Mapping[str, Any] | None = None,
         *,
         stream: Literal[False] | None = None,
+        extra_headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> SessionResponse: ...
     async def create(
         self,
         agent_id: str,
         request: SessionCreateRequest | Mapping[str, Any] | None = None,
+        *,
+        extra_headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> SessionResponse | AsyncIterator[StreamEvent]:
         body = SessionCreateRequest.build(request, **kwargs)
         if body.get("stream") is True:
-            return self._client.stream("POST", f"agents/{agent_id}/sessions", json=body)
-        data = await self._client.post(f"agents/{agent_id}/sessions", json=body)
+            return self._client.stream("POST", f"agents/{agent_id}/sessions", json=body, extra_headers=extra_headers)
+        data = await self._client.post(f"agents/{agent_id}/sessions", json=body, extra_headers=extra_headers)
         return SessionResponse.model_validate(data)
 
     def stream(