code-puppy-core-plugins 0.0.5__tar.gz → 0.0.8__tar.gz

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.5
+Version: 0.0.8
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.15,>=3.11
 Requires-Dist: httpx<1,>=0.24.1
+Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai]<3,>=2.31.0
 Description-Content-Type: text/markdown
 
 # Code Puppy Core Plugins

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/acp/mcp_config.py

@@ -1,9 +1,9 @@
 """Attach client-injected MCP servers (from ``session/new``) to a session agent.
 
-ACP lets the client pass MCP server specs per session. We translate each into a
-pydantic-ai MCP server and append it to the agent's ``_mcp_servers`` list;
-``run_with_mcp`` starts them for that session's runs. Best-effort: a malformed
-spec is skipped, never fatal.
+ACP lets the client pass MCP server specs per session. We translate each into
+the pydantic-ai v2 ``MCPToolset`` API and append it to the host agent's
+MCP configuration; the session agent owns their lifecycle. Best-effort: a
+malformed spec is skipped, never fatal.
 """
 
 from __future__ import annotations
@@ -24,29 +24,37 @@ def _kv(items: Any) -> Dict[str, str]:
     return out
 
 
+def _with_prefix(toolset: Any, name: Optional[str]) -> Any:
+    """Prefix tool names through the public toolset wrapper API."""
+    return toolset.prefixed(name) if name else toolset
+
+
 def _translate(spec: Any) -> Optional[Any]:
-    """Map one ACP MCP server spec to a pydantic-ai MCP server instance."""
-    from pydantic_ai.mcp import (
-        MCPServerSSE,
-        MCPServerStdio,
-        MCPServerStreamableHTTP,
+    """Map one ACP MCP server spec to a pydantic-ai MCP toolset."""
+    from fastmcp.client.transports import (
+        SSETransport,
+        StdioTransport,
+        StreamableHttpTransport,
     )
+    from pydantic_ai.mcp import MCPToolset
 
     name = getattr(spec, "name", None) or None
     if getattr(spec, "command", None):
-        return MCPServerStdio(
+        transport = StdioTransport(
             command=spec.command,
             args=list(getattr(spec, "args", None) or []),
             env=_kv(getattr(spec, "env", None)) or None,
-            tool_prefix=name,
         )
+        return _with_prefix(MCPToolset(transport, prefer_tasks=False), name)
     url = getattr(spec, "url", None)
     if not url:
         return None
     headers = _kv(getattr(spec, "headers", None)) or None
     if getattr(spec, "type", None) == "sse":
-        return MCPServerSSE(url=url, headers=headers, tool_prefix=name)
-    return MCPServerStreamableHTTP(url=url, headers=headers, tool_prefix=name)
+        transport = SSETransport(url=url, headers=headers)
+    else:
+        transport = StreamableHttpTransport(url=url, headers=headers)
+    return _with_prefix(MCPToolset(transport, prefer_tasks=False), name)
 
 
 def attach(agent: Any, specs: List[Any]) -> None:

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/acp/persistence.py

@@ -1,18 +1,19 @@
 """Persist ACP session history so ``session/load`` and ``session/resume``
 rehydrate real turns across process restarts.
 
-Each session's pydantic-ai message history is pickled under a dedicated
-directory keyed by the ACP session id, reusing code-puppy's existing
-``session_storage`` layer. We keep it separate from the user's autosaves
+Each session's pydantic-ai message history is saved through code-puppy's
+versioned JSON ``session_storage`` envelope under a dedicated directory keyed
+by the ACP session id. A legacy pickle twin may exist while older core
+versions are supported; JSON is always preferred and pickle is only a
+fallback. We keep the directory separate from the user's autosaves
 (``AUTOSAVE_DIR/acp``) so ACP threads never pollute the ``/resume`` picker.
 
-Alongside the pickle we write a small ACP metadata sidecar (``*_acp.json``)
-recording the session's own ``cwd`` + ``additional_directories``. This is what
-lets ``list_persisted`` surface revivable sessions after a
-restart *with the ``cwd`` that ACP's ``SessionInfo`` requires* -- the pickle
-alone can't answer "where did this thread live?", and ``session_storage``'s
-own ``_meta.json`` records the *process* cwd, which is wrong for per-session
-ACP threads.
+Alongside the session envelope we write a small ACP metadata sidecar
+(``*_acp.json``) recording the session's own ``cwd`` +
+``additional_directories``. This is what lets ``list_persisted`` surface
+revivable sessions after a restart *with the ``cwd`` that ACP's
+``SessionInfo`` requires* -- the core session metadata records the process
+cwd, which is wrong for per-session ACP threads.
 
 Every public entry point takes an optional ``base_dir``: production callers
 omit it (it defaults to ``AUTOSAVE_DIR/acp``), while tests pass an explicit
@@ -57,7 +58,7 @@ def _resolve_base(base_dir: Optional[Path]) -> Path:
 
 
 def _safe_name(session_id: str) -> str:
-    """Sanitise a session id into a filesystem-safe pickle stem."""
+    """Sanitise a session id into a filesystem-safe session stem."""
     return "".join(c if (c.isalnum() or c in "-_") else "_" for c in session_id)
 
 
@@ -145,12 +146,24 @@ def load_history(
         return None
 
 
+def _session_file_exists(base: Path, session_id: str) -> bool:
+    """Return whether the JSON session or legacy pickle is available.
+
+    The JSON envelope is the source of truth. The pickle check is retained
+    only so an ACP session written by an older core/plugin can still be
+    listed and lazily migrated by ``load_session``.
+    """
+    stem = _safe_name(session_id)
+    return (base / f"{stem}.json").exists() or (base / f"{stem}.pkl").exists()
+
+
 def list_persisted(base_dir: Optional[Path] = None) -> List[PersistedSession]:
     """Return every ACP session persisted on disk (newest first).
 
     Reads the ACP metadata sidecars so revivable sessions survive process
-    restarts. A session whose pickle vanished (only the sidecar remains) is
-    skipped -- there is nothing left to rehydrate.
+    restarts. A session whose JSON envelope and legacy pickle both vanished
+    (only the sidecar remains) is skipped -- there is nothing left to
+    rehydrate.
     """
     base = _resolve_base(base_dir)
     if not base.exists():
@@ -162,7 +175,7 @@ def list_persisted(base_dir: Optional[Path] = None) -> List[PersistedSession]:
             session_id = data.get("session_id")
             if not session_id:
                 continue
-            if not (base / f"{_safe_name(session_id)}.pkl").exists():
+            if not _session_file_exists(base, session_id):
                 continue
             records.append(
                 PersistedSession(
@@ -179,7 +192,7 @@ def list_persisted(base_dir: Optional[Path] = None) -> List[PersistedSession]:
 
 
 def delete(session_id: str, base_dir: Optional[Path] = None) -> None:
-    """Remove a persisted session's pickle + sidecars (best-effort).
+    """Remove a persisted session's JSON/pickle files + sidecars (best-effort).
 
     Called when a client explicitly closes a session so a deliberate close
     doesn't leave a ghost that reappears in the next ``list_sessions``.
@@ -188,6 +201,7 @@ def delete(session_id: str, base_dir: Optional[Path] = None) -> None:
         base = _resolve_base(base_dir)
         stem = _safe_name(session_id)
         for path in (
+            base / f"{stem}.json",
             base / f"{stem}.pkl",
             base / f"{stem}_meta.json",
             _acp_meta_path(base, session_id),

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/acp/replay.py

@@ -77,7 +77,20 @@ def _updates_for_message(message: Any) -> List[Any]:
                 updates.append(update_agent_thought_text(text))
         elif kind == "tool-call":
             updates.append(_tool_call_update(part))
-        # system-prompt / tool-return: model plumbing, not replayed.
+        elif kind in {"system-prompt", "tool-return"}:
+            # Model plumbing, not conversation content.
+            continue
+        else:
+            # New v2 kinds (speech, compaction, tool-availability deltas, and
+            # future additions) must not make replay brittle. Preserve plain
+            # textual content when present; non-text plumbing is safely skipped.
+            text = _text_of(
+                getattr(part, "content", None)
+                if getattr(part, "content", None) is not None
+                else getattr(part, "transcript", None)
+            )
+            if text:
+                updates.append(update_agent_message_text(text))
     return updates
 
 

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/acp/session.py

@@ -306,10 +306,12 @@ def _to_acp_usage(result: Any) -> Optional[Usage]:
     if result is None:
         return None
     try:
-        usage = result.usage()
+        usage = getattr(result, "usage", None)
+        # pydantic-ai 2.31.0 exposes usage as a property. Ignore an older
+        # method-style value rather than invoking its deprecated call path.
     except Exception:  # noqa: BLE001
         return None
-    if usage is None:
+    if usage is None or callable(usage):
         return None
 
     def pick(*names: str) -> Optional[int]:

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/aws_bedrock/register_callbacks.py

@@ -164,9 +164,8 @@ def _create_aws_bedrock_model(model_name: str, model_config: dict, config: dict)
         )
         return None
 
-    from code_puppy.claude_cache_client import patch_anthropic_client_messages
     from code_puppy.config import get_effective_model_settings
-    from code_puppy.model_factory import CONTEXT_1M_BETA
+    from code_puppy.model_factory import CONTEXT_1M_BETA, make_model_settings
     from code_puppy.provider_identity import (
         make_anthropic_provider,
         resolve_provider_identity,
@@ -206,15 +205,27 @@ def _create_aws_bedrock_model(model_name: str, model_config: dict, config: dict)
 
         anthropic_client = AsyncAnthropicBedrock(**client_kwargs)
 
-        patch_anthropic_client_messages(anthropic_client)
-
         provider_identity = resolve_provider_identity(model_name, model_config)
         provider = make_anthropic_provider(
             provider_identity,
             anthropic_client=anthropic_client,
         )
 
-        model = AnthropicModel(model_name=model_id, provider=provider)
+        # Prompt caching is handled by pydantic-ai's native Anthropic
+        # settings at all three cache breakpoints.
+        model_settings = make_model_settings(model_name)
+        model_settings.update(
+            {
+                "anthropic_cache_instructions": True,
+                "anthropic_cache_tool_definitions": True,
+                "anthropic_cache_messages": True,
+            }
+        )
+        model = AnthropicModel(
+            model_name=model_id,
+            provider=provider,
+            settings=model_settings,
+        )
         logger.info(
             "Created Bedrock model: %s -> %s @ %s",
             model_name,

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/azure_foundry/register_callbacks.py

@@ -317,9 +317,8 @@ def _create_azure_foundry_model(
         )
         return None
 
-    from code_puppy.claude_cache_client import patch_anthropic_client_messages
     from code_puppy.config import get_effective_model_settings
-    from code_puppy.model_factory import CONTEXT_1M_BETA
+    from code_puppy.model_factory import CONTEXT_1M_BETA, make_model_settings
     from code_puppy.provider_identity import (
         make_anthropic_provider,
         resolve_provider_identity,
@@ -381,9 +380,6 @@ def _create_azure_foundry_model(
             default_headers=default_headers,
         )
 
-        # Patch for cache control injection
-        patch_anthropic_client_messages(anthropic_client)
-
         # Create the pydantic-ai provider and model
         provider_identity = resolve_provider_identity(model_name, model_config)
         provider = make_anthropic_provider(
@@ -391,7 +387,22 @@ def _create_azure_foundry_model(
             anthropic_client=anthropic_client,
         )
 
-        model = AnthropicModel(model_name=deployment_name, provider=provider)
+        # Prompt caching is handled by pydantic-ai's native Anthropic
+        # settings; Foundry's API-key-style models use Anthropic's default
+        # five-minute cache TTL.
+        model_settings = make_model_settings(model_name)
+        model_settings.update(
+            {
+                "anthropic_cache_instructions": True,
+                "anthropic_cache_tool_definitions": True,
+                "anthropic_cache_messages": True,
+            }
+        )
+        model = AnthropicModel(
+            model_name=deployment_name,
+            provider=provider,
+            settings=model_settings,
+        )
         logger.info(
             "Created Azure Foundry model: %s -> %s @ %s",
             model_name,

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/claude_code_oauth/fast_mode.py

@@ -96,10 +96,9 @@ def make_fast_mode_wrapper(
 def patch_anthropic_client_fast_mode(client: Any, model_name: str) -> None:
     """Monkey-patch ``messages.create`` (and ``beta.messages.create``).
 
-    Must be called *after* ``patch_anthropic_client_messages`` so our wrapper
-    sits outside the cache-control injector — order of wrappers doesn't matter
-    for correctness here, but keeping fast-mode outermost makes it easy to
-    reason about.
+    Must be called after the Anthropic client is constructed. Keeping
+    fast-mode outermost makes the request-header transform easy to reason
+    about.
     """
     try:
         messages_obj = getattr(client, "messages", None)

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/claude_code_oauth/register_callbacks.py

@@ -32,7 +32,7 @@ from .fast_mode import (
     is_fast_mode_enabled,
     patch_anthropic_client_fast_mode,
 )
-from .prompt_handler import is_claude_code_model, prepare_claude_code_prompt
+from .prompt_handler import prepare_claude_code_prompt
 from .utils import (
     OAuthContext,
     add_models_to_extra_config,
@@ -458,17 +458,6 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
     return None
 
 
-def _resolve_cache_ttl(model_name: str) -> Optional[str]:
-    """Prompt-cache TTL for a claude_code-type model.
-
-    ``claude-code-*`` models (OAuth subscription) always get the free 1-hour
-    TTL; anything else falls back to Anthropic's 5-minute default (None).
-    """
-    from code_puppy.claude_cache_client import CACHE_TTL_1H
-
-    return CACHE_TTL_1H if is_claude_code_model(model_name) else None
-
-
 def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict) -> Any:
     """Create a Claude Code model instance.
 
@@ -478,12 +467,13 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
     from anthropic import AsyncAnthropic
     from pydantic_ai.models.anthropic import AnthropicModel
 
-    from code_puppy.claude_cache_client import (
-        ClaudeCacheAsyncClient,
-        patch_anthropic_client_messages,
-    )
+    from code_puppy.claude_cache_client import ClaudeCacheAsyncClient
     from code_puppy.http_utils import get_cert_bundle_path
-    from code_puppy.model_factory import get_custom_config
+    from code_puppy.model_factory import (
+        CONTEXT_1M_BETA,
+        get_custom_config,
+        make_model_settings,
+    )
 
     url, headers, verify, api_key, timeout = get_custom_config(model_config)
 
@@ -529,8 +519,6 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
         headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
 
     # Add 1M context beta header for long-context models
-    from code_puppy.model_factory import CONTEXT_1M_BETA
-
     if model_config.get("context_length", 0) >= 1_000_000:
         if "anthropic-beta" in headers:
             beta_parts = [p.strip() for p in headers["anthropic-beta"].split(",")]
@@ -543,15 +531,11 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
     # Fast mode: append fast-mode-2026-02-01 beta marker when enabled
     ensure_fast_beta_header(headers, fast_enabled)
 
-    # Use a dedicated client wrapper that injects cache_control on /v1/messages
+    # Use a dedicated client wrapper for OAuth refresh and tool-name transport
+    # transformations; prompt-cache markers are owned by model settings.
     if verify is None:
         verify = get_cert_bundle_path()
 
-    # claude-code-* OAuth models get 1-hour prompt caching free, so they ALWAYS
-    # request the extended TTL; plain anthropic/custom_anthropic models keep the
-    # default 5-minute TTL — deliberately not applied to those.
-    cache_ttl = _resolve_cache_ttl(model_name)
-
     # No HTTP/2 for OAuth: the UnprefixingStream tool-name rewrite breaks under
     # HTTP/2's compression handling, causing zlib decompression errors.
     client = ClaudeCacheAsyncClient(
@@ -562,7 +546,6 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
         # Claude Code OAuth requires the ``cp_`` tool-name prefix; the wire
         # format Anthropic's CLI uses won't accept un-prefixed tools.
         apply_claude_code_prefix=True,
-        cache_ttl=cache_ttl,
         oauth_reauthentication_callback=lambda: _reauthenticate_after_expired_oauth(
             model_name
         ),
@@ -581,9 +564,9 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
             custom_endpoint["api_key"] = access_token
 
     client.set_token_update_callback(_update_runtime_token)
-    patch_anthropic_client_messages(anthropic_client, cache_ttl=cache_ttl)
-    # Fast mode wrapper sits outside cache-control injector and re-reads
-    # the setting on every call so /claude-code-fast takes effect live.
+    # Fast mode wrapper re-reads the setting on every call so
+    # /claude-code-fast takes effect live.
+
     patch_anthropic_client_fast_mode(anthropic_client, model_name)
     anthropic_client.api_key = None
     anthropic_client.auth_token = api_key
@@ -591,7 +574,22 @@ def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict)
         resolve_provider_identity(model_name, model_config),
         anthropic_client=anthropic_client,
     )
-    return AnthropicModel(model_name=model_config["name"], provider=provider)
+    # Prompt caching belongs to pydantic-ai's native Anthropic settings, not
+    # the transport shim. OAuth subscription models receive the free one-hour
+    # TTL at all three cache breakpoints.
+    model_settings = make_model_settings(model_name)
+    model_settings.update(
+        {
+            "anthropic_cache_instructions": "1h",
+            "anthropic_cache_tool_definitions": "1h",
+            "anthropic_cache_messages": "1h",
+        }
+    )
+    return AnthropicModel(
+        model_name=model_config["name"],
+        provider=provider,
+        settings=model_settings,
+    )
 
 
 def _register_model_types() -> List[Dict[str, Any]]:

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/code_puppy_agent/PLUGINS_AND_CALLBACKS.md

@@ -36,13 +36,27 @@ time. All hooks accept sync or async functions.
 | `get_model_system_prompt` | Per-model prompt patch | `dict` with `instructions`/`handled` or `None` |
 | `custom_command` | Unknown `/slash` command | `True` (handled), `str` (message), or `None` (not mine) |
 | `pre_tool_call` | Before tool executes | Can modify args |
-| `post_tool_call` | After tool finishes | Observes result + duration |
+| `post_tool_call` | After tool finishes | Observes result + duration; can mutate dict results in place |
 | `run_shell_command` | Before shell exec | Return `{"blocked": True}` to block |
 | `file_permission` | Before file op | `bool` — allow/deny |
 | `agent_run_start` / `agent_run_end` | Agent lifecycle | Observes name, model, session |
 
 The full list is in `callbacks.py` — `PhaseType` has ~45 phases.
 
+### Mutating results from `post_tool_call`
+
+The patched tool runner evaluates the result reference before awaiting
+`post_tool_call`. A callback can therefore mutate a plain dict result in
+place and the model sees the change. It cannot replace a string or other
+non-dict result by rebinding its local argument. Tool exceptions arrive
+as error-only dicts and should remain intact.
+
+Mutation is order-sensitive: result-bounding callbacks must run after
+callbacks that append content. Sync callbacks also execute on the event
+loop, so blocking work belongs in an async callback via
+`asyncio.to_thread()`. The builtin `spill` plugin is the canonical
+implementation.
+
 ## Minimal plugin example
 
 ```

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/code_puppy_agent/SKILL.md

@@ -89,11 +89,11 @@ Plugins hook into every stage via callbacks.
 | File | Read this for |
 |------|----------------|
 | `AGENTS_AND_TOOLS.md` | How agents are structured/discovered (Python, JSON, plugin agents, precedence). How tools get registered and wired to an agent. Async-tool blocking-I/O gotcha. |
-| `PLUGINS_AND_CALLBACKS.md` | Plugin discovery tiers, the full callback hook table, a minimal plugin example, and **two hook-system gotchas** (`get_model_system_prompt` last-write-wins; don't do real work at import time) worth reading before writing any new plugin. |
+| `PLUGINS_AND_CALLBACKS.md` | Plugin discovery tiers, the callback hook table, in-place tool-result mutation and ordering, a minimal plugin example, and hook-system gotchas (`get_model_system_prompt` last-write-wins; don't do real work at import time). |
 | `MODELS_AND_MCP.md` | ModelFactory, model config precedence, model types. MCP server lifecycle, agent bindings, and a known gap (MCP servers can't yet provide skills). |
 | `SESSIONS_AND_HISTORY.md` | Message history, context-window compaction, session save/load commands. |
 | `SKILLS_SYSTEM.md` | Skill discovery/activation, bundled-resource-file gotcha for plugin-registered skills, and **skill namespaces** — how `namespace_skill_search` groups large skill catalogs and replaces the flat prompt list. |
-| `SYSTEM_PROMPT_CONFIG_AND_I18N.md` | Exact system-prompt assembly order (which layer skills/rules/patches land in), `puppy.cfg` + key directories, the messaging bus, and an i18n quick-reference (full guide: `docs/I18N.md`). |
+| `SYSTEM_PROMPT_CONFIG_AND_I18N.md` | Exact system-prompt assembly order, `puppy.cfg` + key directories, spill configuration, the messaging bus, and an i18n quick-reference (full guide: `docs/I18N.md`). |
 
 Don't guess which file has what you need — the table above is exhaustive
 for this skill's scope. If a question doesn't map cleanly to one row, it's

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/code_puppy_agent/SYSTEM_PROMPT_CONFIG_AND_I18N.md

@@ -76,6 +76,23 @@ turning off `frontmatter_in_system_prompt` on its first run) does **not**
 automatically revert. Disabling the plugin and undoing what it already
 did to your config are two separate actions.
 
+### Bounding oversized tool results with `spill`
+
+The builtin `spill` plugin saves oversized top-level string fields to
+private files and substitutes bounded head/tail previews with retrieval
+guidance. It leaves error-only and non-dict results untouched and skips
+`read_file` by default to avoid a read → spill → read loop.
+
+| `puppy.cfg` key | Default | Meaning |
+|-----------------|---------|---------|
+| `spill_max_inline_bytes` | `32768` | Aggregate inline string-byte cap; `0` or negative disables spilling |
+| `spill_preview_bytes` | `4096` | Head-plus-tail source-byte budget per spilled field |
+| `spill_root` | unset | Storage root override; otherwise use a private OS temp directory |
+| `spill_skip_tools` | `read_file` | Comma-separated tool names that must remain inline |
+
+Storage is best-effort: any spill failure keeps the original successful
+tool result inline.
+
 ---
 
 ## Messaging & UI

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/dbos_durable_exec/runtime.py

@@ -1,5 +1,9 @@
-"""Async context manager wrapping pydantic_agent.run() with DBOS workflow ID
-and (when needed) MCP toolset injection on the inner pydantic agent."""
+"""Async context manager wrapping pydantic_agent.run() with a DBOS workflow ID.
+
+pydantic-ai 2.31.0's DBOSAgent converts constructor-level MCP toolsets to
+DBOS-safe variants. Runtime private-toolset swaps are intentionally gone;
+``mcp_servers`` remains in the callback signature for host compatibility.
+"""
 
 from __future__ import annotations
 
@@ -21,11 +25,12 @@ def skip_fallback_render(_agent) -> bool:
 
 @asynccontextmanager
 async def dbos_run_context(agent, pydantic_agent, group_id, mcp_servers):
-    """Wrap a run() call with SetWorkflowID and a temporary MCP toolset swap.
+    """Wrap a run() call with SetWorkflowID.
 
     For sub-agent invocations (group_id starting with 'invoke_agent'), append
     an atomic counter to ensure DBOS workflow ID uniqueness across rapid
-    back-to-back calls. For the main agent, use group_id as-is.
+    back-to-back calls. For the main agent, use group_id as-is. MCP toolsets
+    stay constructor-owned by pydantic-ai's DBOSAgent integration.
     """
     from .lifecycle import is_launched
 
@@ -47,19 +52,9 @@ async def dbos_run_context(agent, pydantic_agent, group_id, mcp_servers):
         else group_id
     )
 
-    # The inner pydantic agent under DBOSAgent is exposed via `.wrapped`
-    # (see pydantic_ai.agent.WrapperAgent). Fall back defensively.
-    inner = getattr(pydantic_agent, "wrapped", pydantic_agent)
-
-    original = None
-    swapped = False
-    if mcp_servers:
-        original = getattr(inner, "_toolsets", []) or []
-        inner._toolsets = list(original) + list(mcp_servers)
-        swapped = True
-    try:
-        with SetWorkflowID(workflow_id):
-            yield workflow_id
-    finally:
-        if swapped:
-            inner._toolsets = original
+    # ``mcp_servers`` is intentionally unused: DBOSAgent received the
+    # constructor-level toolsets and converted them before this context runs.
+    # Retain the argument because the core callback ABI supplies it.
+    del agent, pydantic_agent, mcp_servers
+    with SetWorkflowID(workflow_id):
+        yield workflow_id

{code_puppy_core_plugins-0.0.5 → code_puppy_core_plugins-0.0.8}/code_puppy_core_plugins/dbos_durable_exec/wrapper.py

@@ -1,8 +1,9 @@
 """DBOSAgent wrapper, registered via the wrap_pydantic_agent hook.
 
-The DBOS wrapper can't pickle async-generator MCP toolsets, so we stash
-them off the inner pydantic agent before wrapping. They're restored at
-run-time inside :mod:`runtime` so MCP tools remain available during the run.
+pydantic-ai 2.31.0's ``DBOSAgent`` constructor visits the wrapped agent's
+public toolsets and replaces MCP toolsets with DBOS-safe variants. Keep the
+normal constructor-level toolsets intact and let that public integration own
+the lifecycle; older plugin code mutated private ``_toolsets`` fields here.
 """
 
 from __future__ import annotations
@@ -43,10 +44,9 @@ def wrap_with_dbos_agent(
     except ImportError:
         return None
 
-    # Reset toolsets — DBOS can't pickle async-generator MCP toolsets.
-    # The runtime hook re-injects MCP servers from its own arg at run time.
-    pydantic_agent._toolsets = []
-
+    # DBOSAgent 2.31.0 handles MCP toolsets during construction. Do not
+    # mutate private agent state: constructor-level toolsets are the public
+    # integration point and are converted to DBOS-safe variants there.
     name_suffix = next(_reload_count)
     agent_name = getattr(agent, "name", "agent")
     # Sub-agent path historically didn't pass an event stream handler.