unique-sdk 2026.44.0.dev1__tar.gz → 2026.44.0.dev3__tar.gz

{unique_sdk-2026.44.0.dev1 → unique_sdk-2026.44.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-sdk
-Version: 2026.44.0.dev1
+Version: 2026.44.0.dev3
 Summary: 
 Author: Martin Fadler, Konstantin Krauss, Andreas Hauri
 Author-email: Martin Fadler <martin.fadler@unique.ch>, Konstantin Krauss <konstantin@unique.ch>, Andreas Hauri <andreas@unique.ch>

{unique_sdk-2026.44.0.dev1 → unique_sdk-2026.44.0.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.44.0.dev1"
+version = "2026.44.0.dev3"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }

{unique_sdk-2026.44.0.dev1 → unique_sdk-2026.44.0.dev3}/unique_sdk/api_resources/_mcp.py

@@ -46,6 +46,29 @@ class CallToolContentDto(TypedDict):
     ]  # For type: "resource"
 
 
+class McpServerToolDto(TypedDict):
+    """A tool of an MCP server that the company has enabled."""
+
+    name: str
+    description: str | None
+
+
+class McpServerDto(TypedDict):
+    """An MCP server (connector) of the company that can be attached to a space."""
+
+    id: str
+    name: str
+    description: str | None
+    requiresOAuth: bool
+    isSpaceRestricted: bool
+    allowedSpaceIds: list[str]
+    tools: list[McpServerToolDto]
+
+
+class McpServersResponse(TypedDict):
+    mcpServers: list[McpServerDto]
+
+
 class MCP(APIResource["MCP"]):
     @classproperty
     def OBJECT_NAME(cls) -> Literal["mcp.call_tool"]:
@@ -128,3 +151,57 @@ class MCP(APIResource["MCP"]):
                 params=params,
             ),
         )
+
+    @classmethod
+    def list_servers(
+        cls,
+        user_id: str,
+        company_id: str,
+    ) -> McpServersResponse:
+        """
+        List the company's MCP servers that can be attached to a space, with their
+        tools. Never returns server URLs or credentials.
+
+        Args:
+            user_id: The ID of the user making the request
+            company_id: The ID of the company
+
+        Returns:
+            McpServersResponse: The servers, sorted by name
+        """
+        return cast(
+            McpServersResponse,
+            cls._static_request(
+                "get",
+                "/mcp/servers",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    async def list_servers_async(
+        cls,
+        user_id: str,
+        company_id: str,
+    ) -> McpServersResponse:
+        """
+        Asynchronously list the company's MCP servers that can be attached to a space,
+        with their tools. Never returns server URLs or credentials.
+
+        Args:
+            user_id: The ID of the user making the request
+            company_id: The ID of the company
+
+        Returns:
+            McpServersResponse: The servers, sorted by name
+        """
+        return cast(
+            McpServersResponse,
+            await cls._static_request_async(
+                "get",
+                "/mcp/servers",
+                user_id,
+                company_id,
+            ),
+        )

{unique_sdk-2026.44.0.dev1 → unique_sdk-2026.44.0.dev3}/unique_sdk/api_resources/_space.py

@@ -19,7 +19,11 @@ class Space(APIResource["Space"]):
         return "space"
 
     UiType: TypeAlias = Literal[
-        "MAGIC_TABLE", "UNIQUE_CUSTOM", "TRANSLATION", "UNIQUE_AI"
+        "MAGIC_TABLE",
+        "UNIQUE_CUSTOM",
+        "TRANSLATION",
+        "UNIQUE_AI",
+        "SWAPPABLE_INTELLIGENCE",
     ]
 
     class ModuleParams(TypedDict):
@@ -57,6 +61,24 @@ class Space(APIResource["Space"]):
         isExclusive: bool
         configuration: dict[str, Any]
 
+    class McpServerToolParams(TypedDict):
+        name: str
+        isEnabled: bool
+
+    class McpServerParams(TypedDict):
+        """
+        An MCP server (connector) to attach to a space.
+
+        Only listed servers change. ``tools`` is the complete selection for the server:
+        listed tools take ``isEnabled``, unlisted tools are disabled, and an empty list
+        disables the server for the space. Omit ``tools`` to enable every callable tool.
+        Applied after MCP tool entries in module configurations, so it wins for a server
+        that appears in both. Use ``MCP.list_servers`` for the ids and tool names.
+        """
+
+        mcpServerId: str
+        tools: NotRequired[list["Space.McpServerToolParams"] | None]
+
     class CreateSpaceParams(RequestOptions):
         name: str
         fallbackModule: str
@@ -77,6 +99,7 @@ class Space(APIResource["Space"]):
         isSubAgent: NotRequired[bool | None]
         subAgentSettings: NotRequired["Space.SubAgentSettings | None"]
         subAgentIds: NotRequired[list[str] | None]
+        mcpServers: NotRequired[list["Space.McpServerParams"] | None]
 
     class UpdateParams(RequestOptions):
         name: NotRequired[str | None]
@@ -98,6 +121,7 @@ class Space(APIResource["Space"]):
         isSubAgent: NotRequired[bool | None]
         subAgentSettings: NotRequired["Space.SubAgentSettings | None"]
         subAgentIds: NotRequired[list[str] | None]
+        mcpServers: NotRequired[list["Space.McpServerParams"] | None]
 
     class AccessEntry(TypedDict):
         entityId: str
@@ -261,6 +285,10 @@ class Space(APIResource["Space"]):
         messages: list["Space.Message"]
         totalCount: int
 
+    class McpServerTool(TypedDict):
+        name: str
+        isEnabled: bool
+
     class McpServer(TypedDict):
         """
         Represents an MCP server associated with a space.
@@ -271,9 +299,27 @@ class Space(APIResource["Space"]):
         assistantId: str
         mcpServerId: str
         isEnabled: bool
+        tools: NotRequired[list["Space.McpServerTool"]]
         createdAt: str
         updatedAt: str
 
+    class McpServerStatus(TypedDict):
+        """
+        The calling user's own state for an MCP server enabled on a space.
+        """
+
+        mcpServerId: str
+        name: str
+        isEnabled: bool
+        requiresOAuth: bool
+        isOAuth2Connected: bool
+        oauth2Url: str | None
+        enabledToolNames: list[str]
+
+    class McpServerStatusResponse(TypedDict):
+        spaceId: str
+        mcpServers: list["Space.McpServerStatus"]
+
     class Module(TypedDict):
         """
         Represents a module configured for a space.
@@ -911,3 +957,45 @@ class Space(APIResource["Space"]):
                 params=params,
             ),
         )
+
+    @classmethod
+    def get_mcp_server_status(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+    ) -> "Space.McpServerStatusResponse":
+        """
+        Get the MCP servers enabled on a space with the calling user's own OAuth
+        connection state (``isOAuth2Connected``, ``oauth2Url``).
+        """
+        return cast(
+            "Space.McpServerStatusResponse",
+            cls._static_request(
+                "get",
+                f"/space/{space_id}/mcp-servers/status",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    async def get_mcp_server_status_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+    ) -> "Space.McpServerStatusResponse":
+        """
+        Async get the MCP servers enabled on a space with the calling user's own OAuth
+        connection state (``isOAuth2Connected``, ``oauth2Url``).
+        """
+        return cast(
+            "Space.McpServerStatusResponse",
+            await cls._static_request_async(
+                "get",
+                f"/space/{space_id}/mcp-servers/status",
+                user_id,
+                company_id,
+            ),
+        )

{unique_sdk-2026.44.0.dev1 → unique_sdk-2026.44.0.dev3}/unique_sdk/cli/cli.py

@@ -63,6 +63,9 @@ from unique_sdk.cli.commands.folders import (
     is_mkdir_error_output as _is_mkdir_error_output,
 )
 from unique_sdk.cli.commands.mcp import cmd_mcp
+from unique_sdk.cli.commands.mcp import (
+    is_error_output as _is_mcp_error_output,
+)
 from unique_sdk.cli.commands.navigation import cmd_cd, cmd_ls, cmd_pwd
 from unique_sdk.cli.commands.read import cmd_read
 from unique_sdk.cli.commands.read import (
@@ -844,7 +847,7 @@ def mcp(
     """
     resolved_message_id = _resolve_cli_message_id(ctx, message_id, required=True)
     resolved_chat_id = _resolve_cli_chat_id(ctx, chat_id, required=True)
-    click.echo(
+    emit(
         cmd_mcp(
             LazyState.get(ctx),
             chat_id=resolved_chat_id or "",
@@ -852,7 +855,8 @@ def mcp(
             payload=payload,
             file=file_path,
             stdin=use_stdin,
-        )
+        ),
+        is_error=_is_mcp_error_output,
     )
 
 

{unique_sdk-2026.44.0.dev1 → unique_sdk-2026.44.0.dev3}/unique_sdk/cli/commands/mcp.py

@@ -26,6 +26,9 @@ from unique_sdk.cli.workspace import unique_dir as workspace_unique_dir
 
 _LOGGER = logging.getLogger(__name__)
 
+MCP_ERROR_PREFIX = "mcp:"
+_FORMATTER_ERROR_PREFIX = "mcp: formatter error"
+
 # Per-turn manifest of MCP tool output text, consumed by the Swappable
 # Intelligence runner to ground the hallucination check against MCP-retrieved
 # information (UN-21951). Carries *text only* — no source numbers/markers
@@ -1058,6 +1061,58 @@ def _parse_and_validate(raw: str) -> tuple[str, dict[str, Any]]:
     return name, arguments
 
 
+class McpCommandResult(str):
+    """Text returned by ``cmd_mcp``, with whether that call failed.
+
+    Subclasses ``str`` so callers can print and search the text. ``failed``
+    is set when the process should exit 1: a payload error, any
+    ``UniqueError``, or a tool result with ``isError`` set.
+    """
+
+    failed: bool
+
+    def __new__(cls, text: str, *, failed: bool) -> McpCommandResult:
+        result = str.__new__(cls, text)
+        result.failed = failed
+        return result
+
+
+def _response_is_error(response: Any) -> bool:
+    """Return whether the tool result itself is marked ``isError``.
+
+    Args:
+        response (Any): Raw MCP tool response.
+
+    Returns:
+        bool: True when ``isError`` is set. False when it is absent, false,
+        or unreadable, so a formatter failure on a successful result still
+        exits 0.
+    """
+    try:
+        return bool(getattr(response, "isError", False))
+    except Exception:
+        return False
+
+
+def is_error_output(output: str) -> bool:
+    """Return whether an MCP command result should exit non-zero.
+
+    Args:
+        output (str): Text returned by ``cmd_mcp``.
+
+    Returns:
+        bool: True for payload errors, SDK errors, and ``isError`` tool
+        results. False when the call succeeded, including when formatting
+        that successful result failed and the fallback text was returned.
+    """
+    failed = getattr(output, "failed", None)
+    if isinstance(failed, bool):
+        return failed
+    if output.startswith(_FORMATTER_ERROR_PREFIX):
+        return False
+    return output.startswith(MCP_ERROR_PREFIX)
+
+
 def cmd_mcp(
     state: ShellState,
     chat_id: str,
@@ -1065,8 +1120,21 @@ def cmd_mcp(
     payload: str | None = None,
     file: str | None = None,
     stdin: bool = False,
-) -> str:
-    """Call an MCP tool with a JSON payload containing name and arguments."""
+) -> McpCommandResult:
+    """Call an MCP tool with a JSON payload containing name and arguments.
+
+    Args:
+        state (ShellState): CLI session holding the user and company ids.
+        chat_id (str): Chat the tool call is attributed to.
+        message_id (str): Message the tool call is attributed to.
+        payload (str | None): Inline JSON payload.
+        file (str | None): Path to a JSON payload file.
+        stdin (bool): Read the JSON payload from stdin.
+
+    Returns:
+        McpCommandResult: Formatted tool output, or an ``mcp:`` error line.
+        ``failed`` is true when the call itself failed.
+    """
     try:
         raw = _read_payload(payload, file, stdin)
         name, arguments = _parse_and_validate(raw)
@@ -1080,8 +1148,8 @@ def cmd_mcp(
             arguments=arguments,
         )
 
-    except (ValueError, OSError, unique_sdk.APIError) as e:
-        return f"mcp: {e}"
+    except (ValueError, OSError, unique_sdk.UniqueError) as e:
+        return McpCommandResult(f"{MCP_ERROR_PREFIX} {e}", failed=True)
 
     try:
         formatted = format_mcp_response(response, tool_name=name)
@@ -1090,7 +1158,8 @@ def cmd_mcp(
             fallback = json.dumps(dict(response), indent=2, default=str)
         except Exception:
             fallback = repr(response)
-        formatted = f"mcp: formatter error ({fmt_exc}); raw response:\n{fallback}"
+        formatted = f"{_FORMATTER_ERROR_PREFIX} ({fmt_exc}); raw response:\n{fallback}"
+    call_failed = _response_is_error(response)
 
     server_name = _server_name_from_tool(name) or getattr(response, "mcpServerId", None)
     sources_block = record_mcp_citations(
@@ -1104,5 +1173,5 @@ def cmd_mcp(
     # Sources block FIRST: large outputs get spilled/truncated tail-first by
     # the agent harness, and a trailing block is what partial reads miss.
     if sources_block:
-        return sources_block + "\n\n" + formatted
-    return formatted
+        formatted = sources_block + "\n\n" + formatted
+    return McpCommandResult(formatted, failed=call_failed)