managed-deepagents 0.1.1__py3-none-any.whl

managed_deepagents/__init__.py

@@ -0,0 +1,25 @@
+"""Python SDK for LangSmith Managed Deep Agents."""
+
+from managed_deepagents.client import (
+    AsyncClient,
+    AsyncManagedDeepAgentsClient,
+    Client,
+    ManagedDeepAgentsClient,
+)
+from managed_deepagents.errors import (
+    ManagedDeepAgentsAPIError,
+    ManagedDeepAgentsConfigError,
+    ManagedDeepAgentsError,
+)
+from managed_deepagents.streaming import SSEEvent
+
+__all__ = [
+    "AsyncClient",
+    "AsyncManagedDeepAgentsClient",
+    "Client",
+    "ManagedDeepAgentsAPIError",
+    "ManagedDeepAgentsClient",
+    "ManagedDeepAgentsConfigError",
+    "ManagedDeepAgentsError",
+    "SSEEvent",
+]

managed_deepagents/_utils.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Any
+
+DEFAULT_API_URL = "https://api.smith.langchain.com"
+MANAGED_DEEPAGENTS_PATH = "/v1/deepagents"
+FLEET_PATH = "/v1/fleet"
+MANAGED_AGENT_BASE_PATHS = (
+    MANAGED_DEEPAGENTS_PATH,
+    FLEET_PATH,
+)
+
+
+def get_default_api_key() -> str | None:
+    return os.getenv("LANGSMITH_API_KEY")
+
+
+def get_default_api_url() -> str:
+    return os.getenv("LANGSMITH_ENDPOINT") or DEFAULT_API_URL
+
+
+def normalize_api_url(api_url: str) -> str:
+    base_url = api_url.rstrip("/")
+    if base_url.endswith(MANAGED_AGENT_BASE_PATHS):
+        return base_url
+    if base_url.endswith("/v1"):
+        return f"{base_url}/deepagents"
+    return f"{base_url}{MANAGED_DEEPAGENTS_PATH}"
+
+
+def clean_mapping(values: Mapping[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in values.items() if value is not None}
+
+
+def merge_body_fields(
+    body: Mapping[str, Any] | None,
+    fields: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = dict(body or {})
+    payload.update(clean_mapping(fields))
+    return payload
+
+
+def prepare_agent_payload(payload: Mapping[str, Any]) -> dict[str, Any]:
+    next_payload = dict(payload)
+    files = next_payload.get("files")
+    if isinstance(files, Mapping):
+        next_payload["files"] = {
+            path: {"content": value} if isinstance(value, str) else value
+            for path, value in files.items()
+        }
+    return next_payload
+
+
+def build_stream_body(
+    *,
+    agent_id: str,
+    messages: list[Mapping[str, Any]],
+    stream_mode: list[str] | None = None,
+    stream_subgraphs: bool | None = None,
+    user_timezone: str | None = None,
+    extra: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    body = dict(extra or {})
+    body.update(
+        clean_mapping(
+            {
+                "agent_id": agent_id,
+                "messages": messages,
+                "stream_mode": stream_mode,
+                "stream_subgraphs": stream_subgraphs,
+                "user_timezone": user_timezone,
+            }
+        )
+    )
+    return body
+
+
+def build_invoke_body(
+    *,
+    agent_id: str,
+    messages: list[Mapping[str, Any]],
+    extra: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    body = dict(extra or {})
+    body["assistant_id"] = agent_id
+    body["input"] = {"messages": messages}
+    return body

managed_deepagents/client.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterable, Iterable, Mapping
+from typing import Any
+
+import httpx
+
+from managed_deepagents._utils import (
+    get_default_api_key,
+    get_default_api_url,
+    normalize_api_url,
+)
+from managed_deepagents.errors import ManagedDeepAgentsAPIError
+from managed_deepagents.resources import (
+    AgentsResource,
+    AsyncAgentsResource,
+    AsyncAuthSessionsResource,
+    AsyncMcpServersResource,
+    AsyncThreadsResource,
+    AuthSessionsResource,
+    McpServersResource,
+    ThreadsResource,
+)
+from managed_deepagents.streaming import SSEEvent, aiter_sse_events, iter_sse_events
+
+
+class Client:
+    def __init__(
+        self,
+        *,
+        api_url: str | None = None,
+        api_key: str | None = None,
+        workspace_id: str | None = None,
+        timeout: float | httpx.Timeout = 30.0,
+        headers: Mapping[str, str] | None = None,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        self.api_url = normalize_api_url(api_url or get_default_api_url())
+        self.api_key = api_key if api_key is not None else get_default_api_key()
+        self.workspace_id = workspace_id
+        self._headers = dict(headers or {})
+        self._owns_client = http_client is None
+        self._client = http_client or httpx.Client(timeout=timeout)
+
+        self.agents = AgentsResource(self)
+        self.threads = ThreadsResource(self)
+        self.mcp_servers = McpServersResource(self)
+        self.auth_sessions = AuthSessionsResource(self)
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Mapping[str, Any] | None = None,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> Any:
+        response = self._client.request(
+            method,
+            self._url(path),
+            json=json,
+            params=params,
+            headers=self._request_headers(headers),
+        )
+        return _decode_response(response)
+
+    def stream(
+        self,
+        path: str,
+        *,
+        json: Mapping[str, Any],
+        headers: Mapping[str, str] | None = None,
+    ) -> Iterable[SSEEvent]:
+        with self._client.stream(
+            "POST",
+            self._url(path),
+            json=json,
+            headers=self._request_headers(
+                {"Accept": "text/event-stream", **dict(headers or {})}
+            ),
+        ) as response:
+            if response.status_code >= 400:
+                response.read()
+            _raise_for_status(response)
+            yield from iter_sse_events(response.iter_bytes())
+
+    def _url(self, path: str) -> str:
+        return f"{self.api_url}/{path.lstrip('/')}"
+
+    def _request_headers(
+        self,
+        headers: Mapping[str, str] | None = None,
+    ) -> dict[str, str]:
+        request_headers = {"Accept": "application/json", **self._headers}
+        if self.api_key:
+            request_headers["X-Api-Key"] = self.api_key
+        if self.workspace_id:
+            request_headers["X-Tenant-Id"] = self.workspace_id
+        request_headers.update(headers or {})
+        return request_headers
+
+
+class AsyncClient:
+    def __init__(
+        self,
+        *,
+        api_url: str | None = None,
+        api_key: str | None = None,
+        workspace_id: str | None = None,
+        timeout: float | httpx.Timeout = 30.0,
+        headers: Mapping[str, str] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.api_url = normalize_api_url(api_url or get_default_api_url())
+        self.api_key = api_key if api_key is not None else get_default_api_key()
+        self.workspace_id = workspace_id
+        self._headers = dict(headers or {})
+        self._owns_client = http_client is None
+        self._client = http_client or httpx.AsyncClient(timeout=timeout)
+
+        self.agents = AsyncAgentsResource(self)
+        self.threads = AsyncThreadsResource(self)
+        self.mcp_servers = AsyncMcpServersResource(self)
+        self.auth_sessions = AsyncAuthSessionsResource(self)
+
+    async def close(self) -> None:
+        if self._owns_client:
+            await self._client.aclose()
+
+    async def __aenter__(self) -> AsyncClient:
+        return self
+
+    async def __aexit__(self, *_exc: object) -> None:
+        await self.close()
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Mapping[str, Any] | None = None,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> Any:
+        response = await self._client.request(
+            method,
+            self._url(path),
+            json=json,
+            params=params,
+            headers=self._request_headers(headers),
+        )
+        return _decode_response(response)
+
+    async def stream(
+        self,
+        path: str,
+        *,
+        json: Mapping[str, Any],
+        headers: Mapping[str, str] | None = None,
+    ) -> AsyncIterable[SSEEvent]:
+        async with self._client.stream(
+            "POST",
+            self._url(path),
+            json=json,
+            headers=self._request_headers(
+                {"Accept": "text/event-stream", **dict(headers or {})}
+            ),
+        ) as response:
+            if response.status_code >= 400:
+                await response.aread()
+            _raise_for_status(response)
+            async for event in aiter_sse_events(response.aiter_bytes()):
+                yield event
+
+    def _url(self, path: str) -> str:
+        return f"{self.api_url}/{path.lstrip('/')}"
+
+    def _request_headers(
+        self,
+        headers: Mapping[str, str] | None = None,
+    ) -> dict[str, str]:
+        request_headers = {"Accept": "application/json", **self._headers}
+        if self.api_key:
+            request_headers["X-Api-Key"] = self.api_key
+        if self.workspace_id:
+            request_headers["X-Tenant-Id"] = self.workspace_id
+        request_headers.update(headers or {})
+        return request_headers
+
+
+def _decode_response(response: httpx.Response) -> Any:
+    _raise_for_status(response)
+    if response.status_code == 204 or not response.content:
+        return None
+    content_type = response.headers.get("content-type", "")
+    if "application/json" not in content_type:
+        return response.text
+    return response.json()
+
+
+def _raise_for_status(response: httpx.Response) -> None:
+    if response.status_code < 400:
+        return
+    body = _response_body(response)
+    detail = body.get("detail") if isinstance(body, dict) else None
+    code = body.get("code") if isinstance(body, dict) else None
+    message = detail or response.reason_phrase or "Managed Deep Agents API error"
+    raise ManagedDeepAgentsAPIError(
+        message,
+        status_code=response.status_code,
+        code=code,
+        detail=detail,
+        body=body,
+    )
+
+
+def _response_body(response: httpx.Response) -> Any:
+    try:
+        return response.json()
+    except ValueError:
+        return response.text
+
+
+ManagedDeepAgentsClient = Client
+AsyncManagedDeepAgentsClient = AsyncClient

managed_deepagents/errors.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class ManagedDeepAgentsError(Exception):
+    """Base exception raised by the Managed Deep Agents SDK."""
+
+
+class ManagedDeepAgentsConfigError(ManagedDeepAgentsError):
+    """Raised when client configuration is invalid."""
+
+
+class ManagedDeepAgentsAPIError(ManagedDeepAgentsError):
+    """Raised when the API returns a non-2xx response."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        code: str | None = None,
+        detail: str | None = None,
+        body: Any | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.detail = detail
+        self.body = body

managed_deepagents/py.typed

@@ -0,0 +1 @@
+