soothe-deepagents 0.7.16__tar.gz

soothe_deepagents-0.7.16/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: soothe-deepagents
+Version: 0.7.16
+Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
+License: MIT
+Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
+Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
+Project-URL: Repository, https://github.com/mirasoth/soothe-deepagents
+Project-URL: Issues, https://github.com/mirasoth/soothe-deepagents/issues
+Project-URL: Twitter, https://x.com/langchain_oss
+Project-URL: Slack, https://www.langchain.com/join-community
+Project-URL: Reddit, https://www.reddit.com/r/LangChain/
+Keywords: agents,ai,llm,langgraph,langchain,deep-agent,sub-agents,agentic
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4.0,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: langchain<2.0.0,>=1.3.12
+Requires-Dist: langchain-core<2.0.0,>=1.4.9
+Requires-Dist: langchain-anthropic<2.0.0,>=1.4.8
+Requires-Dist: langchain-google-genai<5.0.0,>=4.2.7
+Requires-Dist: langsmith>=0.9.3
+Requires-Dist: wcmatch>=10.1
+Provides-Extra: aws
+Requires-Dist: langchain-aws<2.0.0,>=1.6.2; extra == "aws"
+Provides-Extra: quickjs
+Requires-Dist: langchain-quickjs>=0.3.2; extra == "quickjs"
+Provides-Extra: video
+Requires-Dist: av<18.0.0,>=17.0.0; extra == "video"
+Requires-Dist: pillow<13.0.0,>=10.0.0; extra == "video"
+
+# 🧠🤖 Deep Agents Enhanced by Soothe
+
+[![PyPI - Version](https://img.shields.io/pypi/v/soothe-deepagents?label=%20)](https://pypi.org/project/soothe-deepagents/#history)
+[![PyPI - License](https://img.shields.io/pypi/l/soothe-deepagents)](https://opensource.org/licenses/MIT)
+[![PyPI - Downloads](https://img.shields.io/pepy/dt/soothe-deepagents)](https://pypistats.org/packages/soothe-deepagents)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchain_oss.svg?style=social&label=Follow%20%40LangChain)](https://x.com/langchain_oss)
+
+Looking for the JS/TS version? Check out [Deep Agents.js](https://github.com/langchain-ai/deepagentsjs).
+
+To help you ship LangChain apps to production faster, check out [LangSmith](https://smith.langchain.com).
+LangSmith is a unified developer platform for building, testing, and monitoring LLM applications.
+
+## Quick Install
+
+```bash
+uv add soothe-deepagents
+```
+
+## 🤔 What is this?
+
+Deep Agents is an open source agent harness — an opinionated agent that runs out of the box. Extend, override, or replace any piece.
+
+**Principles:**
+
+- **Opinionated** — defaults tuned for long-horizon, multi-step work
+- **Extensible** — override or replace any piece without forking
+- **Model-agnostic** — works with any LLM that supports tool calling: frontier, open-weight, or local
+- **Production-ready** — built on LangGraph (streaming, persistence, checkpointing) with first-class tracing, evaluation, and deployment via LangSmith
+
+**Features include:**
+
+- **Sub-agents** — delegate tasks to agents with isolated context windows
+- **Filesystem** — read, write, edit, or search over pluggable local, sandboxed, or remote backends
+- **Context management** — summarize long threads and offload tool outputs to disk
+- **Shell access** — run commands in your sandbox of choice
+- **Persistent memory** — pluggable state and store backends for cross-session recall
+- **Human-in-the-loop** — approve, edit, or reject tool calls before they run
+- **Skills** — reusable behaviors the agent can load on demand
+- **Tools** — bring your own functions or any MCP server
+
+```python
+from soothe_deepagents import create_deep_agent
+
+# Legacy imports remain supported:
+# from soothe_deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-5.5",
+    tools=[my_custom_tool],
+    system_prompt="You are a research assistant.",
+)
+result = agent.invoke({"messages": "Research LangGraph and write a summary"})
+```
+
+The agent can plan, read/write files, and manage its own context. Add your own tools, swap models, customize prompts, configure sub-agents, and more. For a full overview and quickstart of Deep Agents, the best resource is our [docs](https://docs.langchain.com/oss/python/deepagents/overview).
+
+**Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.**
+
+## ❓ FAQ
+
+### How is this different from LangGraph or LangChain?
+
+LangGraph is the graph runtime. LangChain's `create_agent` is a minimal agent harness on top of it. Deep Agents is a more opinionated harness on top of `create_agent` — same building blocks, but with filesystem, sub-agents, context management, and skills bundled in. For how the three relate, see the [LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products).
+
+### Does this work with open-weight or local models?
+
+Yes. Any model that supports tool calling works — frontier APIs (OpenAI, Anthropic, Google), open-weight models hosted on providers like Baseten or Fireworks, and self-hosted models via Ollama, vLLM, or llama.cpp. Use any [LangChain chat model](https://docs.langchain.com/oss/python/langchain/models).
+
+### Can I use this in production?
+
+Yes! Deep Agents is built on LangGraph, designed for production agent deployments. Pair it with [LangSmith](https://docs.langchain.com/langsmith/home) for tracing, evaluation, and monitoring. See [Going to production](https://docs.langchain.com/oss/python/deepagents/going-to-production) for the full guide.
+
+### When should I use Deep Agents vs. LangChain or LangGraph directly?
+
+All three are layers in the same stack — see the [LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products) for how they relate. Use **Deep Agents** when you want the full harness — planning, context management, delegation — out of the box. Use [**LangChain's `create_agent`**](https://docs.langchain.com/oss/python/langchain/agents) when you want a lighter harness without the bundled middleware. Drop to [**LangGraph**](https://docs.langchain.com/oss/python/langgraph/overview) when the agent loop itself isn't the right shape and you need a custom graph.
+
+The layers compose: any LangGraph `CompiledStateGraph` can be passed in as a sub-agent to a Deep Agent, so custom orchestration plugs in alongside the harness's defaults.
+
+## 📖 Resources
+
+- **[Documentation](https://docs.langchain.com/oss/python/deepagents)** — Full documentation
+- **[LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products)** — how Deep Agents, LangChain, LangGraph, and LangSmith fit together
+- **[API Reference](https://reference.langchain.com/python/deepagents/)** — Full SDK reference documentation
+- **[Examples](https://github.com/mirasoth/soothe-deepagents/tree/main/examples)** — Working agents and patterns
+- **[Discussions](https://forum.langchain.com/c/oss-product-help-lc-and-lg/deep-agents/18)** — Community forum for technical questions, ideas, and feedback
+- [LangChain Academy](https://academy.langchain.com/) — Comprehensive, free courses on LangChain libraries and products, made by the LangChain team.
+- [Code of Conduct](https://github.com/langchain-ai/langchain/?tab=coc-ov-file) — community guidelines and standards
+
+## 📕 Releases & Versioning
+
+See our [Releases](https://docs.langchain.com/oss/python/release-policy) and [Versioning](https://docs.langchain.com/oss/python/versioning) policies.
+
+## 🔒 Security
+
+Deep Agents follows a "trust the LLM" model. The agent can do anything its tools allow. Enforce boundaries at the tool/sandbox level, not by expecting the model to self-police. See the [security policy](https://github.com/mirasoth/soothe-deepagents?tab=security-ov-file) for more information.
+
+## 💁 Contributing
+
+As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
+
+For detailed information on how to contribute, see the [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview).

soothe_deepagents-0.7.16/README.md

@@ -0,0 +1,101 @@
+# 🧠🤖 Deep Agents Enhanced by Soothe
+
+[![PyPI - Version](https://img.shields.io/pypi/v/soothe-deepagents?label=%20)](https://pypi.org/project/soothe-deepagents/#history)
+[![PyPI - License](https://img.shields.io/pypi/l/soothe-deepagents)](https://opensource.org/licenses/MIT)
+[![PyPI - Downloads](https://img.shields.io/pepy/dt/soothe-deepagents)](https://pypistats.org/packages/soothe-deepagents)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchain_oss.svg?style=social&label=Follow%20%40LangChain)](https://x.com/langchain_oss)
+
+Looking for the JS/TS version? Check out [Deep Agents.js](https://github.com/langchain-ai/deepagentsjs).
+
+To help you ship LangChain apps to production faster, check out [LangSmith](https://smith.langchain.com).
+LangSmith is a unified developer platform for building, testing, and monitoring LLM applications.
+
+## Quick Install
+
+```bash
+uv add soothe-deepagents
+```
+
+## 🤔 What is this?
+
+Deep Agents is an open source agent harness — an opinionated agent that runs out of the box. Extend, override, or replace any piece.
+
+**Principles:**
+
+- **Opinionated** — defaults tuned for long-horizon, multi-step work
+- **Extensible** — override or replace any piece without forking
+- **Model-agnostic** — works with any LLM that supports tool calling: frontier, open-weight, or local
+- **Production-ready** — built on LangGraph (streaming, persistence, checkpointing) with first-class tracing, evaluation, and deployment via LangSmith
+
+**Features include:**
+
+- **Sub-agents** — delegate tasks to agents with isolated context windows
+- **Filesystem** — read, write, edit, or search over pluggable local, sandboxed, or remote backends
+- **Context management** — summarize long threads and offload tool outputs to disk
+- **Shell access** — run commands in your sandbox of choice
+- **Persistent memory** — pluggable state and store backends for cross-session recall
+- **Human-in-the-loop** — approve, edit, or reject tool calls before they run
+- **Skills** — reusable behaviors the agent can load on demand
+- **Tools** — bring your own functions or any MCP server
+
+```python
+from soothe_deepagents import create_deep_agent
+
+# Legacy imports remain supported:
+# from soothe_deepagents import create_deep_agent
+
+agent = create_deep_agent(
+    model="openai:gpt-5.5",
+    tools=[my_custom_tool],
+    system_prompt="You are a research assistant.",
+)
+result = agent.invoke({"messages": "Research LangGraph and write a summary"})
+```
+
+The agent can plan, read/write files, and manage its own context. Add your own tools, swap models, customize prompts, configure sub-agents, and more. For a full overview and quickstart of Deep Agents, the best resource is our [docs](https://docs.langchain.com/oss/python/deepagents/overview).
+
+**Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.**
+
+## ❓ FAQ
+
+### How is this different from LangGraph or LangChain?
+
+LangGraph is the graph runtime. LangChain's `create_agent` is a minimal agent harness on top of it. Deep Agents is a more opinionated harness on top of `create_agent` — same building blocks, but with filesystem, sub-agents, context management, and skills bundled in. For how the three relate, see the [LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products).
+
+### Does this work with open-weight or local models?
+
+Yes. Any model that supports tool calling works — frontier APIs (OpenAI, Anthropic, Google), open-weight models hosted on providers like Baseten or Fireworks, and self-hosted models via Ollama, vLLM, or llama.cpp. Use any [LangChain chat model](https://docs.langchain.com/oss/python/langchain/models).
+
+### Can I use this in production?
+
+Yes! Deep Agents is built on LangGraph, designed for production agent deployments. Pair it with [LangSmith](https://docs.langchain.com/langsmith/home) for tracing, evaluation, and monitoring. See [Going to production](https://docs.langchain.com/oss/python/deepagents/going-to-production) for the full guide.
+
+### When should I use Deep Agents vs. LangChain or LangGraph directly?
+
+All three are layers in the same stack — see the [LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products) for how they relate. Use **Deep Agents** when you want the full harness — planning, context management, delegation — out of the box. Use [**LangChain's `create_agent`**](https://docs.langchain.com/oss/python/langchain/agents) when you want a lighter harness without the bundled middleware. Drop to [**LangGraph**](https://docs.langchain.com/oss/python/langgraph/overview) when the agent loop itself isn't the right shape and you need a custom graph.
+
+The layers compose: any LangGraph `CompiledStateGraph` can be passed in as a sub-agent to a Deep Agent, so custom orchestration plugs in alongside the harness's defaults.
+
+## 📖 Resources
+
+- **[Documentation](https://docs.langchain.com/oss/python/deepagents)** — Full documentation
+- **[LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products)** — how Deep Agents, LangChain, LangGraph, and LangSmith fit together
+- **[API Reference](https://reference.langchain.com/python/deepagents/)** — Full SDK reference documentation
+- **[Examples](https://github.com/mirasoth/soothe-deepagents/tree/main/examples)** — Working agents and patterns
+- **[Discussions](https://forum.langchain.com/c/oss-product-help-lc-and-lg/deep-agents/18)** — Community forum for technical questions, ideas, and feedback
+- [LangChain Academy](https://academy.langchain.com/) — Comprehensive, free courses on LangChain libraries and products, made by the LangChain team.
+- [Code of Conduct](https://github.com/langchain-ai/langchain/?tab=coc-ov-file) — community guidelines and standards
+
+## 📕 Releases & Versioning
+
+See our [Releases](https://docs.langchain.com/oss/python/release-policy) and [Versioning](https://docs.langchain.com/oss/python/versioning) policies.
+
+## 🔒 Security
+
+Deep Agents follows a "trust the LLM" model. The agent can do anything its tools allow. Enforce boundaries at the tool/sandbox level, not by expecting the model to self-police. See the [security policy](https://github.com/mirasoth/soothe-deepagents?tab=security-ov-file) for more information.
+
+## 💁 Contributing
+
+As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
+
+For detailed information on how to contribute, see the [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview).

soothe_deepagents-0.7.16/pyproject.toml

@@ -0,0 +1,174 @@
+[project]
+name = "soothe-deepagents"
+dynamic = ["version"]
+
+description = "General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11,<4.0"
+keywords = ["agents", "ai", "llm", "langgraph", "langchain", "deep-agent", "sub-agents", "agentic"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "langchain>=1.3.12,<2.0.0",
+    "langchain-core>=1.4.9,<2.0.0",
+    "langchain-anthropic>=1.4.8,<2.0.0",
+    "langchain-google-genai>=4.2.7,<5.0.0",
+    "langsmith>=0.9.3",
+    "wcmatch>=10.1",
+]
+
+[project.optional-dependencies]
+aws = ["langchain-aws>=1.6.2,<2.0.0"]
+quickjs = ["langchain-quickjs>=0.3.2"]
+video = ["av>=17.0.0,<18.0.0", "pillow>=10.0.0,<13.0.0"]
+
+[project.urls]
+Homepage = "https://docs.langchain.com/oss/python/deepagents/overview"
+Documentation = "https://reference.langchain.com/python/deepagents/"
+Repository = "https://github.com/mirasoth/soothe-deepagents"
+Issues = "https://github.com/mirasoth/soothe-deepagents/issues"
+Twitter = "https://x.com/langchain_oss"
+Slack = "https://www.langchain.com/join-community"
+Reddit = "https://www.reddit.com/r/LangChain/"
+
+
+[dependency-groups]
+test = [
+  "pytest",
+  "pytest-benchmark",
+  "pytest-codspeed>=5.0.3,<6.0.0",
+  "pytest-cov",
+  "pytest-xdist",
+  "pytest-timeout>=2.4.0,<3.0.0",
+  "pytest-socket",
+  "pytest-watcher>=0.6.3,<1.0.0",
+  "ruff>=0.15.20,<0.16.0",
+  "ty>=0.0.54,<1.0.0",
+  "pytest-asyncio>=1.4.0",
+  "langchain-tests>=1.1.9",
+  "langchain-openai",
+  "twine",
+  "build",
+  # Lazy-imported at runtime so the core package does
+  # not depend on them. ty still sees the import names and
+  # needs stubs, so we install them into the type-checker venv.
+  "av>=17.0.0,<18.0.0",
+  "pillow>=10.0.0,<13.0.0",
+]
+[build-system]
+requires = ["setuptools>=82.0.1", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["soothe_deepagents*"]
+
+[tool.setuptools.package-data]
+"*" = ["py.typed", "*.md"]
+
+[tool.setuptools.dynamic]
+version = { attr = "soothe_deepagents._version.__version__" }
+
+[tool.ruff]
+line-length = 150
+
+[tool.ruff.format]
+docstring-code-format = true  # Formats code blocks in docstrings
+
+[tool.ruff.lint]
+select = [
+    "ALL"  # Enable all rules by default
+]
+ignore = [
+    "COM812",  # Trailing comma missing — conflicts with the ruff formatter
+    "ISC001",  # Implicit string concatenation on one line — conflicts with the ruff formatter
+    "PERF203", # `try`-`except` within a loop — incurs overhead only when exceptions are common
+    "SLF001",  # Access to a private member of an external class
+    "PLR0913", # Too many arguments to function definition
+    "PLC0414", # Import alias does not rename original package — conflicts with type-checker re-export conventions
+]
+unfixable = ["B028"]  # Rules that shouldn't be auto-fixed
+extend-safe-fixes = ["PLR6201"]
+
+[tool.ruff.lint.pyupgrade]
+keep-runtime-typing = true
+
+[tool.ruff.lint.flake8-annotations]
+allow-star-arg-any = true
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.lint.isort]
+force-single-line = false
+combine-as-imports = true
+known-first-party = ["soothe_deepagents"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"  # Google-style docstrings
+ignore-var-parameters = true
+
+[tool.ruff.lint.per-file-ignores]
+# Tests: relax annotations, docstrings, magic values, security, and assertion style
+"tests/**" = [
+    "ANN001",  # Missing type annotation for function argument
+    "ANN201",  # Missing return type annotation for public function
+    "ANN202",  # Missing return type annotation for private function
+    "ARG002",  # Unused method argument — common for pytest fixtures
+    "D1",      # Missing docstrings
+    "PLR2004", # Magic value used in comparison — fine in test assertions
+    "PT018",   # Assertion should be broken down into multiple parts
+    "S101",    # Use of `assert` detected
+    "S311",    # Pseudo-random generator not suitable for security — fine in tests
+]
+# Scripts: allow prints, broad exceptions, and standalone modules
+"scripts/**" = [
+    "BLE001",  # Blind exception catch — resilience in standalone scripts
+    "INP001",  # Missing `__init__.py` — scripts are standalone
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+addopts = "-m 'not benchmark'"
+filterwarnings = [
+    "ignore:Passing `model=None` to `create_deep_agent`:DeprecationWarning",
+    # Tests intentionally exercise the legacy `list[str]` store content format
+    # for backwards-compat coverage; the deprecation fires from internal code.
+    "ignore:Store item with `list\\[str\\]` content is deprecated:DeprecationWarning",
+    # `files_update` is exercised by middleware tests verifying internal handling.
+    "ignore:`files_update` was deprecated:DeprecationWarning",
+    # Legacy `FileData` `list[str]` content shape, exercised for compat coverage.
+    "ignore:`FileData` with `list\\[str\\]` content is deprecated:DeprecationWarning",
+    # Filesystem middleware tests still exercise the factory/runtime backend path.
+    "ignore:Passing a callable \\(factory\\) as `backend` is deprecated:DeprecationWarning",
+    "ignore:Passing `runtime` to `StateBackend` is deprecated:DeprecationWarning",
+    # `virtual_mode` default-change notice; tests assert legacy behavior explicitly.
+    "ignore:`LocalShellBackend` `virtual_mode` default will change:DeprecationWarning",
+    "ignore:`FilesystemBackend` `virtual_mode` default will change:DeprecationWarning",
+    # `langsmith.sandbox` is alpha upstream; the FutureWarning fires on import.
+    "ignore:langsmith.sandbox is in alpha:FutureWarning",
+    # pytest-cov complains when invoked with `--no-cov` (used for fast runs).
+    "ignore::pytest_cov.plugin.CovDisabledWarning",
+]
+markers = [
+    "benchmark: wall-time benchmarks for construction performance",
+]
+
+[tool.ty.environment]
+python-version = "3.11"
+
+[tool.ty.rules]
+# Most rules are enabled by default. Enable rules that are disabled by default:
+division-by-zero = "error"
+# Add rules here to ignore, e.g.:
+# possibly-unresolved-reference = "ignore"

soothe_deepagents-0.7.16/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

soothe_deepagents-0.7.16/soothe_deepagents/__init__.py

@@ -0,0 +1,50 @@
+"""Deep Agents package."""
+
+from soothe_deepagents._version import __version__
+from soothe_deepagents.graph import (
+    DeepAgentState,
+    SystemPromptConfig,
+    create_deep_agent,
+)
+from soothe_deepagents.middleware.async_subagents import AsyncSubAgent, AsyncSubAgentMiddleware
+from soothe_deepagents.middleware.filesystem import FilesystemMiddleware, FilesystemPermission, FsToolName
+from soothe_deepagents.middleware.memory import MemoryMiddleware
+from soothe_deepagents.middleware.rubric import RubricMiddleware
+from soothe_deepagents.middleware.subagents import (
+    CompiledSubAgent,
+    SubAgent,
+    SubAgentMiddleware,
+)
+from soothe_deepagents.profiles.harness.harness_profiles import (
+    GeneralPurposeSubagentProfile,
+    HarnessProfile,
+    HarnessProfileConfig,
+    register_harness_profile,
+)
+from soothe_deepagents.profiles.provider.provider_profiles import (
+    ProviderProfile,
+    register_provider_profile,
+)
+
+__all__ = [
+    "AsyncSubAgent",
+    "AsyncSubAgentMiddleware",
+    "CompiledSubAgent",
+    "DeepAgentState",
+    "FilesystemMiddleware",
+    "FilesystemPermission",
+    "FsToolName",
+    "GeneralPurposeSubagentProfile",
+    "HarnessProfile",
+    "HarnessProfileConfig",
+    "MemoryMiddleware",
+    "ProviderProfile",
+    "RubricMiddleware",
+    "SubAgent",
+    "SubAgentMiddleware",
+    "SystemPromptConfig",
+    "__version__",
+    "create_deep_agent",
+    "register_harness_profile",
+    "register_provider_profile",
+]

soothe_deepagents-0.7.16/soothe_deepagents/_api/__init__.py

@@ -0,0 +1,5 @@
+"""Internal helpers for `soothe_deepagents`.
+
+Modules under this package are private. Their API is allowed to change between
+minor releases without deprecation.
+"""

soothe_deepagents-0.7.16/soothe_deepagents/_api/deprecation.py

@@ -0,0 +1,131 @@
+"""Adapter for `langchain_core`'s private deprecation helpers.
+
+Centralizes the import surface so an upstream rename or move is a one-file
+change.
+
+Re-exports:
+- `deprecated`: decorator for callables, classes, and properties.
+- `warn_deprecated`: helper for parameter/value-level deprecations where the
+    callable itself isn't being deprecated. Wraps the upstream helper to
+    accept a `stacklevel` argument (the upstream version hardcodes
+    `stacklevel=4`, which mis-attributes warnings emitted directly from a
+    deprecated method body).
+- `suppress_langchain_deprecation_warning`: context manager that silences
+    emissions from this module's helpers (use sparingly — it is type-wide).
+- `LangChainDeprecationWarning`: warning class emitted by the helpers above
+    (subclass of `DeprecationWarning`).
+"""
+
+from __future__ import annotations
+
+import warnings
+
+from langchain_core._api.deprecation import (
+    LangChainDeprecationWarning,
+    deprecated,
+    suppress_langchain_deprecation_warning,
+    warn_deprecated as _lc_warn_deprecated,
+)
+
+__all__ = [
+    "LangChainDeprecationWarning",
+    "deprecated",
+    "reset_deprecation_dedupe",
+    "suppress_langchain_deprecation_warning",
+    "warn_deprecated",
+]
+
+
+def warn_deprecated(
+    since: str,
+    *,
+    message: str = "",
+    name: str = "",
+    alternative: str = "",
+    alternative_import: str = "",
+    pending: bool = False,
+    obj_type: str = "",
+    addendum: str = "",
+    removal: str = "",
+    package: str = "",
+    stacklevel: int = 2,
+) -> None:
+    """Emit a deprecation warning with caller-controlled stack attribution.
+
+    `langchain_core.warn_deprecated` formats a standard message but hardcodes
+    `stacklevel=4` in its internal `warnings.warn` call. That value targets a
+    decorator-wrapped frame layout; when called directly from a deprecated
+    method's body the warning is attributed one frame too high (above the
+    user's call site). This wrapper captures the formatted upstream warning
+    and re-emits it with an explicit `stacklevel`, so the warning points at
+    the user's call site.
+
+    Args:
+        since: Release at which this API became deprecated.
+        message: Override the default deprecation message. See upstream
+            `langchain_core.warn_deprecated` for supported format specifiers.
+        name: Name of the deprecated object.
+        alternative: Alternative API the user may use instead.
+        alternative_import: Alternative import path the user may use instead.
+        pending: If `True`, uses a `PendingDeprecationWarning` instead of a
+            `DeprecationWarning`. Cannot be combined with `removal`.
+        obj_type: Object type label (e.g., `"function"`, `"class"`).
+        addendum: Additional text appended to the final message.
+        removal: Expected removal version. Cannot be combined with `pending`.
+        package: Package name attribution for the deprecation message.
+        stacklevel: Frames above this call to attribute the warning to,
+            using the same convention as `warnings.warn` (`1` = this call,
+            `2` = the caller of the method body that invoked us, etc.).
+    """
+    with warnings.catch_warnings(record=True) as captured:
+        warnings.simplefilter("always")
+        _lc_warn_deprecated(
+            since,
+            message=message,
+            name=name,
+            alternative=alternative,
+            alternative_import=alternative_import,
+            pending=pending,
+            obj_type=obj_type,
+            addendum=addendum,
+            removal=removal,
+            package=package,
+        )
+    if not captured:
+        return
+    record = captured[0]
+    warnings.warn(record.message, category=record.category, stacklevel=stacklevel + 1)
+
+
+def reset_deprecation_dedupe(*targets: object) -> None:
+    """Reset the `@deprecated` decorator's dedupe flag for testing.
+
+    The langchain_core `@deprecated` decorator emits each warning at most once
+    per process via a closure-bound `warned` flag. Tests that assert per-call
+    emission must reset that flag between cases — otherwise the assertions
+    become reorder-sensitive (notably under `pytest -n auto`).
+
+    Accepts decorated functions, methods, and `property` objects (in which
+    case the `fget` closure is reset). Targets without the expected `warned`
+    freevar are silently skipped, so passing non-decorated callables is safe.
+
+    Args:
+        *targets: Decorated callables (or properties wrapping them) to reset.
+    """
+    for target in targets:
+        fn = target.fget if isinstance(target, property) else target
+        code = getattr(fn, "__code__", None)
+        closure = getattr(fn, "__closure__", None)
+        if code is None or closure is None:
+            continue
+        try:
+            index = code.co_freevars.index("warned")
+        except ValueError:
+            continue
+        cell = closure[index]
+        try:
+            current = cell.cell_contents
+        except ValueError:  # empty cell
+            continue
+        if isinstance(current, bool):
+            cell.cell_contents = False