PyPI - code-puppy-core-plugins - Versions diffs - 0.0.83__tar.gz → 0.0.84__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.83
+Version: 0.0.84
 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

@@ -245,6 +245,17 @@ only an [RFD](https://agentclientprotocol.com), not in stable v1 — no client,
 including Zed, implements it yet). When elicitation lands and the SDK exposes a
 connection method for it, this block becomes a real native picker.
+### Clients that present the questions themselves
+A client with its own question UI can opt in at `initialize` by setting
+`clientCapabilities._meta.codePuppyQuestionCards` to `true`. For that client the
+`EventBridge` sends `ask_user_question` as a **completed** `tool_call` whose
+`rawInput` holds the questions, still blocks the terminal picker, and gives the
+model a `tool_result` (core's `pre_tool_call` handled-result contract) telling
+it to end the turn and wait. The client renders the questions and sends the
+answers as the user's next prompt. Clients that don't set the flag see no
+change.
 ---
 ## Testing

@@ -114,6 +114,9 @@ class CodePuppyAgent(Agent):
         the client advertises). Everything else stays local.
         """
         self._client_caps = client_capabilities
+        self._bridge.question_cards_enabled = capabilities.client_presents_questions(
+            client_capabilities
+        )
         io_delegation.install(client_capabilities)
         return InitializeResponse(
             protocol_version=PROTOCOL_VERSION,

@@ -24,6 +24,7 @@ from __future__ import annotations
 import logging
 import os
+import uuid
 from typing import Any, Dict, List, Optional
 from acp.helpers import (
@@ -89,9 +90,22 @@ _INTERACTIVE_BLOCK = {
 }
+# Tool result for a question the client is presenting (see
+# ``capabilities.client_presents_questions``).
+_CLIENT_QUESTION_RESULT = (
+    "The client is showing these questions to the user in its own question "
+    "UI. End this turn and wait for the user's answers, which arrive in their "
+    "next message. Do not repeat the questions in text or call this tool again."
+)
 class EventBridge:
     """Forward Code Puppy runtime hook events to the client as updates."""
+    #: Set at ``initialize`` when the client opted in to presenting
+    #: ``ask_user_question`` itself.
+    question_cards_enabled = False
     def register(self) -> None:
         """Register the runtime hooks. Call once when the connection opens."""
         register_callback("stream_event", self._on_stream_event)
@@ -179,6 +193,8 @@ class EventBridge:
         session_id = state.get_active_session_id()
         if session_id is None:
             return None
+        if tool_name == "ask_user_question" and self.question_cards_enabled:
+            return await self._present_question(session_id, tool_args)
         if tool_name in _INTERACTIVE_TOOLS:
             return dict(_INTERACTIVE_BLOCK)
         tool_call_id = state.push_tool_call(tool_name)
@@ -192,6 +208,33 @@ class EventBridge:
         )
         await self._send(session_id, update)
+    async def _present_question(
+        self, session_id: str, tool_args: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Hand ``ask_user_question`` to a client that presents it itself.
+        The client gets a completed tool call whose ``rawInput`` carries the
+        questions. The terminal picker is still blocked (stdin is the
+        JSON-RPC pipe), and the model receives ``tool_result`` -- "wait for
+        the answers" -- as the tool's return value instead of a policy deny.
+        """
+        await self._send(
+            session_id,
+            start_tool_call(
+                uuid.uuid4().hex,
+                "ask_user_question",
+                kind="other",
+                status="completed",
+                raw_input=tool_args if isinstance(tool_args, dict) else {},
+            ),
+        )
+        return {
+            "blocked": True,
+            "tool_result": _CLIENT_QUESTION_RESULT,
+            # Shown instead on cores without ``tool_result`` support.
+            "error_message": _CLIENT_QUESTION_RESULT,
+        }
     async def _on_post_tool_call(
         self,
         tool_name: str,

@@ -57,6 +57,23 @@ def agent_capabilities() -> AgentCapabilities:
     )
+# ``clientCapabilities._meta`` key a client sets to show ``ask_user_question``
+# itself. Such a client renders the tool call's ``rawInput`` (the questions) as
+# its own question UI and sends the answers in its next prompt.
+QUESTION_CARDS_META_KEY = "codePuppyQuestionCards"
+def client_presents_questions(caps: ClientCapabilities | None) -> bool:
+    """True when the client opted in to presenting ``ask_user_question``.
+    Opt-in only: a client that does not set the flag keeps the existing
+    behavior (the model is told to ask in plain text). Defensive like
+    ``client_io_caps`` -- anything but a literal ``True`` reads as "no".
+    """
+    meta = getattr(caps, "field_meta", None) if caps is not None else None
+    return isinstance(meta, dict) and meta.get(QUESTION_CARDS_META_KEY) is True
 def client_io_caps(caps: ClientCapabilities | None) -> Tuple[bool, bool, bool]:
     """Return ``(fs_read, fs_write, terminal)`` from the client's capabilities.

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.83"
+version = "0.0.84"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

code-puppy-core-plugins 0.0.83__tar.gz → 0.0.84__tar.gz

code-puppy-core-plugins 0.0.83tar.gz → 0.0.84tar.gz