managed-deepagents 0.1.1__tar.gz

managed_deepagents-0.1.1/.gitignore

@@ -0,0 +1,21 @@
+.DS_Store
+.env
+.env.*
+*.crt
+*.key
+*.pem
+credentials.json
+token.json
+
+node_modules/
+dist/
+coverage/
+
+__pycache__/
+*.py[cod]
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.venv/
+build/
+*.egg-info/

managed_deepagents-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LangChain, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

managed_deepagents-0.1.1/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: managed-deepagents
+Version: 0.1.1
+Summary: Python SDK for LangSmith Managed Deep Agents.
+Project-URL: Changelog, https://github.com/langchain-ai/managed-deepagents-sdk/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/langchain-ai/managed-deepagents-sdk/issues
+Project-URL: Repository, https://github.com/langchain-ai/managed-deepagents-sdk
+Author: LangChain
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,langchain,langsmith,managed-deep-agents,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0,>=0.28.1
+Provides-Extra: dev
+Requires-Dist: mypy<2.0,>=1.11; extra == 'dev'
+Requires-Dist: pytest<10.0,>=8.4; extra == 'dev'
+Requires-Dist: ruff<1.0,>=0.12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# managed-deepagents
+
+Python SDK for the LangSmith Managed Deep Agents API.
+
+Managed Deep Agents is a hosted runtime for creating, running, and operating
+Deep Agents through LangSmith. This package is currently public beta software.
+
+## Installation
+
+```bash
+pip install managed-deepagents
+```
+
+Requirements:
+
+- Python 3.10 or newer
+- A LangSmith API key with access to Managed Deep Agents
+
+## Configuration
+
+The client reads `LANGSMITH_API_KEY` by default.
+
+```bash
+export LANGSMITH_API_KEY="..."
+```
+
+The default API URL is `https://api.smith.langchain.com/v1/deepagents`.
+You can override it with `LANGSMITH_ENDPOINT` or the `api_url` client option.
+
+## Quickstart
+
+```python
+from managed_deepagents import Client
+
+with Client() as client:
+    agent = client.agents.create(
+        name="research-assistant",
+        model="anthropic:claude-sonnet-4-6",
+        instructions="You are a careful research assistant.",
+    )
+
+    thread = client.threads.create(agent_id=agent["id"])
+
+    for event in client.threads.stream(
+        thread["id"],
+        agent_id=agent["id"],
+        messages=[{"role": "user", "content": "Summarize the latest notes."}],
+        stream_mode=["values", "updates", "messages-tuple"],
+    ):
+        print(event.event, event.data)
+```
+
+## Async Usage
+
+```python
+from managed_deepagents import AsyncClient
+
+async with AsyncClient() as client:
+    agent = await client.agents.create(
+        name="research-assistant",
+        model="anthropic:claude-sonnet-4-6",
+        instructions="You are a careful research assistant.",
+    )
+```
+
+## Agent Files
+
+Top-level `files` entries may be passed as raw strings; the SDK normalizes them
+to file entries before sending the request. Use either `instructions` or
+`files["AGENTS.md"]`, not both, because the API maps the typed prompt field to
+`AGENTS.md`.
+
+```python
+agent = client.agents.create(
+    name="research-assistant",
+    files={
+        "AGENTS.md": "You are a careful research assistant.",
+        "skills/research/SKILL.md": "# Research\n\nGather context before answering.",
+    },
+    include_files=True,
+)
+```
+
+## API Surface
+
+Resources exposed by the client:
+
+- `client.agents`: list, create, get, update, delete, clone, health
+- `client.threads`: create, search, count, get, update, delete, create run,
+  invoke, stream, bulk update, resolve interrupt
+- `client.mcp_servers`: create, list, get, update, delete, register OAuth
+  provider
+- `client.auth_sessions`: create and get
+
+## Errors
+
+```python
+from managed_deepagents import ManagedDeepAgentsAPIError
+
+try:
+    client.agents.get("missing-agent")
+except ManagedDeepAgentsAPIError as error:
+    print(error.status_code, error.code, error.detail)
+```
+
+## Links
+
+- Repository: https://github.com/langchain-ai/managed-deepagents-sdk
+- Issues: https://github.com/langchain-ai/managed-deepagents-sdk/issues
+- Changelog: https://github.com/langchain-ai/managed-deepagents-sdk/blob/main/CHANGELOG.md

managed_deepagents-0.1.1/README.md

@@ -0,0 +1,110 @@
+# managed-deepagents
+
+Python SDK for the LangSmith Managed Deep Agents API.
+
+Managed Deep Agents is a hosted runtime for creating, running, and operating
+Deep Agents through LangSmith. This package is currently public beta software.
+
+## Installation
+
+```bash
+pip install managed-deepagents
+```
+
+Requirements:
+
+- Python 3.10 or newer
+- A LangSmith API key with access to Managed Deep Agents
+
+## Configuration
+
+The client reads `LANGSMITH_API_KEY` by default.
+
+```bash
+export LANGSMITH_API_KEY="..."
+```
+
+The default API URL is `https://api.smith.langchain.com/v1/deepagents`.
+You can override it with `LANGSMITH_ENDPOINT` or the `api_url` client option.
+
+## Quickstart
+
+```python
+from managed_deepagents import Client
+
+with Client() as client:
+    agent = client.agents.create(
+        name="research-assistant",
+        model="anthropic:claude-sonnet-4-6",
+        instructions="You are a careful research assistant.",
+    )
+
+    thread = client.threads.create(agent_id=agent["id"])
+
+    for event in client.threads.stream(
+        thread["id"],
+        agent_id=agent["id"],
+        messages=[{"role": "user", "content": "Summarize the latest notes."}],
+        stream_mode=["values", "updates", "messages-tuple"],
+    ):
+        print(event.event, event.data)
+```
+
+## Async Usage
+
+```python
+from managed_deepagents import AsyncClient
+
+async with AsyncClient() as client:
+    agent = await client.agents.create(
+        name="research-assistant",
+        model="anthropic:claude-sonnet-4-6",
+        instructions="You are a careful research assistant.",
+    )
+```
+
+## Agent Files
+
+Top-level `files` entries may be passed as raw strings; the SDK normalizes them
+to file entries before sending the request. Use either `instructions` or
+`files["AGENTS.md"]`, not both, because the API maps the typed prompt field to
+`AGENTS.md`.
+
+```python
+agent = client.agents.create(
+    name="research-assistant",
+    files={
+        "AGENTS.md": "You are a careful research assistant.",
+        "skills/research/SKILL.md": "# Research\n\nGather context before answering.",
+    },
+    include_files=True,
+)
+```
+
+## API Surface
+
+Resources exposed by the client:
+
+- `client.agents`: list, create, get, update, delete, clone, health
+- `client.threads`: create, search, count, get, update, delete, create run,
+  invoke, stream, bulk update, resolve interrupt
+- `client.mcp_servers`: create, list, get, update, delete, register OAuth
+  provider
+- `client.auth_sessions`: create and get
+
+## Errors
+
+```python
+from managed_deepagents import ManagedDeepAgentsAPIError
+
+try:
+    client.agents.get("missing-agent")
+except ManagedDeepAgentsAPIError as error:
+    print(error.status_code, error.code, error.detail)
+```
+
+## Links
+
+- Repository: https://github.com/langchain-ai/managed-deepagents-sdk
+- Issues: https://github.com/langchain-ai/managed-deepagents-sdk/issues
+- Changelog: https://github.com/langchain-ai/managed-deepagents-sdk/blob/main/CHANGELOG.md

managed_deepagents-0.1.1/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-0.1.1/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-0.1.1/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-0.1.1/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-0.1.1/managed_deepagents/py.typed

@@ -0,0 +1 @@
+