contexory-sdk 0.1.0__tar.gz

contexory_sdk-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+.pytest_cache/
+.ruff_cache/
+.coverage
+*.egg-info/
+dist/

contexory_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Contexory
+
+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.

contexory_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.5
+Name: contexory-sdk
+Version: 0.1.0
+Summary: Resolve a Contexory agent's released context at runtime: cached, signature-verified, and safe when Contexory is unreachable.
+Project-URL: Homepage, https://github.com/wedgey/contexory/tree/main/packages/sdk-python#readme
+Project-URL: Repository, https://github.com/wedgey/contexory
+License: MIT
+License-File: LICENSE
+Keywords: agent-skills,ai-agents,claude-agent-sdk,contexory,langchain,prompt-management,pydantic-ai
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=42
+Provides-Extra: claude-agent-sdk
+Requires-Dist: claude-agent-sdk>=0.1; extra == 'claude-agent-sdk'
+Provides-Extra: dev
+Requires-Dist: claude-agent-sdk>=0.1; extra == 'dev'
+Requires-Dist: langchain>=1.0; extra == 'dev'
+Requires-Dist: opentelemetry-api>=1.25; extra == 'dev'
+Requires-Dist: opentelemetry-sdk>=1.25; extra == 'dev'
+Requires-Dist: pydantic-ai-slim>=1.0; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain>=1.0; extra == 'langchain'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.25; extra == 'otel'
+Requires-Dist: opentelemetry-sdk>=1.25; extra == 'otel'
+Provides-Extra: pydantic-ai
+Requires-Dist: pydantic-ai-slim>=1.0; extra == 'pydantic-ai'
+Description-Content-Type: text/markdown
+
+# contexory-sdk (Python)
+
+Resolve a Contexory agent's released context at runtime: the system prompt, skills and tool
+descriptions under a label such as `production`. Cached, signature-verified, and safe when Contexory is
+unreachable. It is the Python twin of [`@contexory/sdk`](../sdk): same wire format, same cache layout,
+same failure rules, and a shared parity suite that fails if they drift.
+
+```bash
+pip install contexory-sdk                     # resolve + apply_tools
+pip install 'contexory-sdk[otel]'             # instrument()
+pip install 'contexory-sdk[langchain]'        # + adapters, per framework
+```
+
+Python 3.10 or newer. The only hard dependency is `cryptography`, for Ed25519.
+
+## resolve
+
+```python
+from contexory import Contexory
+
+contexory = Contexory()  # CONTEXORY_API_TOKEN holds a con_rt_ runtime key
+ctx = contexory.resolve("support-agent")  # label defaults to "production"
+
+system = ctx.system
+ctx.release.number  # 43
+ctx.source  # "network" | "cache" | "stale-cache"
+ctx.stale  # True when Contexory failed and this is the last verified release
+```
+
+`await contexory.aresolve(...)` runs the same call off the event loop.
+
+- Every response is verified with Ed25519 against the keys at `/api/v1/signing-keys`. A bad or missing
+  signature raises `ContexorySignatureError` and never falls back to the cache.
+- A refusal (401, 403, 404) raises `ContexoryResolveError` with `.status`. Any other failure serves the
+  last verified release and sets `ctx.stale` and `ctx.error`; with nothing cached it raises.
+- Releases are cached on disk (`CONTEXORY_CACHE_DIR`, default `~/.cache/contexory/sdk`) for `ttl_ms`
+  (60s), then revalidated with `If-None-Match`. The layout is byte-compatible with the TypeScript SDK's.
+- Missing key: `resolve` raises immediately. The TypeScript SDK would serve a cache written under the same
+  empty key; there is no such cache to serve.
+
+## apply_tools
+
+```python
+tools = ctx.apply_tools(my_tools)  # dict keyed by name, or list of tools
+tools = ctx.apply_tools(my_tools, renames={"refund": "issue_refund"})
+ctx.original_tool_name("issue_refund")  # "refund"
+```
+
+Tools may be dicts, dataclasses, Pydantic models or plain objects with `name`/`description`. Hosted tools
+(no `description`) pass through untouched.
+
+## Upstream MCP descriptions
+
+A toolset override can be pinned to the MCP server it overrides (`upstream: {server, hash}` in `tools.json`).
+`apply_tools` then applies it only while the server's description still hashes to the one Contexory
+accepted; otherwise the server's own text stands and the tool is listed in `held` (`ctx.held` after
+`ctx.apply_tools`).
+
+```python
+from contexory import watch_mcp_tools
+
+watch = watch_mcp_tools(
+    server="zendesk",  # the name the toolset uses in upstream.server
+    list_tools=lambda: {"tools": mcp.list_tools(), "ttlMs": None},  # your MCP client's tools/list
+    report={"ingest_key": "con_ing_...", "agent": "support-agent", "release": ctx.release.number},
+)
+watch.start()  # polls on the server's ttlMs, clamped to 5s..1h (default 5min)
+tools = ctx.apply_tools(my_tools, upstream_hashes=watch.latest())
+```
+
+`hash_mcp_tools`, `mcp_tools_hash`, `description_hash`, `schema_hash` and `canonical_json` are the same
+hashes the server and the TypeScript SDK compute, held to `packages/shared/src/mcp-upstream/vectors.json`.
+`report_upstream_hashes` posts with a write-only `con_ing_` ingest key, never a runtime key.
+
+## instrument
+
+```python
+from opentelemetry.sdk.trace import TracerProvider
+from contexory import instrument
+
+handle = instrument(ctx)  # or instrument(43), instrument("r43")
+provider = TracerProvider()
+provider.add_span_processor(handle.processor)
+
+with handle.run_with_release(44):  # per-request scope; concurrent scopes never cross
+    ...
+```
+
+Stamps `gen_ai.agent.version` and the Langfuse, LangSmith and Braintrust metadata attributes on every
+span. `vendors=[]` writes only `gen_ai.agent.version`; `baggage=True` carries the scope in W3C baggage.
+
+## Adapters
+
+| Framework | Use |
+|---|---|
+| LangChain / LangGraph | `create_agent(model, tools, middleware=[ContexoryMiddleware(ctx)])` from `contexory.adapters.langchain`; implements `wrap_model_call`. `apply_system=True` also swaps in the released system prompt |
+| Pydantic AI | `Agent(model, prepare_tools=prepare_tools(ctx))` from `contexory.adapters.pydantic_ai`; descriptions only |
+| Claude Agent SDK | `create_proxy_server(ctx, upstream_tools)` from `contexory.adapters.claude_agent_sdk` returns an in-process MCP server that re-exposes external tools with the released descriptions and forwards calls. Pass it in `mcp_servers` and disallow the originals; the model sees `mcp__contexory__<tool>` |
+
+## Develop
+
+```bash
+cd packages/sdk-python
+python -m venv .venv && . .venv/bin/activate
+pip install -e '.[dev]'
+ruff check . && ruff format --check . && pytest
+```
+
+`parity/fixtures.json` is generated by the TypeScript SDK (`UPDATE_PARITY=1 pnpm exec vitest run --project
+sdk-python`) and replayed by `tests/test_parity.py`. Change `parity/cases.ts`, regenerate, and both suites
+must pass. `pnpm test` runs the TypeScript half.
+
+## Releasing
+
+Releases go to PyPI as `contexory-sdk` through trusted publishing (OIDC): no token exists. The
+`publish` job in `.github/workflows/sdk-python.yml` runs only for a pushed `sdk-python-v*` tag, after
+the test matrix and build pass.
+
+1. Bump `version` in `pyproject.toml` and merge it to `main`.
+2. Tag that commit and push the tag. The tag must equal the version, or the job fails:
+
+```bash
+git tag sdk-python-v0.1.0 && git push origin sdk-python-v0.1.0
+```
+
+One-time setup (pending trusted publisher on PyPI, GitHub environment `pypi`):
+[`docs/RELEASING.md`](../../docs/RELEASING.md#python-sdk-pypi).

contexory_sdk-0.1.0/README.md

@@ -0,0 +1,127 @@
+# contexory-sdk (Python)
+
+Resolve a Contexory agent's released context at runtime: the system prompt, skills and tool
+descriptions under a label such as `production`. Cached, signature-verified, and safe when Contexory is
+unreachable. It is the Python twin of [`@contexory/sdk`](../sdk): same wire format, same cache layout,
+same failure rules, and a shared parity suite that fails if they drift.
+
+```bash
+pip install contexory-sdk                     # resolve + apply_tools
+pip install 'contexory-sdk[otel]'             # instrument()
+pip install 'contexory-sdk[langchain]'        # + adapters, per framework
+```
+
+Python 3.10 or newer. The only hard dependency is `cryptography`, for Ed25519.
+
+## resolve
+
+```python
+from contexory import Contexory
+
+contexory = Contexory()  # CONTEXORY_API_TOKEN holds a con_rt_ runtime key
+ctx = contexory.resolve("support-agent")  # label defaults to "production"
+
+system = ctx.system
+ctx.release.number  # 43
+ctx.source  # "network" | "cache" | "stale-cache"
+ctx.stale  # True when Contexory failed and this is the last verified release
+```
+
+`await contexory.aresolve(...)` runs the same call off the event loop.
+
+- Every response is verified with Ed25519 against the keys at `/api/v1/signing-keys`. A bad or missing
+  signature raises `ContexorySignatureError` and never falls back to the cache.
+- A refusal (401, 403, 404) raises `ContexoryResolveError` with `.status`. Any other failure serves the
+  last verified release and sets `ctx.stale` and `ctx.error`; with nothing cached it raises.
+- Releases are cached on disk (`CONTEXORY_CACHE_DIR`, default `~/.cache/contexory/sdk`) for `ttl_ms`
+  (60s), then revalidated with `If-None-Match`. The layout is byte-compatible with the TypeScript SDK's.
+- Missing key: `resolve` raises immediately. The TypeScript SDK would serve a cache written under the same
+  empty key; there is no such cache to serve.
+
+## apply_tools
+
+```python
+tools = ctx.apply_tools(my_tools)  # dict keyed by name, or list of tools
+tools = ctx.apply_tools(my_tools, renames={"refund": "issue_refund"})
+ctx.original_tool_name("issue_refund")  # "refund"
+```
+
+Tools may be dicts, dataclasses, Pydantic models or plain objects with `name`/`description`. Hosted tools
+(no `description`) pass through untouched.
+
+## Upstream MCP descriptions
+
+A toolset override can be pinned to the MCP server it overrides (`upstream: {server, hash}` in `tools.json`).
+`apply_tools` then applies it only while the server's description still hashes to the one Contexory
+accepted; otherwise the server's own text stands and the tool is listed in `held` (`ctx.held` after
+`ctx.apply_tools`).
+
+```python
+from contexory import watch_mcp_tools
+
+watch = watch_mcp_tools(
+    server="zendesk",  # the name the toolset uses in upstream.server
+    list_tools=lambda: {"tools": mcp.list_tools(), "ttlMs": None},  # your MCP client's tools/list
+    report={"ingest_key": "con_ing_...", "agent": "support-agent", "release": ctx.release.number},
+)
+watch.start()  # polls on the server's ttlMs, clamped to 5s..1h (default 5min)
+tools = ctx.apply_tools(my_tools, upstream_hashes=watch.latest())
+```
+
+`hash_mcp_tools`, `mcp_tools_hash`, `description_hash`, `schema_hash` and `canonical_json` are the same
+hashes the server and the TypeScript SDK compute, held to `packages/shared/src/mcp-upstream/vectors.json`.
+`report_upstream_hashes` posts with a write-only `con_ing_` ingest key, never a runtime key.
+
+## instrument
+
+```python
+from opentelemetry.sdk.trace import TracerProvider
+from contexory import instrument
+
+handle = instrument(ctx)  # or instrument(43), instrument("r43")
+provider = TracerProvider()
+provider.add_span_processor(handle.processor)
+
+with handle.run_with_release(44):  # per-request scope; concurrent scopes never cross
+    ...
+```
+
+Stamps `gen_ai.agent.version` and the Langfuse, LangSmith and Braintrust metadata attributes on every
+span. `vendors=[]` writes only `gen_ai.agent.version`; `baggage=True` carries the scope in W3C baggage.
+
+## Adapters
+
+| Framework | Use |
+|---|---|
+| LangChain / LangGraph | `create_agent(model, tools, middleware=[ContexoryMiddleware(ctx)])` from `contexory.adapters.langchain`; implements `wrap_model_call`. `apply_system=True` also swaps in the released system prompt |
+| Pydantic AI | `Agent(model, prepare_tools=prepare_tools(ctx))` from `contexory.adapters.pydantic_ai`; descriptions only |
+| Claude Agent SDK | `create_proxy_server(ctx, upstream_tools)` from `contexory.adapters.claude_agent_sdk` returns an in-process MCP server that re-exposes external tools with the released descriptions and forwards calls. Pass it in `mcp_servers` and disallow the originals; the model sees `mcp__contexory__<tool>` |
+
+## Develop
+
+```bash
+cd packages/sdk-python
+python -m venv .venv && . .venv/bin/activate
+pip install -e '.[dev]'
+ruff check . && ruff format --check . && pytest
+```
+
+`parity/fixtures.json` is generated by the TypeScript SDK (`UPDATE_PARITY=1 pnpm exec vitest run --project
+sdk-python`) and replayed by `tests/test_parity.py`. Change `parity/cases.ts`, regenerate, and both suites
+must pass. `pnpm test` runs the TypeScript half.
+
+## Releasing
+
+Releases go to PyPI as `contexory-sdk` through trusted publishing (OIDC): no token exists. The
+`publish` job in `.github/workflows/sdk-python.yml` runs only for a pushed `sdk-python-v*` tag, after
+the test matrix and build pass.
+
+1. Bump `version` in `pyproject.toml` and merge it to `main`.
+2. Tag that commit and push the tag. The tag must equal the version, or the job fails:
+
+```bash
+git tag sdk-python-v0.1.0 && git push origin sdk-python-v0.1.0
+```
+
+One-time setup (pending trusted publisher on PyPI, GitHub environment `pypi`):
+[`docs/RELEASING.md`](../../docs/RELEASING.md#python-sdk-pypi).

contexory_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "contexory-sdk"
+version = "0.1.0"
+description = "Resolve a Contexory agent's released context at runtime: cached, signature-verified, and safe when Contexory is unreachable."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["contexory", "ai-agents", "agent-skills", "prompt-management", "langchain", "pydantic-ai", "claude-agent-sdk"]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Typing :: Typed",
+]
+dependencies = ["cryptography>=42"]
+
+[project.urls]
+Homepage = "https://github.com/wedgey/contexory/tree/main/packages/sdk-python#readme"
+Repository = "https://github.com/wedgey/contexory"
+
+[project.optional-dependencies]
+otel = ["opentelemetry-api>=1.25", "opentelemetry-sdk>=1.25"]
+langchain = ["langchain>=1.0"]
+pydantic-ai = ["pydantic-ai-slim>=1.0"]
+claude-agent-sdk = ["claude-agent-sdk>=0.1"]
+dev = [
+  "pytest>=8",
+  "ruff>=0.6",
+  "opentelemetry-api>=1.25",
+  "opentelemetry-sdk>=1.25",
+  "langchain>=1.0",
+  "pydantic-ai-slim>=1.0",
+  "claude-agent-sdk>=0.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/contexory"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/contexory", "README.md", "LICENSE"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["contexory", "conftest"]

contexory_sdk-0.1.0/src/contexory/__init__.py

@@ -0,0 +1,67 @@
+from .apply_tools import AppliedTools, apply_tools
+from .client import (
+    DEFAULT_BASE_URL,
+    DEFAULT_LABEL,
+    Contexory,
+    FetchResponse,
+    ResolvedContext,
+    default_fetch,
+)
+from .errors import ContexoryResolveError, ContexorySignatureError
+from .instrument import (
+    AGENT_VERSION_ATTRIBUTE,
+    RELEASE_BAGGAGE_KEY,
+    VENDOR_ATTRIBUTES,
+    VENDORS,
+    Instrumentation,
+    instrument,
+    open_inference_metadata,
+    open_llmetry_association_properties,
+    openai_agents_trace_metadata,
+)
+from .mcp_upstream import (
+    canonical_json,
+    clamp_ttl,
+    description_hash,
+    hash_mcp_tools,
+    mcp_tools_hash,
+    report_upstream_hashes,
+    schema_hash,
+    watch_mcp_tools,
+)
+from .release import normalize_release
+from .types import ResolvedTool, ResolvePayload, Upstream
+
+__all__ = [
+    "AGENT_VERSION_ATTRIBUTE",
+    "DEFAULT_BASE_URL",
+    "DEFAULT_LABEL",
+    "RELEASE_BAGGAGE_KEY",
+    "VENDORS",
+    "VENDOR_ATTRIBUTES",
+    "AppliedTools",
+    "Contexory",
+    "ContexoryResolveError",
+    "ContexorySignatureError",
+    "FetchResponse",
+    "Instrumentation",
+    "ResolvePayload",
+    "ResolvedContext",
+    "ResolvedTool",
+    "Upstream",
+    "canonical_json",
+    "clamp_ttl",
+    "description_hash",
+    "hash_mcp_tools",
+    "mcp_tools_hash",
+    "report_upstream_hashes",
+    "schema_hash",
+    "watch_mcp_tools",
+    "apply_tools",
+    "default_fetch",
+    "instrument",
+    "normalize_release",
+    "open_inference_metadata",
+    "open_llmetry_association_properties",
+    "openai_agents_trace_metadata",
+]

contexory_sdk-0.1.0/src/contexory/adapters/claude_agent_sdk.py

@@ -0,0 +1,58 @@
+"""Claude Agent SDK: an in-process MCP proxy that re-exposes external tools with released descriptions.
+
+Claude Code's built-in tools and external MCP servers describe themselves; their
+descriptions cannot be rewritten in flight. The proxy registers each upstream tool again
+under an in-process MCP server with the released description and forwards the call, so
+the model reads Contexory's text. Name the proxy server so the model sees
+`mcp__<server>__<tool>` and disallow the upstream originals with `disallowed_tools`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Iterable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class UpstreamTool:
+    name: str
+    description: str
+    input_schema: Any
+    #: Forwards one call: `await call(args)` returns the MCP result dict (`{"content": [...]}`).
+    call: Callable[[Mapping[str, Any]], Awaitable[dict[str, Any]]]
+
+
+def proxied_tools(context: Any, upstream: Iterable[UpstreamTool], *, include_unmatched: bool = True) -> list[Any]:
+    """`UpstreamTool`s with the released description applied.
+
+    A tool with no released description is kept as-is unless `include_unmatched=False`.
+    """
+    tools = list(upstream)
+    applied = context.apply_tools({t.name: {"name": t.name, "description": t.description} for t in tools})
+    out: list[UpstreamTool] = []
+    released = {t.name for t in context.tools}
+    for tool in tools:
+        if tool.name not in released and not include_unmatched:
+            continue
+        description = applied[tool.name]["description"]
+        out.append(UpstreamTool(tool.name, description, tool.input_schema, tool.call))
+    return out
+
+
+def create_proxy_server(
+    context: Any, upstream: Iterable[UpstreamTool], *, name: str = "contexory", include_unmatched: bool = True
+) -> Any:
+    """An SDK MCP server config for `ClaudeAgentOptions(mcp_servers={name: server})`."""
+    try:
+        from claude_agent_sdk import create_sdk_mcp_server, tool
+    except ImportError as error:
+        raise ImportError(
+            "create_proxy_server() needs the Claude Agent SDK. pip install 'contexory-sdk[claude-agent-sdk]'"
+        ) from error
+
+    wrapped = [
+        tool(t.name, t.description, t.input_schema)(t.call)
+        for t in proxied_tools(context, upstream, include_unmatched=include_unmatched)
+    ]
+    return create_sdk_mcp_server(name=name, tools=wrapped)

contexory_sdk-0.1.0/src/contexory/adapters/langchain.py

@@ -0,0 +1,36 @@
+"""LangChain / LangGraph: apply released tool descriptions and the system prompt per model call."""
+
+from __future__ import annotations
+
+from typing import Any
+
+try:
+    from langchain.agents.middleware import AgentMiddleware as _Base
+except ImportError:  # pragma: no cover - the adapter still works duck-typed against any object with `override`
+    _Base = object  # type: ignore[assignment,misc]
+
+
+class ContexoryMiddleware(_Base):  # type: ignore[misc,valid-type]
+    """Agent middleware: `create_agent(model, tools, middleware=[ContexoryMiddleware(ctx)])`.
+
+    Rewrites each model request's tools to the released descriptions. `apply_system=True`
+    also replaces the system message with the release's system prompt.
+    """
+
+    def __init__(self, context: Any, *, apply_system: bool = False):
+        self.context = context
+        self.apply_system = apply_system
+
+    def _rewrite(self, request: Any) -> Any:
+        overrides: dict[str, Any] = {}
+        if request.tools:
+            overrides["tools"] = self.context.apply_tools(list(request.tools))
+        if self.apply_system:
+            overrides["system_prompt"] = self.context.system
+        return request.override(**overrides) if overrides else request
+
+    def wrap_model_call(self, request: Any, handler: Any) -> Any:
+        return handler(self._rewrite(request))
+
+    async def awrap_model_call(self, request: Any, handler: Any) -> Any:
+        return await handler(self._rewrite(request))

contexory_sdk-0.1.0/src/contexory/adapters/pydantic_ai.py

@@ -0,0 +1,27 @@
+"""Pydantic AI: apply released tool descriptions through `prepare_tools`."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+from ..apply_tools import describe_tool
+
+
+def prepare_tools(context: Any) -> Any:
+    """`Agent(model, prepare_tools=prepare_tools(ctx))`.
+
+    Descriptions only: Pydantic AI routes a call back by the tool name it registered,
+    so renames are not offered here.
+    """
+    released = {tool.name: tool for tool in context.tools}
+
+    async def prepare(_run_context: Any, tool_defs: list[Any]) -> list[Any]:
+        return [
+            dataclasses.replace(definition, description=describe_tool(released[definition.name]))
+            if definition.name in released
+            else definition
+            for definition in tool_defs
+        ]
+
+    return prepare