deploypod 0.1.0__py3-none-any.whl

deploypod/resources/custom_tools.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import CustomToolResponse, MessageResult
+
+
+class CustomToolsResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(self, *, name: str, tool_type: str = "webhook", **kwargs: Any) -> CustomToolResponse:
+        payload = {"name": name, "tool_type": tool_type, **kwargs}
+        resp = self._http.post("/custom-tools/", json=payload)
+        raise_for_status(resp)
+        return CustomToolResponse(**resp.json())
+
+    def list(self) -> list[CustomToolResponse]:
+        resp = self._http.get("/custom-tools/")
+        raise_for_status(resp)
+        return [CustomToolResponse(**t) for t in resp.json()]
+
+    def get(self, tool_id: int) -> CustomToolResponse:
+        resp = self._http.get(f"/custom-tools/{tool_id}")
+        raise_for_status(resp)
+        return CustomToolResponse(**resp.json())
+
+    def update(self, tool_id: int, **kwargs: Any) -> CustomToolResponse:
+        resp = self._http.put(f"/custom-tools/{tool_id}", json=kwargs)
+        raise_for_status(resp)
+        return CustomToolResponse(**resp.json())
+
+    def delete(self, tool_id: int) -> MessageResult:
+        resp = self._http.delete(f"/custom-tools/{tool_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def test(self, tool_id: int) -> dict:
+        resp = self._http.post(f"/custom-tools/{tool_id}/test")
+        raise_for_status(resp)
+        return resp.json()
+
+    def test_configuration(self, **kwargs: Any) -> dict:
+        resp = self._http.post("/custom-tools/test-configuration", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Agent tool assignment ────────────────────────────────────
+
+    def assign_to_agent(self, agent_id: int, tool_id: int, *, enabled: bool = True) -> dict:
+        resp = self._http.post(f"/custom-tools/agents/{agent_id}/tools", json={"tool_id": tool_id, "enabled": enabled})
+        raise_for_status(resp)
+        return resp.json()
+
+    def remove_from_agent(self, agent_id: int, tool_id: int) -> MessageResult:
+        resp = self._http.delete(f"/custom-tools/agents/{agent_id}/tools/{tool_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def list_for_agent(self, agent_id: int) -> list[dict]:
+        resp = self._http.get(f"/custom-tools/agents/{agent_id}/tools")
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_agent_assignments(self, agent_id: int) -> list[dict]:
+        resp = self._http.get(f"/custom-tools/agents/{agent_id}/tool-assignments")
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_agent_tool_hook(
+        self,
+        agent_id: int,
+        tool_id: int,
+        *,
+        trigger: str | None = None,
+        hook_config: dict | None = None,
+    ) -> dict:
+        """Update hook trigger/config for an agent-tool assignment.
+
+        Args:
+            agent_id: The agent ID.
+            tool_id: The custom tool ID.
+            trigger: Set to 'hook' to make this tool a pre-pipeline hook, or None to disable.
+            hook_config: Hook configuration dict with 'on_error' ('skip'|'block') and 'execution_order'.
+        """
+        resp = self._http.put(
+            f"/custom-tools/agents/{agent_id}/tools/{tool_id}/hook",
+            json={"trigger": trigger, "hook_config": hook_config},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── MCP tool assignment ──────────────────────────────────────
+
+    def assign_mcp_tool_to_agent(self, agent_id: int, mcp_tool_id: int) -> dict:
+        resp = self._http.post(f"/custom-tools/agents/{agent_id}/mcp-tools/{mcp_tool_id}")
+        raise_for_status(resp)
+        return resp.json()
+
+    def remove_mcp_tool_from_agent(self, agent_id: int, mcp_tool_id: int) -> MessageResult:
+        resp = self._http.delete(f"/custom-tools/agents/{agent_id}/mcp-tools/{mcp_tool_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    # ── Executions & Security ────────────────────────────────────
+
+    def list_executions(self, tool_id: int | None = None) -> list[dict]:
+        if tool_id is not None:
+            resp = self._http.get(f"/custom-tools/{tool_id}/executions")
+        else:
+            resp = self._http.get("/custom-tools/executions/all")
+        raise_for_status(resp)
+        return resp.json()
+
+    def list_security_events(self) -> list[dict]:
+        resp = self._http.get("/security/events")
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_security_summary(self) -> dict:
+        resp = self._http.get("/security/summary")
+        raise_for_status(resp)
+        return resp.json()

deploypod/resources/groups.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import GroupMemberResponse, GroupResponse, MessageResult
+
+
+class GroupsResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(self, *, name: str) -> GroupResponse:
+        resp = self._http.post("/groups/", json={"name": name})
+        raise_for_status(resp)
+        return GroupResponse(**resp.json())
+
+    def list(self) -> list[GroupResponse]:
+        resp = self._http.get("/groups/")
+        raise_for_status(resp)
+        return [GroupResponse(**g) for g in resp.json()]
+
+    def get(self, group_id: int) -> GroupResponse:
+        resp = self._http.get(f"/groups/{group_id}")
+        raise_for_status(resp)
+        return GroupResponse(**resp.json())
+
+    def update(self, group_id: int, **kwargs: Any) -> GroupResponse:
+        resp = self._http.put(f"/groups/{group_id}", json=kwargs)
+        raise_for_status(resp)
+        return GroupResponse(**resp.json())
+
+    def delete(self, group_id: int) -> MessageResult:
+        resp = self._http.delete(f"/groups/{group_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    # ── Members ──────────────────────────────────────────────────
+
+    def list_members(self, group_id: int) -> list[dict]:
+        resp = self._http.get(f"/groups/{group_id}/members")
+        raise_for_status(resp)
+        return resp.json()
+
+    def add_member(self, group_id: int, *, user_id: str, permission_level: str = "viewer") -> dict:
+        resp = self._http.post(
+            f"/groups/{group_id}/members",
+            json={"user_id": user_id, "permission_level": permission_level},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    def remove_member(self, group_id: int, user_id: str) -> MessageResult:
+        resp = self._http.delete(f"/groups/{group_id}/members/{user_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def update_member_permission(self, group_id: int, user_id: str, permission_level: str) -> dict:
+        resp = self._http.put(
+            f"/groups/{group_id}/members/{user_id}/permission",
+            json={"permission_level": permission_level},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_accessible_resources(self, resource_type: str) -> list[dict]:
+        resp = self._http.get(f"/groups/resources/{resource_type}")
+        raise_for_status(resp)
+        return resp.json()

deploypod/resources/jobs.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import JobResponse, MessageResult
+
+
+class JobsResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self) -> list[JobResponse]:
+        resp = self._http.get("/agent-jobs/")
+        raise_for_status(resp)
+        return [JobResponse(**j) for j in resp.json()]
+
+    def get(self, job_uuid: str) -> JobResponse:
+        resp = self._http.get(f"/agent-jobs/{job_uuid}")
+        raise_for_status(resp)
+        return JobResponse(**resp.json())
+
+    def cancel(self, job_uuid: str) -> MessageResult:
+        resp = self._http.patch(f"/agent-jobs/{job_uuid}", json={"status": "cancelled"})
+        raise_for_status(resp)
+        return message_result(resp)

deploypod/resources/knowledge_bases.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import json_body, raise_for_status
+from deploypod.types import KnowledgeBaseResponse, MessageResult
+
+
+class KnowledgeBasesResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(self, *, name: str, description: str = "", group_id: int | None = None) -> KnowledgeBaseResponse:
+        payload: dict[str, Any] = {"name": name, "description": description}
+        if group_id is not None:
+            payload["group_id"] = group_id
+        resp = self._http.post("/kb/", json=payload)
+        raise_for_status(resp)
+        return KnowledgeBaseResponse(**resp.json())
+
+    def list(self) -> list[KnowledgeBaseResponse]:
+        resp = self._http.get("/kb/")
+        raise_for_status(resp)
+        return [KnowledgeBaseResponse(**kb) for kb in resp.json()]
+
+    def get(self, kb_id: int) -> KnowledgeBaseResponse:
+        resp = self._http.get(f"/kb/{kb_id}")
+        raise_for_status(resp)
+        return KnowledgeBaseResponse(**resp.json())
+
+    def update(self, kb_id: int, **kwargs: Any) -> KnowledgeBaseResponse:
+        resp = self._http.put(f"/kb/{kb_id}", json=kwargs)
+        raise_for_status(resp)
+        return KnowledgeBaseResponse(**resp.json())
+
+    def delete(self, kb_id: int, *, force: bool = False) -> dict:
+        params = {"force": "true"} if force else {}
+        resp = self._http.delete(f"/kb/{kb_id}", params=params)
+        raise_for_status(resp)
+        return json_body(resp)
+
+    def get_constraints(self) -> dict:
+        resp = self._http.get("/kb/constraints")
+        raise_for_status(resp)
+        return resp.json()

deploypod/resources/knowledge_sources.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+from typing import Any, BinaryIO
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import KnowledgeSourceResponse, MessageResult
+
+
+class KnowledgeSourcesResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def upload(self, *, kb_id: int, name: str, file_path: str | Path | None = None,
+               file_obj: BinaryIO | None = None, file_name: str | None = None,
+               description: str = "", purpose: str = "KNOWLEDGE_ONLY") -> KnowledgeSourceResponse:
+        """Upload a file as a knowledge source.
+
+        Provide either ``file_path`` (path on disk) or ``file_obj`` + ``file_name``.
+        """
+        if file_path is not None:
+            file_path = Path(file_path)
+            file_name = file_name or file_path.name
+            fp = open(file_path, "rb")
+            should_close = True
+        elif file_obj is not None:
+            if not file_name:
+                raise ValueError("file_name is required when using file_obj")
+            fp = file_obj
+            should_close = False
+        else:
+            raise ValueError("Either file_path or file_obj must be provided")
+
+        try:
+            content_type = mimetypes.guess_type(file_name)[0] or "application/octet-stream"
+            resp = self._http.post(
+                "/ks/upload",
+                params={"kb_id": kb_id},
+                data={"name": name, "description": description, "purpose": purpose},
+                files={"file": (file_name, fp, content_type)},
+            )
+        finally:
+            if should_close:
+                fp.close()
+
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def create(self, *, kb_id: int, name: str, source_type: str, source_identifier: str,
+               purpose: str = "knowledge_only", options: dict | None = None) -> KnowledgeSourceResponse:
+        payload: dict[str, Any] = {
+            "kb_id": kb_id,
+            "name": name,
+            "source_type": source_type,
+            "source_identifier": source_identifier,
+            "purpose": purpose,
+        }
+        if options is not None:
+            payload["options"] = options
+        resp = self._http.post("/ks/", json=payload)
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def create_web(self, *, kb_id: int, name: str, url: str,
+                   purpose: str = "KNOWLEDGE_ONLY", description: str = "",
+                   auth_headers: dict[str, str] | None = None) -> KnowledgeSourceResponse:
+        payload: dict[str, Any] = {
+            "kb_id": kb_id,
+            "name": name,
+            "url": url,
+            "purpose": purpose,
+        }
+        if description:
+            payload["description"] = description
+        if auth_headers:
+            payload["auth_headers"] = auth_headers
+        resp = self._http.post("/ks/web", json=payload)
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def list(self, *, kb_id: int) -> list[KnowledgeSourceResponse]:
+        resp = self._http.get("/ks/", params={"kb_id": kb_id})
+        raise_for_status(resp)
+        return [KnowledgeSourceResponse(**s) for s in resp.json()]
+
+    def get(self, source_id: int) -> KnowledgeSourceResponse:
+        resp = self._http.get(f"/ks/{source_id}")
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def update(self, source_id: int, **kwargs: Any) -> KnowledgeSourceResponse:
+        resp = self._http.put(f"/ks/{source_id}", json=kwargs)
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def delete(self, source_id: int) -> MessageResult:
+        resp = self._http.delete(f"/ks/{source_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def parse(self, source_id: int, **kwargs: Any) -> dict:
+        """Trigger parsing/processing for a knowledge source."""
+        resp = self._http.post(f"/ks/{source_id}/parse", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def create_database_table(self, *, kb_id: int, name: str, **kwargs: Any) -> KnowledgeSourceResponse:
+        payload: dict[str, Any] = {"kb_id": kb_id, "name": name, **kwargs}
+        resp = self._http.post("/ks/database-table", json=payload)
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def create_graph(self, *, kb_id: int, name: str, **kwargs: Any) -> KnowledgeSourceResponse:
+        payload: dict[str, Any] = {"kb_id": kb_id, "name": name, **kwargs}
+        resp = self._http.post("/ks/graph", json=payload)
+        raise_for_status(resp)
+        return KnowledgeSourceResponse(**resp.json())
+
+    def sync_database_tables(self, source_id: int) -> dict:
+        resp = self._http.post(f"/ks/{source_id}/sync-database-tables")
+        raise_for_status(resp)
+        return resp.json()
+
+    def search(self, *, kb_id: int, query: str, **kwargs: Any) -> list[dict]:
+        payload: dict[str, Any] = {"kb_id": kb_id, "query": query, **kwargs}
+        resp = self._http.post("/ks/search", json=payload)
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_progress(self, source_id: int) -> dict:
+        resp = self._http.get(f"/ks/{source_id}/progress")
+        raise_for_status(resp)
+        return resp.json()
+
+    def list_by_kbs(self, kb_ids: list[int]) -> list[KnowledgeSourceResponse]:
+        resp = self._http.get("/ks/by-kb", params={"kb_ids": ",".join(str(i) for i in kb_ids)})
+        raise_for_status(resp)
+        return [KnowledgeSourceResponse(**s) for s in resp.json()]

deploypod/resources/mcp_servers.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import json_body, message_result, raise_for_status
+from deploypod.types import MCPServerResponse, MCPToolResponse, MessageResult
+
+
+class MCPServersResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(self, *, name: str, **kwargs: Any) -> MCPServerResponse:
+        payload = {"name": name, **kwargs}
+        resp = self._http.post("/mcp/servers", json=payload)
+        raise_for_status(resp)
+        return MCPServerResponse(**resp.json())
+
+    def list(self) -> list[MCPServerResponse]:
+        resp = self._http.get("/mcp/servers")
+        raise_for_status(resp)
+        return [MCPServerResponse(**s) for s in resp.json()]
+
+    def get(self, server_id: int) -> MCPServerResponse:
+        resp = self._http.get(f"/mcp/servers/{server_id}")
+        raise_for_status(resp)
+        return MCPServerResponse(**resp.json())
+
+    def update(self, server_id: int, **kwargs: Any) -> MCPServerResponse:
+        resp = self._http.put(f"/mcp/servers/{server_id}", json=kwargs)
+        raise_for_status(resp)
+        return MCPServerResponse(**resp.json())
+
+    def delete(self, server_id: int, *, force: bool = False) -> dict:
+        params = {"force": "true"} if force else {}
+        resp = self._http.delete(f"/mcp/servers/{server_id}", params=params)
+        raise_for_status(resp)
+        return json_body(resp)
+
+    def health_check(self, server_id: int) -> dict:
+        resp = self._http.get(f"/mcp/servers/{server_id}/health")
+        raise_for_status(resp)
+        return resp.json()
+
+    def test_connection(self, server_id: int) -> dict:
+        resp = self._http.post(f"/mcp/servers/{server_id}/test")
+        raise_for_status(resp)
+        return resp.json()
+
+    def discover_capabilities(self, server_id: int) -> dict:
+        resp = self._http.get(f"/mcp/servers/{server_id}/capabilities")
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Tools ────────────────────────────────────────────────────
+
+    def list_tools(self, server_id: int) -> list[MCPToolResponse]:
+        resp = self._http.get(f"/mcp/servers/{server_id}/tools")
+        raise_for_status(resp)
+        return [MCPToolResponse(**t) for t in resp.json()]
+
+    def list_all_tools(self) -> list[MCPToolResponse]:
+        resp = self._http.get("/mcp/tools")
+        raise_for_status(resp)
+        return [MCPToolResponse(**t) for t in resp.json()]
+
+    def update_tool(self, tool_id: int, **kwargs: Any) -> MCPToolResponse:
+        resp = self._http.put(f"/mcp/tools/{tool_id}", json=kwargs)
+        raise_for_status(resp)
+        return MCPToolResponse(**resp.json())
+
+    def delete_tool(self, tool_id: int) -> MessageResult:
+        resp = self._http.delete(f"/mcp/tools/{tool_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def test_tool(self, server_id: int, tool_name: str, parameters: dict[str, Any] | None = None) -> dict:
+        """Run one tool of a server by name. The API tests tools by id
+        (POST /mcp/tools/:id/test), so the name is resolved first."""
+        tool = next((t for t in self.list_tools(server_id) if t.tool_name == tool_name), None)
+        if tool is None:
+            raise ValueError(f"MCP server {server_id} has no tool {tool_name!r}")
+        return self.test_tool_by_id(tool.id, parameters)
+
+    def test_tool_by_id(self, tool_id: int, parameters: dict[str, Any] | None = None) -> dict:
+        resp = self._http.post(f"/mcp/tools/{tool_id}/test", json={"parameters": parameters or {}})
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_agent_tools(self, agent_id: int) -> list[MCPToolResponse]:
+        resp = self._http.get(f"/mcp/agents/{agent_id}/tools")
+        raise_for_status(resp)
+        return [MCPToolResponse(**t) for t in resp.json()]
+
+    # ── OAuth ────────────────────────────────────────────────────
+
+    def get_oauth_url(self, server_id: int) -> dict:
+        resp = self._http.get(f"/mcp/servers/{server_id}/oauth/url")
+        raise_for_status(resp)
+        return resp.json()
+
+    def oauth_callback(self, server_id: int, **kwargs: Any) -> dict:
+        resp = self._http.post(f"/mcp/servers/{server_id}/oauth/callback", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def oauth_refresh(self, server_id: int) -> dict:
+        resp = self._http.post(f"/mcp/servers/{server_id}/oauth/refresh")
+        raise_for_status(resp)
+        return resp.json()
+
+    def oauth_disconnect(self, server_id: int) -> dict:
+        resp = self._http.delete(f"/mcp/servers/{server_id}/oauth")
+        raise_for_status(resp)
+        return json_body(resp)

deploypod/resources/organization.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.resources.users import UsersResource
+from deploypod.types import LicenseInfoResponse, MessageResult, UserResponse
+
+
+class OrganizationResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def get_current(self) -> dict:
+        resp = self._http.get("/orgs/current")
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Session / timeout settings ───────────────────────────────
+
+    def update_session_timeout(self, hours: int) -> dict:
+        resp = self._http.put("/orgs/session-timeout", json={"session_timeout_hours": hours})
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_timeout_settings(self, **kwargs: Any) -> dict:
+        resp = self._http.put("/orgs/timeout-settings", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Speech / TTS config ──────────────────────────────────────
+
+    def get_speech_config(self) -> dict:
+        resp = self._http.get("/orgs/speech-config")
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_speech_config(self, **kwargs: Any) -> dict:
+        resp = self._http.put("/orgs/speech-config", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def list_voices(self) -> list[dict]:
+        resp = self._http.get("/orgs/voices")
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── License ──────────────────────────────────────────────────
+
+    def setup_license(self, license_token: str) -> dict:
+        resp = self._http.put("/orgs/license", json={"license_token": license_token})
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_license(self, license_token: str) -> dict:
+        resp = self._http.put("/orgs/license", json={"license_token": license_token})
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_license_info(self) -> LicenseInfoResponse:
+        resp = self._http.get("/orgs/license")
+        raise_for_status(resp)
+        return LicenseInfoResponse(**resp.json())
+
+    # ── Invitations ──────────────────────────────────────────────
+
+    def invite_user(
+        self,
+        email: str,
+        *,
+        roles: list[str] | None = None,
+        app_url: str | None = None,
+    ) -> UserResponse:
+        """Create the user and email them a login link.
+
+        There are no pending invitations: the user exists as soon as this
+        returns and shows up in ``users.list()``. ``app_url`` builds the login
+        link on another app's host (e.g. SDT Copilot) instead of the platform's.
+        """
+        return UsersResource(self._http).create(
+            email=email, roles=roles, send_password_email=True, app_url=app_url
+        )
+
+    # ── Search / query settings ───────────────────────────────────
+
+    def get_search_config(self) -> dict:
+        resp = self._http.get("/orgs/search-config")
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_search_config(self, **kwargs: Any) -> dict:
+        resp = self._http.put("/orgs/search-config", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_query_settings(self, **kwargs: Any) -> dict:
+        resp = self._http.put("/orgs/query-settings", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_pruning_settings(self, **kwargs: Any) -> dict:
+        resp = self._http.put("/orgs/pruning-settings", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Notifications ─────────────────────────────────────────────
+
+    def list_notifications(self) -> list[dict]:
+        resp = self._http.get("/orgs/notifications")
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_unread_count(self) -> dict:
+        resp = self._http.get("/orgs/notifications/unread-count")
+        raise_for_status(resp)
+        return resp.json()
+
+    def mark_notification_read(self, notification_id: int) -> dict:
+        resp = self._http.patch(f"/orgs/notifications/{notification_id}/read")
+        raise_for_status(resp)
+        return resp.json()
+
+    def delete_notification(self, notification_id: int) -> MessageResult:
+        resp = self._http.delete(f"/orgs/notifications/{notification_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def get_notification_preferences(self) -> dict:
+        resp = self._http.get("/orgs/notification-preferences")
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_notification_preferences(self, **kwargs: Any) -> dict:
+        resp = self._http.patch("/orgs/notification-preferences", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Audit logs ────────────────────────────────────────────────
+
+    def get_audit_logs(self) -> list[dict]:
+        resp = self._http.get("/orgs/audit-logs")
+        raise_for_status(resp)
+        return resp.json()
+
+    def remove_license(self) -> MessageResult:
+        resp = self._http.delete("/orgs/license")
+        raise_for_status(resp)
+        return message_result(resp)