deploypod 0.1.0__py3-none-any.whl

deploypod/resources/agents.py

@@ -0,0 +1,430 @@
+from __future__ import annotations
+
+import mimetypes
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+import httpx
+
+from deploypod._http import json_body, message_result, raise_for_status
+from deploypod.types import (
+    AgentResponse,
+    DeploymentResponse,
+    MessageResult,
+    TestPruningResponse,
+    ThirdPartyAuthResponse,
+    WalkthroughQuestionResponse,
+    WelcomeMessageResponse,
+)
+
+
+class AgentsResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    # ── CRUD ─────────────────────────────────────────────────────
+
+    def list(self) -> list[AgentResponse]:
+        resp = self._http.get("/agents/")
+        raise_for_status(resp)
+        return [AgentResponse(**a) for a in resp.json()]
+
+    def create(
+        self,
+        *,
+        name: str,
+        knowledge_base_ids: list[int],
+        llm_provider_id: int | None = None,
+        llm_model: str | None = None,
+        group_id: int | None = None,
+        system_prompt_extension: str | None = None,
+        autonomy_mode: str | None = None,
+        can_use_web_search: bool | None = None,
+        table_manager_enabled: bool | None = None,
+        writable_kb_ids: list[int] | None = None,
+        max_iterations: int | None = None,
+        tts_provider: str | None = None,
+        tts_model: str | None = None,
+        tts_voice: str | None = None,
+        speech_speed: float | None = None,
+        welcome_message_ids: list[str] | None = None,
+        output_schema: dict[str, Any] | None = None,
+    ) -> AgentResponse:
+        payload: dict[str, Any] = {
+            "name": name,
+            "knowledge_base_ids": knowledge_base_ids,
+        }
+        _set_optional(payload, "llm_provider_id", llm_provider_id)
+        _set_optional(payload, "llm_model", llm_model)
+        _set_optional(payload, "group_id", group_id)
+        _set_optional(payload, "system_prompt_extension", system_prompt_extension)
+        _set_optional(payload, "autonomy_mode", autonomy_mode)
+        _set_optional(payload, "can_use_web_search", can_use_web_search)
+        _set_optional(payload, "table_manager_enabled", table_manager_enabled)
+        _set_optional(payload, "writable_kb_ids", writable_kb_ids)
+        _set_optional(payload, "max_iterations", max_iterations)
+        _set_optional(payload, "tts_provider", tts_provider)
+        _set_optional(payload, "tts_model", tts_model)
+        _set_optional(payload, "tts_voice", tts_voice)
+        _set_optional(payload, "speech_speed", speech_speed)
+        _set_optional(payload, "welcome_message_ids", welcome_message_ids)
+        _set_optional(payload, "output_schema", output_schema)
+
+        resp = self._http.post("/agent/create", json=payload)
+        raise_for_status(resp)
+
+        # Go API returns JSON with uuid; legacy Python returned HTML embed script.
+        content_type = resp.headers.get("content-type", "")
+        if "application/json" in content_type:
+            data = resp.json()
+            return self.get(data["uuid"])
+
+        # Fallback: extract UUID from HTML embed script
+        match = re.search(r"/widget/([0-9a-f-]{36})/embed\.js", resp.text)
+        if not match:
+            raise ValueError(f"Could not parse agent UUID from create response: {resp.text[:200]}")
+        return self.get(match.group(1))
+
+    def get(self, agent_uuid: str) -> AgentResponse:
+        resp = self._http.get(f"/agent/{agent_uuid}")
+        raise_for_status(resp)
+        return AgentResponse(**resp.json())
+
+    def update(self, agent_id: int, **kwargs: Any) -> AgentResponse:
+        resp = self._http.put(f"/agent/{agent_id}", json=kwargs)
+        raise_for_status(resp)
+        return AgentResponse(**resp.json())
+
+    def delete(self, agent_id: int) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}")
+        raise_for_status(resp)
+        # The endpoint answers 204 with no body.
+        if not resp.content:
+            return MessageResult(message="Agent deleted")
+        return message_result(resp)
+
+    def list_deleted(self) -> list[AgentResponse]:
+        resp = self._http.get("/agent/deleted")
+        raise_for_status(resp)
+        return [AgentResponse(**a) for a in resp.json()]
+
+    def restore(self, agent_id: int) -> AgentResponse:
+        resp = self._http.post(f"/agent/{agent_id}/restore")
+        raise_for_status(resp)
+        return AgentResponse(**resp.json())
+
+    # ── Run ──────────────────────────────────────────────────────
+
+    def run(self, agent_uuid: str, prompt: str, *, timeout: Optional[float] = None, **options: Any) -> dict:
+        """Run the agent once and wait for the result (POST /agent/{uuid}/run).
+
+        ``options`` are the run request's other fields, e.g. ``run_skills=True``,
+        ``run_exploration=True``, ``output_schema={...}``, ``max_iterations=8``.
+        Returns the run result: ``status``, ``final_emit``, ``result_summary``,
+        ``iterations``, ``usage``, ``execution_time_ms``, ``error_message``.
+        A run can take longer than the client's default timeout; pass ``timeout``
+        (seconds) for this call.
+        """
+        extra: Dict[str, Any] = {} if timeout is None else {"timeout": timeout}
+        resp = self._http.post(f"/agent/{agent_uuid}/run", json={"prompt": prompt, **options}, **extra)
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Deployment ───────────────────────────────────────────────
+
+    def deploy(self, agent_id: int, **kwargs: Any) -> dict:
+        resp = self._http.post(f"/agent/{agent_id}/deploy", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_deployment(self, agent_id: int) -> dict:
+        resp = self._http.get(f"/agent/{agent_id}/deploy")
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_deployment(self, agent_id: int, **kwargs: Any) -> dict:
+        resp = self._http.put(f"/agent/{agent_id}/deploy", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def undeploy(self, agent_id: int) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}/deploy")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    # ── Third-party auth ─────────────────────────────────────────
+
+    def enable_third_party_auth(self, agent_uuid: str) -> ThirdPartyAuthResponse:
+        resp = self._http.post(f"/agent/{agent_uuid}/third-party-auth/enable")
+        raise_for_status(resp)
+        return ThirdPartyAuthResponse(**resp.json())
+
+    def disable_third_party_auth(self, agent_uuid: str) -> MessageResult:
+        resp = self._http.post(f"/agent/{agent_uuid}/third-party-auth/disable")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def get_shared_secret(self, agent_uuid: str) -> ThirdPartyAuthResponse:
+        resp = self._http.get(f"/agent/{agent_uuid}/third-party-auth")
+        raise_for_status(resp)
+        return ThirdPartyAuthResponse(**resp.json())
+
+    def regenerate_secret(self, agent_uuid: str) -> ThirdPartyAuthResponse:
+        resp = self._http.post(f"/agent/{agent_uuid}/third-party-auth/regenerate")
+        raise_for_status(resp)
+        return ThirdPartyAuthResponse(**resp.json())
+
+    def validate_token(self, agent_uuid: str, token: str) -> dict:
+        resp = self._http.post(f"/agent/{agent_uuid}/validate-token", json={"token": token})
+        raise_for_status(resp)
+        return resp.json()
+
+    # ── Welcome messages ─────────────────────────────────────────
+
+    def list_welcome_messages(self, agent_id: int) -> list[WelcomeMessageResponse]:
+        resp = self._http.get(f"/agent/{agent_id}/welcome-messages")
+        raise_for_status(resp)
+        return [WelcomeMessageResponse(**m) for m in resp.json()]
+
+    def update_welcome_messages(self, agent_id: int, welcome_message_ids: list[str]) -> dict:
+        resp = self._http.put(
+            f"/agent/{agent_id}/welcome-messages",
+            json={"welcome_message_ids": welcome_message_ids},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    def create_welcome_message(
+        self, *, name: str, message: str, is_template: bool = False,
+        template_variables: list[str] | None = None,
+    ) -> dict:
+        payload: dict[str, Any] = {"name": name, "message": message, "is_template": is_template}
+        _set_optional(payload, "template_variables", template_variables)
+        resp = self._http.post("/agent/welcome-messages", json=payload)
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_welcome_message(self, message_id: str) -> dict:
+        resp = self._http.get(f"/agent/welcome-messages/{message_id}")
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_welcome_message(self, message_id: str, **kwargs: Any) -> dict:
+        resp = self._http.put(f"/agent/welcome-messages/{message_id}", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def delete_welcome_message(self, message_id: str) -> MessageResult:
+        resp = self._http.delete(f"/agent/welcome-messages/{message_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    # ── Walkthrough questions ────────────────────────────────────
+
+    def list_walkthrough_questions(self, agent_id: int) -> list[WalkthroughQuestionResponse]:
+        resp = self._http.get(f"/agent/{agent_id}/walkthrough-questions")
+        raise_for_status(resp)
+        return [WalkthroughQuestionResponse(**q) for q in resp.json()]
+
+    def create_walkthrough_question(
+        self, agent_id: int, *, question_text: str, description: str | None = None,
+        category: str | None = None,
+    ) -> dict:
+        payload: dict[str, Any] = {"question_text": question_text}
+        _set_optional(payload, "description", description)
+        _set_optional(payload, "category", category)
+        resp = self._http.post(f"/agent/{agent_id}/walkthrough-questions", json=payload)
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_walkthrough_question(self, agent_id: int, question_id: str, **kwargs: Any) -> dict:
+        resp = self._http.put(f"/agent/{agent_id}/walkthrough-questions/{question_id}", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def delete_walkthrough_question(self, agent_id: int, question_id: str) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}/walkthrough-questions/{question_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def reorder_walkthrough_questions(self, agent_id: int, question_ids: list[str]) -> dict:
+        resp = self._http.put(
+            f"/agent/{agent_id}/walkthrough-questions-reorder",
+            json={"question_ids": question_ids},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    def generate_walkthrough_questions(self, agent_id: int) -> list[dict]:
+        resp = self._http.post(f"/agent/{agent_id}/walkthrough-questions/generate")
+        raise_for_status(resp)
+        return resp.json()
+
+    def add_walkthrough_attachment(
+        self, agent_id: int, question_id: str, file_path: str | Path,
+    ) -> dict:
+        """Attach a file to a walkthrough question.
+
+        The upload runs the same extraction the chat upload does, so a large
+        PDF can take longer than the client's default timeout; construct the
+        client with a larger ``timeout`` when seeding big files.
+        """
+        file_path = Path(file_path)
+        content_type = mimetypes.guess_type(file_path.name)[0] or "application/octet-stream"
+        with open(file_path, "rb") as fp:
+            resp = self._http.post(
+                f"/agent/{agent_id}/walkthrough-questions/{question_id}/attachments",
+                files={"file": (file_path.name, fp, content_type)},
+            )
+        raise_for_status(resp)
+        return resp.json()
+
+    def remove_walkthrough_attachment(
+        self, agent_id: int, question_id: str, index: int,
+    ) -> dict:
+        """Remove one attachment by position; returns the entry that was removed."""
+        resp = self._http.delete(
+            f"/agent/{agent_id}/walkthrough-questions/{question_id}/attachments/{index}"
+        )
+        raise_for_status(resp)
+        return json_body(resp)
+
+    # ── Subagents ────────────────────────────────────────────────
+
+    def list_subagents(self, agent_id: int) -> list[dict]:
+        resp = self._http.get(f"/agent/{agent_id}/subagents/")
+        raise_for_status(resp)
+        return resp.json()
+
+    def assign_subagent(self, agent_id: int, subagent_id: int, **kwargs: Any) -> dict:
+        payload = {"subagent_id": subagent_id, **kwargs}
+        resp = self._http.post(f"/agent/{agent_id}/subagents/", json=payload)
+        raise_for_status(resp)
+        return resp.json()
+
+    def update_subagent(self, agent_id: int, subagent_id: int, **kwargs: Any) -> dict:
+        resp = self._http.put(f"/agent/{agent_id}/subagents/{subagent_id}", json=kwargs)
+        raise_for_status(resp)
+        return resp.json()
+
+    def remove_subagent(self, agent_id: int, subagent_id: int) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}/subagents/{subagent_id}")
+        raise_for_status(resp)
+        # The endpoint answers {"status": "ok"}, not {"message": ...}.
+        body = resp.json() if resp.content else {}
+        return MessageResult(message=body.get("message") or body.get("status") or "Subagent removed")
+
+    # ── Long-term memory ─────────────────────────────────────────
+
+    def list_memories(self, agent_id: int) -> list[dict]:
+        resp = self._http.get(f"/agent/{agent_id}/memories")
+        raise_for_status(resp)
+        return resp.json()
+
+    def create_memory(self, agent_id: int, *, content: str, **kwargs: Any) -> dict:
+        payload = {"content": content, **kwargs}
+        resp = self._http.post(f"/agent/{agent_id}/memories", json=payload)
+        raise_for_status(resp)
+        return resp.json()
+
+    def search_memories(self, agent_id: int, *, query: str, top_k: int = 5) -> list[dict]:
+        resp = self._http.post(
+            f"/agent/{agent_id}/memories/search",
+            json={"query": query, "top_k": top_k},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    def delete_memory(self, agent_id: int, memory_id: int) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}/memories/{memory_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def delete_all_memories(self, agent_id: int) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}/memories/")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    # ── Managed tables ───────────────────────────────────────────
+
+    def list_managed_tables(self, agent_id: int) -> list[dict]:
+        resp = self._http.get(f"/agent/{agent_id}/managed-tables")
+        raise_for_status(resp)
+        return resp.json()
+
+    def get_managed_table(self, agent_id: int, table_name: str) -> dict:
+        resp = self._http.get(f"/agent/{agent_id}/managed-tables/{table_name}")
+        raise_for_status(resp)
+        return resp.json()
+
+    def query_managed_table(self, agent_id: int, *, sql: str, limit: int = 100) -> dict:
+        resp = self._http.post(
+            f"/agent/{agent_id}/managed-tables/query",
+            json={"sql": sql, "limit": limit},
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    def delete_managed_table(self, agent_id: int, table_name: str) -> MessageResult:
+        resp = self._http.delete(f"/agent/{agent_id}/managed-tables/{table_name}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    # ── Pruning test ──────────────────────────────────────────────
+
+    def test_pruning(self, agent_id: int, query: str) -> TestPruningResponse:
+        resp = self._http.post("/chat/test-pruning", json={"agent_id": agent_id, "query": query})
+        raise_for_status(resp)
+        return TestPruningResponse(**resp.json())
+
+    # ── Embed script ─────────────────────────────────────────────
+
+    def get_embed_script(self, agent_uuid: str) -> str:
+        resp = self._http.get(f"/agent/{agent_uuid}/script")
+        raise_for_status(resp)
+        return resp.text
+
+    # ── Single-shot LLM completion ───────────────────────────────
+
+    def completion(
+        self,
+        agent_uuid: str,
+        *,
+        user_prompt: str,
+        system_prompt: str | None = None,
+        tools: list[dict[str, Any]] | None = None,
+        tool_choice: str | dict[str, Any] | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        metadata: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Make a single LLM completion using the agent's configured LLM.
+
+        Uses the agent's provider, model, api_key and base_url — callers do not
+        need their own LLM credentials. Every call is recorded in LLM Monitor
+        (set ``metadata={"generation_name": "..."}`` to tag traces).
+
+        This is NOT an agent pipeline run: no tools execution, no history, no
+        reflection. Just one chat-completion call.
+
+        Returns a dict with keys: ``content``, ``tool_calls``, ``finish_reason``,
+        ``usage``, ``model``, ``duration_ms``.
+        """
+        payload: dict[str, Any] = {"user_prompt": user_prompt}
+        _set_optional(payload, "system_prompt", system_prompt)
+        _set_optional(payload, "tools", tools)
+        _set_optional(payload, "tool_choice", tool_choice)
+        _set_optional(payload, "temperature", temperature)
+        _set_optional(payload, "max_tokens", max_tokens)
+        _set_optional(payload, "metadata", metadata)
+
+        resp = self._http.post(f"/agent/{agent_uuid}/llm/completion", json=payload)
+        raise_for_status(resp)
+        return resp.json()
+
+
+def _set_optional(d: dict, key: str, value: Any) -> None:
+    if value is not None:
+        d[key] = value

deploypod/resources/async_tasks.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import AsyncRunResponse, AsyncTaskResponse, MessageResult
+
+
+class AsyncTasksResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(
+        self,
+        *,
+        agent_id: int,
+        name: str,
+        prompt: str,
+        schedule_cron: str,
+        timeout_seconds: int | None = None,
+        enabled: bool = True,
+    ) -> AsyncTaskResponse:
+        payload: dict[str, Any] = {
+            "agent_id": agent_id,
+            "name": name,
+            "prompt": prompt,
+            "schedule_cron": schedule_cron,
+            "enabled": enabled,
+        }
+        if timeout_seconds is not None:
+            payload["timeout_seconds"] = timeout_seconds
+        resp = self._http.post("/async-agents/tasks/", json=payload)
+        raise_for_status(resp)
+        return AsyncTaskResponse(**resp.json())
+
+    def list(self) -> list[AsyncTaskResponse]:
+        resp = self._http.get("/async-agents/tasks/")
+        raise_for_status(resp)
+        return [AsyncTaskResponse(**t) for t in resp.json()]
+
+    def get(self, task_id: int) -> AsyncTaskResponse:
+        resp = self._http.get(f"/async-agents/tasks/{task_id}")
+        raise_for_status(resp)
+        return AsyncTaskResponse(**resp.json())
+
+    def update(self, task_id: int, **kwargs: Any) -> MessageResult:
+        resp = self._http.put(f"/async-agents/tasks/{task_id}", json=kwargs)
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def delete(self, task_id: int) -> MessageResult:
+        resp = self._http.delete(f"/async-agents/tasks/{task_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def trigger(self, task_id: int) -> AsyncRunResponse:
+        resp = self._http.post(f"/async-agents/tasks/{task_id}/trigger")
+        raise_for_status(resp)
+        return AsyncRunResponse(**resp.json())
+
+    def list_runs(self, task_id: int | None = None, agent_id: int | None = None,
+                  status: str | None = None, limit: int = 50) -> list[AsyncRunResponse]:
+        params: dict[str, Any] = {"limit": limit}
+        if task_id is not None:
+            params["task_id"] = task_id
+        if agent_id is not None:
+            params["agent_id"] = agent_id
+        if status is not None:
+            params["status"] = status
+        resp = self._http.get("/async-agents/runs/", params=params)
+        raise_for_status(resp)
+        return [AsyncRunResponse(**r) for r in resp.json()]
+
+    def get_run(self, run_id: int) -> AsyncRunResponse:
+        resp = self._http.get(f"/async-agents/runs/{run_id}")
+        raise_for_status(resp)
+        return AsyncRunResponse(**resp.json())
+
+    def delete_run(self, run_id: int) -> MessageResult:
+        resp = self._http.delete(f"/async-agents/runs/{run_id}")
+        raise_for_status(resp)
+        return message_result(resp)

deploypod/resources/connections.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import ConnectionResponse, MessageResult, TableResponse
+
+
+class ConnectionsResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(self, *, name: str, db_type: str, **kwargs: Any) -> ConnectionResponse:
+        payload = {"name": name, "db_type": db_type, **kwargs}
+        resp = self._http.post("/connections/", json=payload)
+        raise_for_status(resp)
+        return ConnectionResponse(**resp.json())
+
+    def list(self) -> list[ConnectionResponse]:
+        resp = self._http.get("/connections/")
+        raise_for_status(resp)
+        return [ConnectionResponse(**c) for c in resp.json()]
+
+    def get(self, conn_id: int) -> ConnectionResponse:
+        resp = self._http.get(f"/connections/{conn_id}")
+        raise_for_status(resp)
+        return ConnectionResponse(**resp.json())
+
+    def update(self, conn_id: int, **kwargs: Any) -> ConnectionResponse:
+        resp = self._http.put(f"/connections/{conn_id}", json=kwargs)
+        raise_for_status(resp)
+        return ConnectionResponse(**resp.json())
+
+    def delete(self, conn_id: int) -> MessageResult:
+        resp = self._http.delete(f"/connections/{conn_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def test(self, conn_id: int) -> dict:
+        resp = self._http.post(f"/connections/{conn_id}/test")
+        raise_for_status(resp)
+        return resp.json()
+
+    def list_schemas(self, conn_id: int) -> list[dict]:
+        resp = self._http.get(f"/connections/{conn_id}/schemas")
+        raise_for_status(resp)
+        return resp.json()
+
+    def list_tables(self, conn_id: int, *, schema_name: str | None = None) -> list[dict]:
+        if schema_name:
+            resp = self._http.get(f"/connections/{conn_id}/schemas/{schema_name}/tables")
+        else:
+            resp = self._http.get(f"/connections/{conn_id}/tables")
+        raise_for_status(resp)
+        return resp.json()

deploypod/resources/conversations.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from deploypod._http import message_result, raise_for_status
+from deploypod.types import ConversationDetailResponse, ConversationResponse, MessageResult
+
+
+class ConversationsResource:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self, *, agent_id: int | None = None, skip: int = 0, limit: int = 50) -> list[ConversationResponse]:
+        params: dict[str, Any] = {"skip": skip, "limit": limit}
+        if agent_id is not None:
+            params["agent_id"] = agent_id
+        resp = self._http.get("/chat/conversations", params=params)
+        raise_for_status(resp)
+        return [ConversationResponse(**c) for c in resp.json()]
+
+    def get(self, conversation_id: str) -> ConversationDetailResponse:
+        resp = self._http.get(f"/chat/conversation/{conversation_id}")
+        raise_for_status(resp)
+        return ConversationDetailResponse(**resp.json())
+
+    def get_messages(self, conversation_id: str) -> list[dict]:
+        resp = self._http.get(f"/chat/conversation/{conversation_id}/messages")
+        raise_for_status(resp)
+        return resp.json()
+
+    def delete(self, conversation_id: str) -> MessageResult:
+        resp = self._http.delete(f"/chat/conversation/{conversation_id}")
+        raise_for_status(resp)
+        return message_result(resp)
+
+    def batch_delete(self, conversation_ids: list[str]) -> MessageResult:
+        resp = self._http.request("DELETE", "/chat/conversations/batch", json={"ids": conversation_ids})
+        raise_for_status(resp)
+        return message_result(resp)