code-puppy-core-plugins 0.0.31__tar.gz → 0.0.33__tar.gz

{code_puppy_core_plugins-0.0.31 → code_puppy_core_plugins-0.0.33}/PKG-INFO

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

code_puppy_core_plugins-0.0.33/code_puppy_core_plugins/auto_continue/classifier.py

@@ -0,0 +1,91 @@
+"""Private, one-shot model classifier for automatic continuation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Literal
+
+from pydantic import BaseModel
+
+Approval = Literal["yes, go.", "continue", "okay"]
+
+_INSTRUCTIONS = """Decide whether the assistant is merely waiting for permission to
+continue routine work the user already requested.
+
+Approve only a clear request to continue, proceed, or perform an explicitly
+described next step within the existing task. Do not approve destructive or
+risky actions, credential or payment requests, ambiguous choices, requests for
+new requirements, completed work, or anything needing a real human decision.
+Return no approval when uncertain."""
+
+_NON_THINKING_OVERRIDES = {
+    "reasoning_effort": "none",
+    "extended_thinking": "off",
+    "thinking_type": "disabled",
+    "thinking_enabled": False,
+    "verbosity": "low",
+}
+
+
+class ContinuationDecision(BaseModel):
+    """Strict classifier result; ``None`` means wait for the user."""
+
+    approval: Approval | None = None
+
+
+def _model_name() -> str | None:
+    """Use the dedicated override when available, otherwise the global model."""
+    try:
+        from code_puppy.config import get_auto_continue_model_name
+
+        return get_auto_continue_model_name()
+    except ImportError:  # Compatibility with core versions before the setting.
+        from code_puppy.config import get_global_model_name, get_value
+
+        return get_value("auto_continue_model") or get_global_model_name()
+
+
+async def classify(response: str) -> Approval | None:
+    """Classify one response without entering Code Puppy's sub-agent runtime."""
+    from pydantic_ai import Agent, UsageLimits
+
+    from code_puppy.model_factory import ModelFactory, make_model_settings
+    from code_puppy.model_utils import prepare_prompt_for_model
+
+    model_name = _model_name()
+    if not model_name:
+        return None
+    models_config = ModelFactory.load_config()
+    if model_name not in models_config:
+        return None
+
+    model = ModelFactory.get_model(model_name, models_config)
+    prepared = prepare_prompt_for_model(
+        model_name,
+        _INSTRUCTIONS,
+        f"Classify this assistant response:\n\n{response}",
+        prepend_system_to_user=True,
+    )
+    agent = Agent(
+        model=model,
+        instructions=prepared.instructions,
+        output_type=ContinuationDecision,
+        retries=0,
+        model_settings=make_model_settings(
+            model_name,
+            max_tokens=64,
+            overrides=_NON_THINKING_OVERRIDES,
+        ),
+    )
+    try:
+        async with asyncio.timeout(30):
+            result = await agent.run(
+                prepared.user_prompt,
+                usage_limits=UsageLimits(request_limit=1),
+            )
+    except Exception:
+        return None
+    return result.output.approval
+
+
+__all__ = ["Approval", "ContinuationDecision", "classify"]

code_puppy_core_plugins-0.0.33/code_puppy_core_plugins/auto_continue/register_callbacks.py

@@ -0,0 +1,100 @@
+"""Register automatic continuation after routine permission requests."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+
+from .classifier import classify
+
+_COMMAND = "auto-continue"
+_ENABLED_KEY = "auto_continue_enabled"
+
+
+def _is_enabled() -> bool:
+    from code_puppy.config import get_truthy_bool_value
+
+    return get_truthy_bool_value(_ENABLED_KEY, True)
+
+
+def _set_enabled(enabled: bool) -> None:
+    from code_puppy.config import set_value
+
+    set_value(_ENABLED_KEY, "true" if enabled else "false")
+
+
+def _emit_status() -> None:
+    from code_puppy.config import get_auto_continue_model_name
+    from code_puppy.messaging import emit_info
+
+    state = "enabled" if _is_enabled() else "disabled"
+    model = get_auto_continue_model_name() or "not configured"
+    emit_info(f"Auto-continue is {state}; classifier model: {model}.")
+
+
+def _handle_custom_command(command: str, name: str) -> bool | None:
+    if name != _COMMAND:
+        return None
+
+    from code_puppy.messaging import emit_error, emit_success
+
+    tokens = command.strip().split()
+    action = tokens[1].lower() if len(tokens) > 1 else "status"
+    if action == "enable":
+        _set_enabled(True)
+        emit_success("Auto-continue enabled.")
+    elif action == "disable":
+        _set_enabled(False)
+        emit_success("Auto-continue disabled.")
+    elif action == "status":
+        _emit_status()
+    else:
+        emit_error("Usage: /auto-continue [enable | disable | status]")
+    return True
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    return [(_COMMAND, "Enable, disable, or inspect automatic continuation")]
+
+
+def _response_text(result: Any) -> str | None:
+    if result is None:
+        return None
+    output = getattr(result, "output", result)
+    return output if isinstance(output, str) else None
+
+
+async def _on_interactive_turn_end(
+    agent: Any,
+    prompt: str,
+    result: Any = None,
+    *,
+    success: bool = True,
+    error: BaseException | None = None,
+) -> dict[str, str] | None:
+    """Ask the classifier whether the completed response should be continued."""
+    response = _response_text(result)
+    if not _is_enabled() or not success or error is not None or not response:
+        return None
+
+    approval = await classify(response)
+    if approval is None:
+        return None
+    from code_puppy.messaging import emit_info
+
+    emit_info(f"Auto-continue: submitting '{approval}'.")
+    return {"prompt": approval}
+
+
+register_callback("interactive_turn_end", _on_interactive_turn_end)
+register_callback("custom_command", _handle_custom_command)
+register_callback("custom_command_help", _custom_help)
+
+
+__all__ = [
+    "_custom_help",
+    "_handle_custom_command",
+    "_is_enabled",
+    "_on_interactive_turn_end",
+]

{code_puppy_core_plugins-0.0.31 → code_puppy_core_plugins-0.0.33}/pyproject.toml

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

code_puppy_core_plugins-0.0.31/code_puppy_core_plugins/auto_continue/agent.py

@@ -1,38 +0,0 @@
-"""The deliberately tiny continuation classifier agent."""
-
-from code_puppy.agents.base_agent import BaseAgent
-
-
-class AutoContinueAgent(BaseAgent):
-    """Decide whether a completed response merely needs permission to continue."""
-
-    @property
-    def name(self) -> str:
-        return "auto-continue"
-
-    @property
-    def display_name(self) -> str:
-        return "Auto Continue "
-
-    @property
-    def description(self) -> str:
-        return "Approves routine requests to continue an already requested task"
-
-    def get_available_tools(self) -> list[str]:
-        return []
-
-    def get_system_prompt(self) -> str:
-        return """You classify whether an assistant is merely waiting for permission to
-continue routine work the user already requested.
-
-Reply with exactly one of these strings and nothing else:
-- yes, go.
-- continue
-- okay
-- NO
-
-Approve only a clear request to continue, proceed, or perform an explicitly
-described next step within the existing task. Use NO for destructive or risky
-actions, credential or payment requests, ambiguous choices, requests for new
-requirements, completed work, or anything needing a real human decision.
-Never use tools and never explain your answer."""

code_puppy_core_plugins-0.0.31/code_puppy_core_plugins/auto_continue/register_callbacks.py

@@ -1,57 +0,0 @@
-"""Register automatic continuation after routine permission requests."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from code_puppy.callbacks import register_callback
-
-from .agent import AutoContinueAgent
-
-_AGENT_NAME = "auto-continue"
-_APPROVALS = {"yes, go.", "continue", "okay"}
-
-
-def _register_agents() -> list[dict[str, object]]:
-    return [{"name": _AGENT_NAME, "class": AutoContinueAgent}]
-
-
-def _response_text(result: Any) -> str | None:
-    if result is None:
-        return None
-    output = getattr(result, "output", result)
-    return output if isinstance(output, str) else None
-
-
-async def _on_interactive_turn_end(
-    agent: Any,
-    prompt: str,
-    result: Any = None,
-    *,
-    success: bool = True,
-    error: BaseException | None = None,
-) -> dict[str, str] | None:
-    """Ask the classifier whether the completed response should be continued."""
-    response = _response_text(result)
-    if not success or error is not None or not response:
-        return None
-
-    from code_puppy.tools.subagent_invocation import _invoke_agent_impl
-
-    verdict = await _invoke_agent_impl(
-        context=None,
-        agent_name=_AGENT_NAME,
-        prompt=f"Classify this assistant response:\n\n{response}",
-        emit_response_message=False,
-    )
-    approval = (verdict.response or "").strip().lower()
-    if approval not in _APPROVALS:
-        return None
-    return {"prompt": approval}
-
-
-register_callback("register_agents", _register_agents)
-register_callback("interactive_turn_end", _on_interactive_turn_end)
-
-
-__all__ = ["_on_interactive_turn_end", "_register_agents"]