managed-deepagents 0.1.3.dev15__py3-none-win_arm64.whl

managed_deepagents/__init__.py

@@ -0,0 +1,158 @@
+"""Managed Deep Agents for the Python ecosystem.
+
+This package provides two things:
+
+* the ``define_deep_agent`` authoring interface (the v0 contract for MDA), and
+* the prebuilt, cross-compiled ``mda`` CLI. Each published wheel bundles the
+  binary for a single platform under ``_binaries/`` and exposes it through the
+  ``mda`` console script.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+__all__ = [
+    "define_deep_agent",
+    "define_sandbox",
+    "DeepAgentDefinition",
+    "SandboxDefinition",
+    "MANAGED_KEYS",
+    "main",
+    "binary_path",
+]
+
+#: Properties the managed runtime owns. Agent authors never set these — MDA
+#: wires the backend, store, and checkpointer at deploy time.
+MANAGED_KEYS = ("backend", "store", "checkpointer")
+
+
+class DeepAgentDefinition:
+    """The pre-runtime spec returned by :func:`define_deep_agent`.
+
+    It is intentionally *not* a compiled graph: the CLI generates an entry
+    module that hands this definition to the managed runtime, which injects the
+    managed backend/store/checkpointer and compiles it into a Deep Agent.
+    """
+
+    kind = "deep-agent"
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        self.config = config
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        keys = ", ".join(sorted(self.config))
+        return f"DeepAgentDefinition({keys})"
+
+
+def define_deep_agent(**config: Any) -> DeepAgentDefinition:
+    """Define a Managed Deep Agent.
+
+    Accepts the full ``create_deep_agent`` keyword surface except the managed
+    keys (``backend``, ``store``, ``checkpointer``, ``system_prompt``) and
+    returns a pre-runtime spec. ``mda deploy`` generates an entry module that
+    hands this definition to the managed runtime, which injects the
+    platform-owned backend/store/checkpointer, embeds the system prompt from
+    ``instructions.md``, and compiles it into a Deep Agent.
+    """
+    if "system_prompt" in config:
+        raise TypeError(
+            "system_prompt is managed by MDA and cannot be set in "
+            "define_deep_agent(...). Write your agent's system prompt in "
+            "instructions.md next to agent.py; the CLI embeds it at deploy time."
+        )
+    managed = [key for key in MANAGED_KEYS if key in config]
+    if managed:
+        raise TypeError(
+            f"{', '.join(managed)} {'is' if len(managed) == 1 else 'are'} owned by "
+            "the managed runtime and cannot be set in define_deep_agent(...). "
+            "Configure the sandbox under sandbox/; the store and checkpointer are "
+            "wired automatically."
+        )
+    return DeepAgentDefinition(config)
+
+
+class SandboxDefinition:
+    """The pre-runtime sandbox spec returned by :func:`define_sandbox`.
+
+    A Managed Deep Agent declares its execution environment in
+    ``sandbox/__init__.py`` by importing a real provider class (such as
+    ``deepagents``' ``LangSmithSandbox``) and passing it to
+    :func:`define_sandbox`. MDA owns how it is *resolved*: construction,
+    run-scoped naming, reuse across turns, the provisioning ``setup.sh``, and
+    lifecycle/TTL.
+    """
+
+    kind = "sandbox"
+
+    #: Option keys MDA owns; ``define_sandbox`` callers must not set these.
+    MANAGED_OPTION_KEYS = ("name", "image", "snapshot", "image_name")
+
+    def __init__(self, provider: Any, options: dict[str, Any]) -> None:
+        self.provider = provider
+        self.options = options
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        name = getattr(self.provider, "__name__", repr(self.provider))
+        return f"SandboxDefinition(provider={name}, options={sorted(self.options)})"
+
+
+def define_sandbox(provider: Any, **options: Any) -> SandboxDefinition:
+    """Declare the managed sandbox provider for a Managed Deep Agent.
+
+    ``provider`` is a sandbox provider class (e.g.
+    ``from deepagents import LangSmithSandbox``). The keyword options are the
+    provider's own ``create(...)`` options, plus the managed reuse/lifecycle
+    knobs ``scope`` (``"thread"`` | ``"tenant"`` | ``"actor"``, default
+    ``"thread"``) and ``idle_ttl_seconds``.
+
+    MDA owns naming, scoping, lifecycle, image/snapshot construction, reuse, the
+    provisioning ``setup.sh``, and cleanup, so image-related keys cannot be set
+    here.
+    """
+    managed = [key for key in SandboxDefinition.MANAGED_OPTION_KEYS if key in options]
+    if managed:
+        raise TypeError(
+            f"{', '.join(managed)} {'is' if len(managed) == 1 else 'are'} owned by "
+            "the managed runtime and cannot be set in define_sandbox(...). MDA "
+            "supplies the sandbox image/snapshot and run-scoped name automatically."
+        )
+    return SandboxDefinition(provider, options)
+
+
+def binary_path() -> Path:
+    """Return the path to the bundled ``mda`` binary for this platform."""
+    name = "mda.exe" if os.name == "nt" else "mda"
+    return Path(__file__).parent / "_binaries" / name
+
+
+def main() -> int:
+    """Entry point for the ``mda`` console script.
+
+    Forwards all arguments to the bundled binary and returns its exit code.
+    """
+    binary = binary_path()
+    if not binary.exists():
+        sys.stderr.write(
+            "managed-deepagents: the prebuilt mda binary was not found in this "
+            "installation. Reinstall the platform-specific wheel.\n"
+        )
+        return 1
+
+    argv = [str(binary), *sys.argv[1:]]
+
+    # On POSIX, replace the current process so signals propagate cleanly.
+    if os.name == "posix":
+        os.execv(str(binary), argv)
+        return 0  # unreachable
+
+    import subprocess
+
+    return subprocess.run(argv).returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

managed_deepagents/__main__.py

@@ -0,0 +1,3 @@
+from . import main
+
+raise SystemExit(main())

managed_deepagents/runtime.py

@@ -0,0 +1,442 @@
+"""Managed runtime seam for compiled Managed Deep Agents.
+
+This module is consumed only by the entry module that ``mda deploy`` generates —
+agent authors never import it directly. It is the point where MDA injects the
+platform-owned backend (the configured sandbox), plus the system prompt embedded
+from ``instructions.md``, and — in a later milestone — the managed store and
+checkpointer.
+"""
+
+from __future__ import annotations
+
+import inspect
+import os
+from dataclasses import dataclass
+from typing import Any
+
+from . import DeepAgentDefinition, SandboxDefinition
+
+__all__ = ["compile_managed_agent", "announce_sandbox_plan"]
+
+#: Absolute path the provisioning script is uploaded to inside the sandbox.
+_SETUP_REMOTE_PATH = "/tmp/mda-setup.sh"
+
+#: Created sandboxes, keyed by scope, reused for the lifetime of this runtime
+#: process. This guarantees ``setup.sh`` runs only once per newly created
+#: sandbox; reused sandboxes (same scope key) skip provisioning entirely.
+_managed_sandboxes: dict[str, Any] = {}
+
+
+def compile_managed_agent(
+    definition: DeepAgentDefinition,
+    config: Any | None = None,
+    *,
+    system_prompt: str | None = None,
+    sandbox: SandboxDefinition | None = None,
+    setup_script: str | None = None,
+) -> Any:
+    """Compile a :class:`DeepAgentDefinition` into a runnable Deep Agent.
+
+    ``system_prompt`` is the text the CLI embedded from ``instructions.md``.
+    ``sandbox`` is the ``sandbox/__init__.py`` declaration, and ``setup_script``
+    is the contents of ``sandbox/setup.sh`` (run once when a sandbox is first
+    provisioned). All are merged here so authors never set them directly.
+
+    The managed store/checkpointer wiring lands in a follow-up milestone; this
+    signature is the stable injection point.
+    """
+    # Imported lazily so the CLI wheel does not require ``deepagents`` at import
+    # time; it is present in the deployed runtime.
+    from deepagents import create_deep_agent
+
+    merged = dict(definition.config)
+    if system_prompt is not None:
+        merged["system_prompt"] = system_prompt
+
+    # TODO(mda): inject the managed store/checkpointer here, scoped by ``config``
+    # identity / thread_id.
+    if sandbox is not None:
+        merged["backend"] = _resolve_managed_sandbox(sandbox, setup_script, config)
+
+    return create_deep_agent(**merged)
+
+
+#: Cache key for the single, process-wide sandbox used under ``mda dev``.
+#:
+#: Deploys key sandboxes per scope (thread/tenant/actor) for isolation. Dev is a
+#: single developer iterating locally, so it shares one sandbox across every
+#: thread: that lets :func:`announce_sandbox_plan` create it eagerly at startup
+#: (to report local-vs-remote and the temp dir up front) and have the first real
+#: run reuse it instead of provisioning a second one.
+_DEV_SANDBOX_SCOPE_KEY = "__mda_dev__"
+
+
+def announce_sandbox_plan(
+    sandbox: SandboxDefinition, setup_script: str | None = None
+) -> None:
+    """Eagerly resolve the ``mda dev`` sandbox at startup so the developer sees
+    the definitive decision — local vs. the configured provider, and the temp
+    dir path when local — right when the dev server boots, not on the first run.
+
+    The generated entry calls this at module load (graph registration); because
+    dev shares one sandbox (:data:`_DEV_SANDBOX_SCOPE_KEY`), the first real run
+    reuses what is created here. The authoritative "created" log (with the temp
+    dir) is emitted by :func:`_create_dev_sandbox`.
+
+    No-op outside ``mda dev``, so the generated entry can always call it.
+    """
+    if not _is_dev_mode():
+        return
+    _resolve_managed_sandbox(sandbox, setup_script, None)
+
+
+def _resolve_managed_sandbox(
+    sandbox: SandboxDefinition,
+    setup_script: str | None,
+    config: Any | None,
+) -> Any:
+    """Resolve (and cache) the scoped sandbox backend, provisioning it with
+    ``setup.sh`` the first time it is created."""
+    key = _DEV_SANDBOX_SCOPE_KEY if _is_dev_mode() else _sandbox_scope_key(sandbox, config)
+    backend = _managed_sandboxes.get(key)
+    if backend is None:
+        backend = _create_managed_sandbox(sandbox, setup_script)
+        _managed_sandboxes[key] = backend
+    return backend
+
+
+def _sandbox_scope_key(sandbox: SandboxDefinition, config: Any | None) -> str:
+    """Derive the reuse key from the run: by thread without identity, or by the
+    configured tenant/actor scope when identity is present."""
+    configurable = {}
+    if isinstance(config, dict):
+        configurable = config.get("configurable") or {}
+    identity = configurable.get("identity") or {}
+    tenant_id = (identity.get("tenant") or {}).get("id")
+    actor_id = (identity.get("actor") or {}).get("id")
+    thread_id = configurable.get("thread_id")
+
+    scope = sandbox.options.get("scope", "thread")
+    if scope == "tenant":
+        key = tenant_id
+    elif scope == "actor":
+        key = actor_id
+    else:
+        key = thread_id
+
+    return key or tenant_id or actor_id or thread_id or "default"
+
+
+def _create_managed_sandbox(sandbox: SandboxDefinition, setup_script: str | None) -> Any:
+    # ``mda dev`` never provisions a real provider sandbox the way a deploy does
+    # (it builds no snapshot/image), so it gets its own resolution path with a
+    # local fallback. The flag gating ensures a real deployment can never be
+    # silently downgraded to local shell execution.
+    if _is_dev_mode():
+        return _create_dev_sandbox(sandbox, setup_script)
+    return _create_provider_sandbox(sandbox, setup_script)
+
+
+def _create_provider_sandbox(
+    sandbox: SandboxDefinition, setup_script: str | None
+) -> Any:
+    """Production path: build the configured provider's sandbox and provision it.
+
+    Any failure propagates — a misconfigured deployment must surface, not
+    silently degrade to local shell execution.
+    """
+    # Strip MDA-managed knobs before handing the rest to the provider factory.
+    provider_options = {
+        key: value
+        for key, value in sandbox.options.items()
+        if key not in ("scope", "idle_ttl_seconds")
+    }
+
+    backend = _construct_sandbox_backend(sandbox.provider, provider_options)
+
+    if setup_script and setup_script.strip():
+        _run_setup_script(backend, setup_script)
+
+    return backend
+
+
+def _create_dev_sandbox(sandbox: SandboxDefinition, setup_script: str | None) -> Any:
+    """Dev path: prefer the configured provider when its credentials are present,
+    but fall back to a local temp-directory sandbox when credentials are missing
+    *or* the provider cannot be created (e.g. ``LangSmithSandbox``, which needs a
+    snapshot that only ``mda deploy`` builds). This keeps ``mda dev`` working
+    offline and resilient to provider/config gaps while still exercising real
+    providers that can spin up from an API key alone.
+    """
+    cred = _provider_credential_status(sandbox.provider)
+
+    if cred.status != "missing":
+        try:
+            backend = _create_provider_sandbox(sandbox, setup_script)
+            if cred.status == "available":
+                _log_dev_sandbox_once(
+                    f"[mda dev] using the configured {cred.provider} sandbox."
+                )
+            else:
+                _log_dev_sandbox_once(
+                    "[mda dev] using the configured sandbox provider "
+                    f"({cred.provider})."
+                )
+            return backend
+        except Exception as error:  # noqa: BLE001 - dev fallback is intentional
+            return _create_local_sandbox(
+                setup_script,
+                f"the configured {cred.provider} sandbox could not be created "
+                f"({error}); using a local temporary directory instead",
+            )
+
+    missing = ", ".join(cred.missing) or "the provider credentials"
+    return _create_local_sandbox(
+        setup_script,
+        "no credentials found for the configured sandbox provider "
+        f"({cred.provider}); using a local temporary directory instead — set "
+        f"{missing} to use it",
+    )
+
+
+def _create_local_sandbox(setup_script: str | None, reason: str) -> Any:
+    """Provision the local dev sandbox and run ``setup.sh`` inline inside it."""
+    backend = _create_local_dev_sandbox(reason)
+    if setup_script and setup_script.strip():
+        # Run the script inline rather than uploading it first: the local backend
+        # virtualizes file paths (uploads land under the temp root) but executes
+        # shell commands against the real filesystem, so an uploaded
+        # ``/tmp/mda-setup.sh`` would not be found by ``bash``. Executed inline,
+        # it runs with the temp root as its working directory.
+        _assert_setup_succeeded(_await_if_needed(backend.execute(setup_script)))
+    return backend
+
+
+#: Guards the one-time dev sandbox notice so it logs at most once per process.
+#:
+#: ``_create_managed_sandbox`` runs once per sandbox *scope key*
+#: (thread/tenant/actor), not once per process. The ``mda dev`` LangGraph server
+#: is long-lived and serves many threads, so each new thread misses the
+#: ``_managed_sandboxes`` cache and provisions a fresh sandbox — without this
+#: guard the banner would reprint on the first turn of every new thread. The
+#: message is session-level context, so once is enough.
+_logged_dev_sandbox_notice = False
+
+
+def _is_dev_mode() -> bool:
+    """Whether MDA is running under ``mda dev``.
+
+    The CLI sets ``MDA_DEV`` when it launches the local LangGraph dev server; it
+    is never set for ``mda deploy``.
+    """
+    return bool(os.environ.get("MDA_DEV"))
+
+
+#: Per-provider environment variables MDA expects to hold the credentials each
+#: sandbox provider needs. Keyed by the provider's ``provider_id`` (when set) or
+#: its class name.
+#:
+#: The value is a list of alternative credential *sets*: a provider is
+#: considered credentialed if **every** variable in **any one** set is present.
+#: An empty list means the provider needs no credentials (e.g. it runs locally).
+#:
+#: Sources: the deepagents sandbox docs and each provider's own SDK docs.
+#: - LangSmith: https://docs.langchain.com/langsmith/sandboxes
+#: - Daytona / E2B / Modal / Runloop / Vercel / AgentCore: provider SDK docs.
+_PROVIDER_CREDENTIAL_ENV_VARS: dict[str, list[list[str]]] = {
+    # LangSmith managed sandboxes.
+    "LangSmithSandbox": [["LANGSMITH_API_KEY"]],
+    # Daytona (``langchain-daytona`` / deepagents ``DaytonaSandbox``).
+    "DaytonaSandbox": [["DAYTONA_API_KEY"]],
+    # E2B (``langchain-e2b`` / deepagents ``E2BSandbox``).
+    "E2BSandbox": [["E2B_API_KEY"]],
+    # Modal requires both a token id and secret.
+    "ModalSandbox": [["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]],
+    # Runloop devboxes.
+    "RunloopSandbox": [["RUNLOOP_API_KEY"]],
+    # Vercel: either an OIDC token, or an access token + team + project ids.
+    "VercelSandbox": [
+        ["VERCEL_OIDC_TOKEN"],
+        ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"],
+    ],
+    # AWS Bedrock AgentCore: standard AWS credential resolution.
+    "AgentCoreSandbox": [
+        ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
+        ["AWS_PROFILE"],
+    ],
+}
+
+
+@dataclass(frozen=True)
+class _ProviderCredentialStatus:
+    #: One of ``"available"`` (credentials present or none needed),
+    #: ``"missing"`` (a known provider's credentials are absent), or
+    #: ``"unknown"`` (provider not in ``_PROVIDER_CREDENTIAL_ENV_VARS``).
+    status: str
+    #: The provider id / class name used for the lookup.
+    provider: str
+    #: Env vars from the primary credential set, surfaced when ``missing``.
+    missing: tuple[str, ...] = ()
+
+
+def _provider_key(provider: Any) -> str:
+    """Resolve the lookup key for a sandbox provider (its id, else class name)."""
+    provider_id = getattr(provider, "provider_id", None) or getattr(
+        provider, "providerId", None
+    )
+    if isinstance(provider_id, str) and provider_id.strip():
+        return provider_id.strip()
+    name = getattr(provider, "__name__", None) or type(provider).__name__
+    return str(name).strip()
+
+
+def _credential_set_satisfied(env_vars: list[str]) -> bool:
+    """Whether every variable in a credential set is set and non-empty."""
+    return all((os.environ.get(name) or "").strip() for name in env_vars)
+
+
+def _provider_credential_status(provider: Any) -> _ProviderCredentialStatus:
+    """Determine whether the configured provider's credentials are available.
+
+    Lets ``mda dev`` choose between the real provider and the local fallback.
+    """
+    key = _provider_key(provider)
+    sets = _PROVIDER_CREDENTIAL_ENV_VARS.get(key)
+    if sets is None:
+        return _ProviderCredentialStatus("unknown", key or "unknown")
+    if not sets or any(_credential_set_satisfied(s) for s in sets):
+        return _ProviderCredentialStatus("available", key)
+    return _ProviderCredentialStatus("missing", key, tuple(sets[0]))
+
+
+def _create_local_dev_sandbox(reason: str) -> Any:
+    """Provision a local, throwaway sandbox rooted at a fresh OS temp directory.
+
+    Uses ``deepagents``' ``LocalShellBackend``, which runs commands and file
+    operations against the host within the temp dir — no remote sandbox, no
+    credentials, no network. Intended only for ``mda dev``.
+
+    ``reason`` explains *why* the local sandbox is being used (missing
+    credentials, provider creation failure, …) and is logged once alongside the
+    temp dir path.
+    """
+    import tempfile
+
+    from deepagents import LocalShellBackend
+
+    root_dir = tempfile.mkdtemp(prefix="mda-dev-sandbox-")
+    _log_dev_sandbox_once(f"[mda dev] {reason}:\n  {root_dir}")
+
+    return LocalShellBackend(root_dir, virtual_mode=True, inherit_env=True)
+
+
+def _log_dev_sandbox_once(message: str) -> None:
+    """Emit a dev sandbox notice at most once per process.
+
+    See ``_logged_dev_sandbox_notice`` for why the dedupe matters: the notice is
+    reached once per sandbox scope key, and the dev server serves many threads.
+    """
+    global _logged_dev_sandbox_notice
+    if _logged_dev_sandbox_notice:
+        return
+    _logged_dev_sandbox_notice = True
+    print(message)
+
+
+def _construct_sandbox_backend(provider: Any, options: dict[str, Any]) -> Any:
+    """Construct the provider's sandbox backend.
+
+    Providers that expose a ``create(...)`` factory (the contract the TypeScript
+    SDK relies on, and the forward-compatible path for ``deepagents``) are used
+    directly. Otherwise, MDA falls back to building a LangSmith sandbox and
+    wrapping it with the provider class — the shape of today's
+    ``deepagents.LangSmithSandbox(sandbox=...)``.
+    """
+    create = getattr(provider, "create", None)
+    if callable(create):
+        result = create(**options)
+        return _await_if_needed(result)
+
+    return _wrap_langsmith_sandbox(provider, options)
+
+
+def _wrap_langsmith_sandbox(provider: Any, options: dict[str, Any]) -> Any:
+    """Build a LangSmith sandbox and wrap it with ``provider``.
+
+    Used when the provider has no ``create(...)`` factory, which is the case for
+    the current ``deepagents.LangSmithSandbox`` whose constructor wraps an
+    existing ``langsmith.sandbox.Sandbox``.
+    """
+    try:
+        from langsmith.sandbox import SandboxClient
+    except ImportError as error:  # pragma: no cover - depends on runtime deps
+        raise RuntimeError(
+            "The configured sandbox provider does not expose a create(...) "
+            "factory and LangSmith is not installed, so MDA cannot construct it. "
+            "Install `langsmith` with sandbox support or use a provider that "
+            "exposes `create(...)`."
+        ) from error
+
+    # Pass through only the options the LangSmith sandbox lifecycle understands;
+    # `default_timeout` is applied to the backend wrapper below, not the sandbox.
+    create_kwargs: dict[str, Any] = {}
+    if "idle_ttl_seconds" in options:
+        create_kwargs["idle_ttl_seconds"] = options["idle_ttl_seconds"]
+    if "snapshot_id" in options:
+        create_kwargs["snapshot_id"] = options["snapshot_id"]
+
+    client = SandboxClient()
+    sandbox = client.create_sandbox(**create_kwargs)
+    backend = provider(sandbox)
+
+    default_timeout = options.get("default_timeout")
+    if default_timeout is not None and hasattr(backend, "_default_timeout"):
+        backend._default_timeout = default_timeout  # noqa: SLF001
+
+    return backend
+
+
+def _run_setup_script(backend: Any, script: str) -> None:
+    """Provision a freshly created sandbox by running ``setup.sh`` inside it."""
+    upload_files = getattr(backend, "upload_files", None)
+    if callable(upload_files):
+        _await_if_needed(upload_files([(_SETUP_REMOTE_PATH, script.encode("utf-8"))]))
+        result = _await_if_needed(backend.execute(f"bash {_SETUP_REMOTE_PATH}"))
+    else:
+        result = _await_if_needed(backend.execute(script))
+
+    _assert_setup_succeeded(result)
+
+
+def _assert_setup_succeeded(result: Any) -> None:
+    exit_code = getattr(result, "exit_code", None)
+    if isinstance(exit_code, int) and exit_code != 0:
+        detail = (getattr(result, "output", "") or "").strip()
+        message = f"sandbox setup.sh failed with exit code {exit_code}"
+        if detail:
+            message = f"{message}: {detail}"
+        raise RuntimeError(message)
+
+
+def _await_if_needed(value: Any) -> Any:
+    """Resolve a value that may be awaitable.
+
+    The compiled Python entry runs synchronously, so if a provider returns a
+    coroutine we drive it to completion on a private event loop.
+    """
+    if not inspect.isawaitable(value):
+        return value
+
+    import asyncio
+
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(value)
+
+    # Already inside a running loop: run the coroutine on a dedicated loop in a
+    # worker thread so we don't deadlock the caller's loop.
+    import concurrent.futures
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(asyncio.run, value).result()

managed_deepagents-0.1.3.dev15.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: managed-deepagents
+Version: 0.1.3.dev15
+Summary: Managed Deep Agents — the define_deep_agent authoring interface plus the CLI that compiles and deploys a code-first Deep Agent repository to a managed LangGraph runtime.
+Author: LangChain
+License: MIT
+Project-URL: Homepage, https://github.com/langchain-ai/managed-deepagents-sdk
+Project-URL: Repository, https://github.com/langchain-ai/managed-deepagents-sdk
+Keywords: langchain,langgraph,deepagents,agents,cli
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
+<!-- markdownlint-disable MD033 MD041 -->
+
+<div align="center">
+  <a href="https://www.langchain.com/langsmith-managed-deep-agents-waitlist">
+    <img alt="Managed Deep Agents logo" src="https://raw.githubusercontent.com/langchain-ai/managed-deepagents-sdk/main/.github/assets/logo.png" width="70%">
+  </a>
+</div>
+
+<div align="center">
+  <h3>Python authoring package and CLI launcher for Managed Deep Agents.</h3>
+</div>
+
+> [!IMPORTANT]
+> **Active development / private beta.** Managed Deep Agents is in active
+> development and currently in private beta. The PyPI package API and managed
+> runtime contract may change. [Join the
+> waitlist](https://www.langchain.com/langsmith-managed-deep-agents-waitlist)
+> for access and updates.
+
+`managed-deepagents` is the PyPI package for authoring Managed Deep Agents in
+Python. It includes:
+
+- `define_deep_agent`, the Python authoring contract for managed agents.
+- `mda`, the CLI used to build and deploy your agent to LangSmith.
+- `managed_deepagents.runtime`, the runtime helper used by generated managed
+  entry modules.
+
+## Install
+
+```bash
+pip install managed-deepagents
+```
+
+> [!NOTE]
+> **Private beta: dev releases only.** We currently publish only PEP 440
+> pre-release (dev) versions and no stable version yet. pip skips pre-releases
+> by default, so install with `--pre`:
+>
+> ```bash
+> pip install --pre managed-deepagents
+> ```
+
+This package requires Python 3.9 or newer. Each platform wheel bundles the
+prebuilt `mda` binary for its OS and CPU architecture and exposes it through the
+`mda` console script.
+
+## Define an Agent
+
+Create an `agent.py` that defines an `agent`:
+
+```python
+from pathlib import Path
+
+from managed_deepagents import define_deep_agent
+
+instructions = Path("instructions.md").read_text()
+
+agent = define_deep_agent(
+    model="openai:gpt-5.5",
+    system_prompt=instructions,
+    tools=[query_db],
+)
+```
+
+`define_deep_agent` accepts the `create_deep_agent` keyword surface minus the
+managed keys: `backend`, `store`, and `checkpointer`. Those are provided by the
+managed runtime when your agent is deployed.
+
+## Project Shape
+
+```text
+my-agent/
+  agent.py
+  instructions.md
+  tools/
+  middleware/
+  skills/
+```
+
+The CLI copies your project files into the managed build and generates the entry
+module that connects your definition to the hosted runtime.
+
+## CLI
+
+Build locally:
+
+```bash
+mda build ./my-agent
+```
+
+Deploy to LangSmith:
+
+```bash
+mda deploy ./my-agent
+```
+
+The generated build is written to `<root>/.mda/build` by default.

managed_deepagents-0.1.3.dev15.dist-info/RECORD

@@ -0,0 +1,10 @@
+managed_deepagents/__init__.py,sha256=m6twfLrHeO14y9-x5W4HQ5C92duYG3JJpHRliyKwmks,5737
+managed_deepagents/__main__.py,sha256=BHLi_-4Bx1gsZn-z6x7wECPn1YTxdc74y0deRea9FzY,45
+managed_deepagents/runtime.py,sha256=GDTC0-QAa5q6YrJBlj4V3v_naerRLgNiznXWxTCRLWk,17900
+managed_deepagents/_binaries/mda,sha256=JvwHPx6G2MHgD6CjJMOfcKJwIzBt9gU0d6CLYLxuo1E,3200208
+managed_deepagents/_binaries/mda.exe,sha256=imV_avbhmIbcQqxptTffjlW9c9NngNQ2OAhxEHH7REc,2435072
+managed_deepagents-0.1.3.dev15.dist-info/METADATA,sha256=s-8Szgz151_o7XYgOF56JV2N8ep3of4znBlzI5q8PjI,3272
+managed_deepagents-0.1.3.dev15.dist-info/WHEEL,sha256=84gBEa4fGSDR6CJj9KMeLIZ46AIp14gh61YGBn-qQNM,97
+managed_deepagents-0.1.3.dev15.dist-info/entry_points.txt,sha256=Z7JjAzLk9VYdYVvN9xdG91cZ1-pCHj3GFfSRiT0SObw,48
+managed_deepagents-0.1.3.dev15.dist-info/top_level.txt,sha256=fdBo4O0Hlol_w022tTLB5ftZpamb4yJoQ3MUvjgTGfA,19
+managed_deepagents-0.1.3.dev15.dist-info/RECORD,,

managed_deepagents-0.1.3.dev15.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-win_arm64
+

managed_deepagents-0.1.3.dev15.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mda = managed_deepagents:main

managed_deepagents-0.1.3.dev15.dist-info/top_level.txt

@@ -0,0 +1 @@
+managed_deepagents