code-puppy-core-plugins 0.0.103__tar.gz → 0.0.105__tar.gz

{code_puppy_core_plugins-0.0.103 → code_puppy_core_plugins-0.0.105}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.103
+Version: 0.0.105
 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
@@ -41,6 +41,8 @@ Requires-Dist: pyobjc-framework-cocoa>=10.3; (sys_platform == 'darwin') and extr
 Requires-Dist: pyobjc-framework-quartz>=10.3; (sys_platform == 'darwin') and extra == 'computer-use'
 Requires-Dist: pywinauto<0.7,>=0.6.9; (sys_platform == 'win32') and extra == 'computer-use'
 Requires-Dist: windows-capture<3,>=2.0.1; (sys_platform == 'win32') and extra == 'computer-use'
+Provides-Extra: logfire
+Requires-Dist: logfire>=4.0; extra == 'logfire'
 Description-Content-Type: text/markdown
 
 # Code Puppy Core Plugins
@@ -108,6 +110,21 @@ player can play it. Linux uses `notify-send` for desktop notifications when it
 is installed; Windows uses a best-effort PowerShell toast. No external Python
 dependencies are required.
 
+## Logfire
+
+The `logfire_instrumentation`, `logfire_oauth` and `logfire_sessions` plugins
+do not import the SDK until you opt in. The SDK is an optional extra:
+
+```bash
+uv tool install code-puppy --with 'code-puppy-core-plugins[logfire]'
+```
+
+Opt in to pydantic-ai instrumentation with `/set enable_logfire=true` (or a
+truthy `CODE_PUPPY_ENABLE_LOGFIRE` for headless runs), then restart. Spans are
+sent only when a write token is available, either your own `LOGFIRE_TOKEN` or
+one minted by `/logfire onboard`. Opting in without the extra installed shows
+an install hint instead.
+
 ## pstack
 
 The `pstack` plugin bundles poteto's [pstack](https://github.com/cursor/plugins/tree/main/pstack)

{code_puppy_core_plugins-0.0.103 → code_puppy_core_plugins-0.0.105}/README.md

@@ -63,6 +63,21 @@ player can play it. Linux uses `notify-send` for desktop notifications when it
 is installed; Windows uses a best-effort PowerShell toast. No external Python
 dependencies are required.
 
+## Logfire
+
+The `logfire_instrumentation`, `logfire_oauth` and `logfire_sessions` plugins
+do not import the SDK until you opt in. The SDK is an optional extra:
+
+```bash
+uv tool install code-puppy --with 'code-puppy-core-plugins[logfire]'
+```
+
+Opt in to pydantic-ai instrumentation with `/set enable_logfire=true` (or a
+truthy `CODE_PUPPY_ENABLE_LOGFIRE` for headless runs), then restart. Spans are
+sent only when a write token is available, either your own `LOGFIRE_TOKEN` or
+one minted by `/logfire onboard`. Opting in without the extra installed shows
+an install hint instead.
+
 ## pstack
 
 The `pstack` plugin bundles poteto's [pstack](https://github.com/cursor/plugins/tree/main/pstack)

{code_puppy_core_plugins-0.0.103 → code_puppy_core_plugins-0.0.105}/code_puppy_core_plugins/acp/README.md

@@ -119,6 +119,7 @@ Every file stays well under the 600-line cap and owns one concern.
 | `register_callbacks.py` | Register the `--acp` flag; when present, redirect the console to stderr, run `acp.run_agent(CodePuppyAgent())` on its own loop in a thread, and return `{"handled": True}` so the TUI never starts. |
 | `agent.py` | `CodePuppyAgent(acp.Agent)` — the SDK agent implementation: initialize, new/load/resume/fork/list/close session, prompt, cancel, set_session_mode/model, set_config_option, authenticate, plus `on_connect` (stashes the client handle + installs approvals). |
 | `capabilities.py` | Declarative capability negotiation in SDK models: our `AgentCapabilities`, and parsing the client's `ClientCapabilities` into `(fs_read, fs_write, terminal)`. |
+| `auth_status.py` | Neutral provider registry that lets any plugin report sign-in state; read-only snapshots feed `authMethods` and `authenticate`. |
 | `content.py` | Parse ACP prompt content blocks → text + multimodal attachments (`BinaryContent` / `ImageUrl`), honouring `embeddedContext` + `image`. |
 | `session.py` | `ACPSession`: one ACP session ⇄ one `BaseAgent` + its `_message_history`. Runs each turn as a cancellable `asyncio.Task`; persists history after each turn; owns the final-result fallback. |
 | `commands.py` | Execute client-typed `/slash` commands via `command_handler`, capturing MessageBus output and forwarding it (never touches stdin). |
@@ -129,6 +130,7 @@ Every file stays well under the 600-line cap and owns one concern.
 | `bridge.py` | `EventBridge`: registers `stream_event` / `pre_tool_call` / `post_tool_call` hooks and translates them into SDK `session/update`s via `connection.session_update`. (Hooks, **not** MessageBus — see *Event source*.) |
 | `permissions.py` | Wires Code Puppy's two approval edges to the client via the SDK's `request_permission`: the `tools.common` approval backend (files, cross-thread) and the `run_shell_command` hook (shell). Fails closed. |
 | `io_delegation.py` | `DelegatedFileSystemBackend` (sync, cross-thread) + `DelegatedCommandExecutor` (async terminal lifecycle) that plug into the core I/O seams, capability-gated. |
+| `themes.py` | Read-only theme catalog: the `_code_puppy/themes/list` ext method, the `codePuppy/theme` session `_meta`, and the `_code_puppy/themes/changed` poll (`ThemeWatcher`). |
 | `state.py` | Process-wide run context: the SDK connection + its loop, the active session id, and the open-tool-call stack — so the permission/I/O seams (plain module functions) can reach the running connection and correlate events. |
 
 ```
@@ -186,7 +188,7 @@ double-send.
 | Method | Behaviour |
 |--------|-----------|
 | `initialize` | Negotiate version + capabilities; install capability-gated I/O delegation. |
-| `authenticate` / `logout` | No-op (auth is via Code Puppy's own model config/env). |
+| `authenticate` / `logout` | `authenticate` reports (read-only) the registered auth status for a known method id as `_meta.codePuppy.authStatus`, and succeeds even when that status is `missing` or `expired`; clients must read `status`, not infer from success. An unknown method id gets an empty response. `logout` is a no-op. |
 | `session/new` | Create an `ACPSession` (fresh `BaseAgent`) from `cwd` + `additionalDirectories`; attach client `mcpServers`; return models + config options; schedule `available_commands_update`. |
 | `session/load` | Re-open a thread: **replay persisted history into the agent AND stream it back to the client** as `session/update`s so the client rebuilds the thread UI. |
 | `session/resume` | Rehydrate + replay a session across a restart from persisted history. |
@@ -204,6 +206,66 @@ call in 0.10.1), `plan` updates (no native plan model), and the unstable
 unimplemented method to a clean "method not found", so we advertise honestly
 and stub nothing.
 
+### Reporting sign-in state
+
+`auth_status.py` is a neutral registry: any plugin can register a provider that
+reports its sign-in state, and ACP clients see it in `initialize` (`authMethods`)
+and `authenticate`. Providers must be fast and synchronous; a provider that raises
+or returns a report with wrong-typed fields is skipped. If two providers report the
+same `method_id`, the first registered wins, so the outcome depends on plugin load order.
+
+```python
+from datetime import datetime, timezone
+
+from code_puppy_core_plugins.acp.auth_status import (
+    AuthStatusReport,
+    register_auth_status_provider,
+)
+
+
+def example_auth_status() -> AuthStatusReport | None:
+    session = _load_session()
+    if session is None:
+        return AuthStatusReport("example-login", "Example Login", "missing")
+    return AuthStatusReport(
+        "example-login",
+        "Example Login",
+        "signed_in",
+        expires_at=datetime(2030, 1, 2, 3, 4, 5, tzinfo=timezone.utc),
+        user_id=session.user_name,
+    )
+
+
+register_auth_status_provider(example_auth_status)
+```
+
+`expires_at` is serialized as ISO-8601 UTC (`...Z`); a naive value is treated as UTC,
+and an aware value is converted to UTC. `user_id` is a display string (trimmed, max 128 chars).
+
+Wire shape in the `initialize` result (`authMethods` is omitted when no provider is registered):
+
+```json
+{
+  "authMethods": [
+    {
+      "id": "example-login",
+      "name": "Example Login",
+      "_meta": {
+        "codePuppy": {
+          "authStatus": { "status": "signed_in", "expiresAt": "2030-01-02T03:04:05Z", "userId": "jdoe" }
+        }
+      }
+    }
+  ]
+}
+```
+
+Readers must never trigger login, network or prompts. `id`, `name` and `description`
+are provider-supplied display strings and must never contain secrets; only the contents of
+`_meta.codePuppy.authStatus` are allow-listed to `status`, `expiresAt` and `userId`.
+A `status` of `not_applicable` means the method does not apply to this
+install, so clients should hide any sign-in UI for it.
+
 ### Outbound notifications (us → the client) — `session/update`
 
 `agent_message_chunk`, `agent_thought_chunk`, `tool_call`, `tool_call_update`,
@@ -258,6 +320,73 @@ change.
 
 ---
 
+## Theme catalog (`_code_puppy/themes/*`)
+
+You can list Code Puppy's color themes and track the active one without reading
+its config. The catalog is read-only: there is no setter.
+
+### `_code_puppy/themes/list`
+
+Send this request before or after `session/new`. It needs no session. Send
+`{}` or omit `params`; extra keys are ignored.
+
+The result has this shape:
+
+```jsonc
+{
+  "schemaVersion": 1,
+  "active": "ocean",          // or null
+  "themes": [
+    {
+      "id": "ocean",
+      "label": "Ocean",
+      "icon": "...",
+      "blurb": "...",
+      "appearance": "dark",   // "dark" or "light"
+      "palette": { "bg": "#rrggbb", "fg": "#rrggbb", "ansi": ["#rrggbb", "...16 entries"] },
+      "roles": { "background": "#rrggbb", "surface": "#rrggbb", "text": "#rrggbb",
+                 "mutedText": "#rrggbb", "accent": "#rrggbb", "success": "#rrggbb",
+                 "error": "#rrggbb", "warning": "#rrggbb", "running": "#rrggbb",
+                 "diffAdd": "#rrggbb", "diffRemove": "#rrggbb" }
+    }
+    // ...more themes
+  ]
+}
+```
+
+Themes appear in this order: curated themes in menu order, then `default`. The `surprise`
+theme is excluded. The `default` entry has `null` for `appearance`, `palette`,
+and `roles`, because it restores the terminal's own colors.
+
+`active` is the ID of the catalog theme stored in the `theme_active_theme`
+config key. It is `null` when the key is unset, and also when the key holds
+`legacy-custom` or `surprise`.
+
+For the mapping from palette to roles, see
+[`theme/README.md`](../theme/README.md). This page does not repeat it.
+
+### `_meta` on session responses
+
+`session/new`, `session/load`, and `session/resume` results include
+`_meta["codePuppy/theme"] = {"active": <id or null>}`. Use it to paint the first
+frame without waiting for the list request.
+
+### `_code_puppy/themes/changed`
+
+When the active theme changes, the agent sends this notification with params
+`{"active": <id or null>}`. It sends one notification per change. The agent
+reads the config value every 2 seconds from the moment the client connects.
+The first reading is a baseline, so no notification is sent for it.
+
+### Unknown methods and older CLIs
+
+Any other `_code_puppy/*` method, such as `_code_puppy/themes/set`, returns
+JSON-RPC error `-32601` (method not found). Older Code Puppy CLIs omit the
+`_meta` key and return `-32601` for the list request. Clients should fall back
+to a bundled copy of the catalog when either happens.
+
+---
+
 ## Testing
 
 `tests/test_acp_plugin.py` drives `CodePuppyAgent` directly against a fake SDK

{code_puppy_core_plugins-0.0.103 → code_puppy_core_plugins-0.0.105}/code_puppy_core_plugins/acp/agent.py

@@ -40,6 +40,7 @@ from acp.schema import (
 )
 
 from code_puppy_core_plugins.acp import (
+    auth_status,
     capabilities,
     io_delegation,
     mcp_config,
@@ -48,6 +49,7 @@ from code_puppy_core_plugins.acp import (
     replay,
     session_config,
     state,
+    themes,
 )
 from code_puppy_core_plugins.acp.bridge import EventBridge
 from code_puppy_core_plugins.acp.session import ACPSession
@@ -76,6 +78,7 @@ class CodePuppyAgent(Agent):
         self._sessions: Dict[str, ACPSession] = {}
         self._bridge = EventBridge()
         self._client_caps: Optional[ClientCapabilities] = None
+        self._theme_watcher = themes.ThemeWatcher()
 
     # ---- Connection lifecycle ---------------------------------------------
     def on_connect(self, conn: Any) -> None:
@@ -88,6 +91,11 @@ class CodePuppyAgent(Agent):
         state.set_connection(conn, asyncio.get_running_loop())
         self._bridge.register()
         permissions.install()
+        try:
+            self._theme_watcher.start()
+        except Exception as error:  # noqa: BLE001
+            # Startup must never fail on the theme watcher; log the class only.
+            logger.debug("ACP theme watcher not started: %s", type(error).__name__)
 
     def shutdown(self) -> None:
         """Unwire this agent's event hooks. Call once the connection ends.
@@ -97,6 +105,7 @@ class CodePuppyAgent(Agent):
         connection leaves the global callback registry clean.
         """
         self._bridge.unregister()
+        self._theme_watcher.stop()
 
     # ---- Handshake --------------------------------------------------------
     async def initialize(
@@ -126,11 +135,16 @@ class CodePuppyAgent(Agent):
                 title="Code Puppy",
                 version=_code_puppy_version(),
             ),
+            auth_methods=auth_status.auth_methods(),
         )
 
     async def authenticate(self, method_id: str, **kwargs: Any) -> AuthenticateResponse:
-        """No auth flow — Code Puppy authenticates via its own model config."""
-        return AuthenticateResponse()
+        """Report the registered auth status for ``method_id``.
+        Never logs in, calls the network, or prompts."""
+        report = auth_status.auth_status_for(method_id)
+        if report is None:
+            return AuthenticateResponse()
+        return AuthenticateResponse(field_meta=auth_status.auth_status_meta(report))
 
     # ---- Session lifecycle ------------------------------------------------
     async def new_session(
@@ -153,6 +167,7 @@ class CodePuppyAgent(Agent):
         return NewSessionResponse(
             session_id=session_id,
             config_options=session_config.config_options() or None,
+            field_meta=themes.session_meta(),
         )
 
     async def load_session(
@@ -179,6 +194,7 @@ class CodePuppyAgent(Agent):
         self._announce_commands_soon(session_id)
         return LoadSessionResponse(
             config_options=session_config.config_options() or None,
+            field_meta=themes.session_meta(),
         )
 
     async def resume_session(
@@ -199,6 +215,7 @@ class CodePuppyAgent(Agent):
         self._announce_commands_soon(session_id)
         return ResumeSessionResponse(
             config_options=session_config.config_options() or None,
+            field_meta=themes.session_meta(),
         )
 
     async def fork_session(
@@ -367,6 +384,10 @@ class CodePuppyAgent(Agent):
         reset_model_fallback_warnings(scope=session_id)
         return CloseSessionResponse()
 
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Route ext requests (currently only themes) to the theme catalog."""
+        return await themes.handle_ext_method(method, params)
+
     # ---- Prompt turn ------------------------------------------------------
     async def prompt(
         self, prompt: List[Any], session_id: str, **kwargs: Any

code_puppy_core_plugins-0.0.105/code_puppy_core_plugins/acp/auth_status.py

@@ -0,0 +1,148 @@
+"""Neutral registry of sign-in state that plugins report to ACP clients.
+
+Any plugin registers a provider; ACP reads it without knowing who owns it.
+Called by: agent.py :: CodePuppyAgent.initialize() / authenticate().
+Readers must never trigger login, network I/O, or prompts; providers stay read-only.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import typing
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Callable, Literal
+
+from acp.schema import AuthMethodAgent
+
+logger = logging.getLogger(__name__)
+
+AuthState = Literal["signed_in", "expired", "missing", "not_applicable"]
+
+_USER_ID_MAX_LEN = 128
+
+
+@dataclass(frozen=True)
+class AuthStatusReport:
+    method_id: str
+    name: str
+    status: AuthState
+    description: str | None = None
+    expires_at: datetime | None = None
+    user_id: str | None = None
+
+
+AuthStatusProvider = Callable[[], "AuthStatusReport | None"]
+
+_providers: list[AuthStatusProvider] = []
+_providers_lock = threading.Lock()
+
+
+def register_auth_status_provider(provider: AuthStatusProvider) -> None:
+    with _providers_lock:
+        if provider not in _providers:
+            _providers.append(provider)
+
+
+def unregister_auth_status_provider(provider: AuthStatusProvider) -> None:
+    with _providers_lock:
+        if provider in _providers:
+            _providers.remove(provider)
+
+
+def _is_valid_report(report: object) -> bool:
+    if not isinstance(report, AuthStatusReport):
+        return False
+    if report.status not in typing.get_args(AuthState):
+        return False
+    for text in (report.method_id, report.name):
+        if not isinstance(text, str) or not text.strip():
+            return False
+    if report.description is not None and not isinstance(report.description, str):
+        return False
+    if report.expires_at is not None and not isinstance(report.expires_at, datetime):
+        return False
+    if report.user_id is not None and not isinstance(report.user_id, str):
+        return False
+    return True
+
+
+def current_auth_reports() -> list[AuthStatusReport]:
+    with _providers_lock:
+        providers = list(_providers)
+
+    reports: list[AuthStatusReport] = []
+    seen_ids: set[str] = set()
+    for provider in providers:
+        try:
+            report = provider()
+        except Exception as exc:
+            # Exception type only: messages may carry tokens or other secrets.
+            logger.debug("auth status provider failed: %s", type(exc).__name__)
+            continue
+        if not _is_valid_report(report) or report.method_id in seen_ids:
+            continue
+        seen_ids.add(report.method_id)
+        reports.append(report)
+    return reports
+
+
+def auth_status_for(method_id: str) -> AuthStatusReport | None:
+    for report in current_auth_reports():
+        if report.method_id == method_id and _meta_or_none(report) is not None:
+            return report
+    return None
+
+
+def _format_expires_at(expires_at: datetime) -> str:
+    if expires_at.tzinfo is None:
+        utc_value = expires_at.replace(tzinfo=timezone.utc)
+    else:
+        utc_value = expires_at.astimezone(timezone.utc)
+    return utc_value.replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def auth_status_meta(report: AuthStatusReport) -> dict[str, Any]:
+    # Allow-list only: copying other fields could leak data a subclass carries.
+    inner: dict[str, Any] = {"status": report.status}
+    if report.expires_at is not None:
+        inner["expiresAt"] = _format_expires_at(report.expires_at)
+    if isinstance(report.user_id, str):
+        user_id = report.user_id.strip()[:_USER_ID_MAX_LEN]
+        if user_id:
+            inner["userId"] = user_id
+    return {"codePuppy": {"authStatus": inner}}
+
+
+def _meta_or_none(report: AuthStatusReport) -> dict[str, Any] | None:
+    try:
+        return auth_status_meta(report)
+    except Exception as exc:
+        # Exception type only: messages may carry tokens or other secrets.
+        logger.debug(
+            "auth status report could not be serialized: %s", type(exc).__name__
+        )
+        return None
+
+
+def auth_methods() -> list[AuthMethodAgent] | None:
+    methods: list[AuthMethodAgent] = []
+    for report in current_auth_reports():
+        meta = _meta_or_none(report)
+        if meta is None:
+            continue
+        try:
+            methods.append(
+                AuthMethodAgent(
+                    id=report.method_id,
+                    name=report.name,
+                    description=report.description,
+                    field_meta=meta,
+                )
+            )
+        except Exception as exc:
+            logger.debug(
+                "auth status report could not be serialized: %s", type(exc).__name__
+            )
+    return methods or None

code_puppy_core_plugins-0.0.105/code_puppy_core_plugins/acp/themes.py

@@ -0,0 +1,99 @@
+"""ACP theme catalog: the ``code_puppy/themes/list`` ext method, session meta, and change pushes.
+
+Read-only by design: the client lists themes and reads the active one; there is no setter.
+
+Depends on: catalog.py :: build_catalog(), read_active_theme_id(), SCHEMA_VERSION
+Depends on: state.py :: get_connection()
+Called by: agent.py :: CodePuppyAgent.ext_method(), new_session(), load_session(), resume_session(), on_connect(), shutdown()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Optional
+
+from acp import RequestError
+
+from code_puppy_core_plugins.acp import state
+from code_puppy_core_plugins.theme.catalog import (
+    SCHEMA_VERSION,
+    build_catalog,
+    read_active_theme_id,
+)
+
+logger = logging.getLogger(__name__)
+
+EXT_LIST = "code_puppy/themes/list"
+EXT_CHANGED = "code_puppy/themes/changed"
+META_KEY = "codePuppy/theme"
+POLL_SECONDS = 2.0
+
+# Distinct from None: None is a valid "no active theme" observation.
+_NO_BASELINE: Any = object()
+
+
+async def handle_ext_method(method: str, params: Any) -> dict[str, Any]:
+    """Serve the theme list; any other ext method is not found."""
+    if method != EXT_LIST:
+        # The wire name carries the SDK's leading underscore; the error reports it.
+        raise RequestError.method_not_found("_" + method)
+    return {
+        "schemaVersion": SCHEMA_VERSION,
+        "active": read_active_theme_id(),
+        "themes": build_catalog(),
+    }
+
+
+def session_meta() -> dict[str, Any]:
+    """Return the active theme as ACP ``_meta`` for session responses."""
+    return {META_KEY: {"active": read_active_theme_id()}}
+
+
+class ThemeWatcher:
+    """Polls the active theme and pushes a notification when it changes.
+
+    The first observation is the baseline and sends nothing, so a client that
+    has not yet read the list is never told about a theme it did not ask about.
+    """
+
+    def __init__(self, poll_seconds: float = POLL_SECONDS) -> None:
+        self._poll_seconds = poll_seconds
+        self._task: Optional[asyncio.Task[None]] = None
+        self._last: Any = _NO_BASELINE
+
+    def start(self) -> None:
+        """Start the poll loop on the running event loop; no-op if already running."""
+        if self._task is not None and not self._task.done():
+            return
+        self._task = asyncio.get_running_loop().create_task(self._run())
+
+    def stop(self) -> None:
+        """Cancel the poll loop; safe when never started or already stopped."""
+        if self._task is not None:
+            self._task.cancel()
+            self._task = None
+
+    async def poll_once(self) -> None:
+        """Read the active theme and notify the client if it changed since last poll."""
+        # Broad catches are deliberate: a theme failure must never kill the poll loop.
+        try:
+            value = await asyncio.to_thread(read_active_theme_id)
+        except Exception as error:
+            logger.debug("ACP theme poll failed: %s", type(error).__name__)
+            return
+        previous, self._last = self._last, value
+        if previous is _NO_BASELINE or previous == value:
+            return
+        connection = state.get_connection()
+        if connection is None:
+            return
+        try:
+            await connection.ext_notification(EXT_CHANGED, {"active": value})
+        except Exception as error:
+            logger.debug("ACP theme notify failed: %s", type(error).__name__)
+
+    async def _run(self) -> None:
+        while True:
+            await self.poll_once()
+            await asyncio.sleep(self._poll_seconds)

{code_puppy_core_plugins-0.0.103 → code_puppy_core_plugins-0.0.105}/code_puppy_core_plugins/attachment_references/tool.py

@@ -21,6 +21,7 @@ from pydantic_ai import BinaryContent, RunContext
 from pydantic_ai.messages import UserPromptPart
 
 from code_puppy import config
+from code_puppy.error_logging import log_error
 
 TOOL_NAME = "save_attachments_as_references"
 
@@ -117,6 +118,7 @@ def register_save_attachments_as_references(agent: Any) -> None:
         try:
             paths = await asyncio.to_thread(_save_reference_images, images)
         except OSError as exc:
+            log_error(exc, context="save_attachments_as_references failed")
             return {
                 "success": False,
                 "error": f"Could not save reference images: {exc}",

code_puppy_core_plugins-0.0.105/code_puppy_core_plugins/logfire_instrumentation/__init__.py

@@ -0,0 +1 @@
+"""Opt-in Logfire instrumentation of Code Puppy agent runs."""