diploid-plugins 0.1.0__py3-none-any.whl

diploid_plugins/__init__.py

@@ -0,0 +1,25 @@
+"""Built-in state plugins for diploid-agent."""
+
+from diploid_plugins.auto_continue import AutoContinuePlugin
+from diploid_plugins.body import BodyPlugin
+from diploid_plugins.continuity import ContinuityPlugin
+from diploid_plugins.curriculum import CurriculumPlugin
+from diploid_plugins.identity import IdentityPlugin
+from diploid_plugins.persistent_memory import PersistentMemoryPlugin
+from diploid_plugins.planner import PlannerPlugin
+from diploid_plugins.self_management import SelfManagementPlugin
+from diploid_plugins.self_state import SelfStatePlugin
+from diploid_plugins.working_memory import WorkingMemoryPlugin
+
+__all__ = [
+    "AutoContinuePlugin",
+    "BodyPlugin",
+    "ContinuityPlugin",
+    "CurriculumPlugin",
+    "IdentityPlugin",
+    "PersistentMemoryPlugin",
+    "PlannerPlugin",
+    "SelfManagementPlugin",
+    "SelfStatePlugin",
+    "WorkingMemoryPlugin",
+]

diploid_plugins/auto_continue/__init__.py

@@ -0,0 +1,5 @@
+"""Auto-continue plugin."""
+
+from diploid_plugins.auto_continue.auto_continue import AutoContinuePlugin
+
+Plugin = AutoContinuePlugin

diploid_plugins/auto_continue/auto_continue.py

@@ -0,0 +1,222 @@
+"""Auto-continue plugin: resume a chat turn automatically after a stop reason."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any
+
+from diploid_agent.config import PluginConfig
+from diploid_agent.models import WakeEvent
+from diploid_agent.plugins.base import StatePlugin, TurnInfo
+from diploid_agent.plugins.contexts import TurnStartContext
+from diploid_agent.runtime.plugin_runtime import PluginRuntime
+
+logger = logging.getLogger(__name__)
+
+# Cap the continuation payload so the wake queue and downstream Telegram edits
+# do not balloon with a huge partial thought stream.
+_MAX_CONTINUATION_TEXT_CHARS = 2000
+
+
+def _join_notices(*parts: str | None) -> str | None:
+    """Concatenate non-empty notice strings with a blank line between them."""
+    joined = "\n\n".join(p for p in parts if p)
+    return joined or None
+
+
+class AutoContinuePlugin(StatePlugin):
+    """Resume a chat turn automatically after a configured stop reason."""
+
+    def __init__(
+        self,
+        config: PluginConfig,
+        chat_id: str,
+        sessions_root: Path,
+        runtime: PluginRuntime | None = None,
+    ) -> None:
+        super().__init__(config, chat_id, sessions_root, runtime=runtime)
+        self._state = self._load_state()
+        cfg = self.config.config or {}
+        self._delay_seconds = float(cfg.get("delay_seconds", 2.0))
+        self._max_attempts = int(cfg.get("max_attempts", 3))
+        self._delay_cap_seconds = float(cfg.get("delay_cap_seconds", 60.0))
+        self._stop_reasons = set(cfg.get("stop_reasons", ["timeout", "cancelled"]))
+        self._per_reason = dict(cfg.get("per_reason", {}))
+        self._reason = cfg.get("reason", "auto_continue")
+
+    def _settings(self, stop_reason: str | None) -> tuple[int, float, float]:
+        """Return (max_attempts, delay_seconds, delay_cap) for a stop reason."""
+        reason_cfg = self._per_reason.get(stop_reason, {})
+        max_attempts = int(reason_cfg.get("max_attempts", self._max_attempts))
+        delay = float(reason_cfg.get("delay_seconds", self._delay_seconds))
+        cap = float(reason_cfg.get("delay_cap_seconds", self._delay_cap_seconds))
+        return max_attempts, delay, cap
+
+    def _backoff_delay(self, delay: float, attempt: int, cap: float) -> float:
+        """Exponential backoff capped at delay_cap_seconds."""
+        return min(delay * (2 ** (attempt - 1)), cap)
+
+    def _load_state(self) -> dict[str, Any]:
+        path = self.state_path()
+        if path is None or not path.exists():
+            return {}
+        try:
+            return json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _save_state(self) -> None:
+        path = self.state_path()
+        if path is None:
+            return
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(self._state, indent=2, default=str))
+
+    def _is_continuation(self, text: str) -> bool:
+        if not self._runtime:
+            return False
+        return self._runtime.is_continuation_message(text)
+
+    def _cancel_pending(self) -> None:
+        if not self._runtime:
+            return
+        now = time.time()
+        for event in self._runtime.wake_queue.pending(chat_id=self.chat_id):
+            if event.reason != self._reason:
+                continue
+            if event.leased_until is not None and event.leased_until > now:
+                continue
+            self._runtime.wake_queue.complete(event.id)
+
+    def before_turn(self, context: TurnStartContext) -> None:
+        record = context.record
+        if record is None or record.last_stop_reason not in self._stop_reasons:
+            return
+
+        if self._is_continuation(context.user_message):
+            # Manual continue takes over; cancel any pending auto-continue and
+            # drop any deferred partial notice.
+            self._cancel_pending()
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+            self._save_state()
+            # Attempt count stays as-is because this manual turn is the next attempt.
+        else:
+            # User changed topic; cancel the auto-continue chain and drop the
+            # deferred partial notice. If the user wants the partial result, they
+            # can still say Continue; otherwise we should not leak a soft-timeout
+            # / stopped notice into a normal reply.
+            self._cancel_pending()
+            self._state["attempt"] = 0
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+            self._save_state()
+
+    def after_turn(self, turn: TurnInfo) -> None:
+        # If the harness has suppressed auto-continue (e.g., a service restart
+        # is pending), drop the continuation chain and any deferred notice.
+        if self._runtime and self._runtime.is_auto_continue_suppressed(self.chat_id):
+            self._cancel_pending()
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+            self._state["attempt"] = 0
+            self._save_state()
+            return
+
+        reason = turn.last_stop_reason
+        if reason not in self._stop_reasons:
+            # The turn finished or was stopped by the user. Send any deferred
+            # partial notice that has been pending, then reset the chain.
+            if self._state.get("send_deferred") and self._state.get("deferred_notice"):
+                turn.notice = _join_notices(self._state.pop("deferred_notice"), turn.notice)
+                self._state.pop("send_deferred", None)
+                self._save_state()
+            elif self._state.get("attempt"):
+                self._state["attempt"] = 0
+                self._save_state()
+            return
+
+        max_attempts, base_delay, delay_cap = self._settings(reason)
+        attempt = self._state.get("attempt", 0) + 1
+        if attempt > max_attempts:
+            logger.info(
+                "Auto-continue for %s reached max %d attempts",
+                self.chat_id,
+                max_attempts,
+            )
+            # Give up: send the current partial notice along with any older one.
+            if turn.partial_notice or self._state.get("deferred_notice"):
+                turn.notice = _join_notices(
+                    turn.partial_notice,
+                    self._state.pop("deferred_notice", None),
+                    turn.notice,
+                )
+                turn.partial_notice = None
+                self._state.pop("send_deferred", None)
+            self._state["attempt"] = 0
+            self._save_state()
+            return
+
+        # Show the working indicator, but keep the partial notice visible so the
+        # user can see what was already completed before the auto-continuation.
+        delay = self._backoff_delay(base_delay, attempt, delay_cap)
+        working = f"Working... (attempt {attempt}/{max_attempts}); continuing automatically in {delay:.0f}s."
+        if turn.partial_notice:
+            turn.notice = _join_notices(
+                turn.notice,
+                turn.partial_notice,
+                working,
+            )
+            turn.partial_notice = None
+            # Do not carry a stale deferred notice from a previous version.
+            self._state.pop("deferred_notice", None)
+            self._state.pop("send_deferred", None)
+        else:
+            turn.notice = _join_notices(turn.notice, working)
+
+        self._schedule(attempt, max_attempts, delay)
+
+    def _schedule(self, attempt: int, max_attempts: int, delay: float) -> None:
+        if not self._runtime:
+            return
+
+        payload: dict[str, Any] = {"user_message": "Continue"}
+        try:
+            chat_id_int = int(self.chat_id)
+            placeholder_path = self.sessions_root / ".poller-placeholders" / f"{chat_id_int}.json"
+            if placeholder_path.exists():
+                placeholder_state = json.loads(placeholder_path.read_text())
+                payload["message_id"] = placeholder_state.get("message_id")
+                payload["thought_id"] = placeholder_state.get("thought_id")
+
+            active = self._runtime._active_turns.get(self.chat_id)
+            if active is not None:
+                payload["message_text"] = active.message_text[:_MAX_CONTINUATION_TEXT_CHARS]
+                payload["thought_text"] = active.thought_text[:_MAX_CONTINUATION_TEXT_CHARS]
+        except Exception:
+            logger.exception("Failed to capture continuation placeholder for %s", self.chat_id)
+
+        event = WakeEvent(
+            id="",
+            chat_id=self.chat_id,
+            reason=self._reason,
+            priority=1,
+            scheduled_at=time.time() + delay,
+            payload=payload,
+            silent=False,
+            created_at=time.time(),
+            ready=True,
+        )
+        self._runtime.wake_queue.enqueue(event)
+        self._state["attempt"] = attempt
+        self._save_state()
+        logger.info(
+            "Auto-continue scheduled for %s in %.1fs (attempt %d/%d)",
+            self.chat_id,
+            delay,
+            attempt,
+            max_attempts,
+        )

diploid_plugins/body/__init__.py

@@ -0,0 +1,8 @@
+"""Body state plugin for diploid-agent."""
+
+from diploid_plugins.body.body import BodyPlugin
+from diploid_plugins.body.body_mcp import BodyMcpServer, main
+
+Plugin = BodyPlugin
+
+__all__ = ["BodyMcpServer", "BodyPlugin", "Plugin", "main"]

diploid_plugins/body/body.py

@@ -0,0 +1,186 @@
+"""Body-state plugin for diploid-agent."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from diploid_agent.config import McpServerConfig, PluginConfig
+from diploid_agent.memory import MemoryItem
+from diploid_agent.plugins.base import SleepContext, StatePlugin, TurnInfo, WakeContext
+from diploid_agent.runtime.plugin_runtime import PluginRuntime
+
+from diploid_plugins.body.config import BodyConfig
+from diploid_plugins.body.manager import BodyEvent, BodyManager
+
+
+class BodyPlugin(StatePlugin):
+    """Per-chat body state that survives transport restarts."""
+
+    def __init__(
+        self,
+        config: PluginConfig,
+        chat_id: str,
+        sessions_root: Any,
+        runtime: PluginRuntime | None = None,
+    ) -> None:
+        super().__init__(config, chat_id, sessions_root, runtime=runtime)
+        self._decay_rate = float(config.config.get("decay_rate_per_minute", 0.05))
+        self._max_intensity = float(config.config.get("max_intensity", 1.0))
+        felt_keys = (
+            "felt_turn_retention",
+            "felt_wake_fade",
+            "felt_silence_cap_hours",
+            "felt_surface_threshold",
+            "felt_expire_seconds",
+            "felt_event_gain",
+            "max_felt_summary_chars",
+            "felt_events_max",
+            "felt_event_record_threshold",
+        )
+        self._felt_overrides = {
+            k: config.config[k] for k in felt_keys if k in config.config
+        }
+        body_cfg = BodyConfig(
+            state_file=config.state_file or "chat_body_state.json",
+            max_prompt_chars=config.max_prompt_chars,
+            decay_rate_per_minute=self._decay_rate,
+            max_intensity=self._max_intensity,
+            **self._felt_overrides,
+        )
+        self._body = BodyManager(sessions_root, chat_id, body_cfg)
+
+    def mcp_server(self) -> McpServerConfig | None:
+        return McpServerConfig(
+            name="diploid-body",
+            command="python",
+            args=[
+                "-m",
+                "diploid_plugins.body.body_mcp",
+                "--chat-id",
+                "{chat_id}",
+                "--sessions-root",
+                "{sessions_root}",
+                "--state-file",
+                self.config.state_file or "chat_body_state.json",
+                "--decay-rate",
+                str(self._decay_rate),
+                "--max-intensity",
+                str(self._max_intensity),
+                "--felt-config",
+                json.dumps(self._felt_overrides),
+            ],
+        )
+
+    def _body_map_path(self) -> Path | None:
+        if self._runtime is None:
+            return None
+        try:
+            return self._runtime.config.persona.profile_root / "references" / "body.md"
+        except AttributeError:
+            return None
+
+    def _body_map_text(self) -> str | None:
+        path = self._body_map_path()
+        if path is None or not path.exists():
+            return None
+        return path.read_text().strip()
+
+    def on_waking(self, context: WakeContext) -> None:
+        """Reload from the restored snapshot and let sensations fade."""
+        self._body.refresh()
+        self._body.decay()
+        since = context.previous_turn_at or self._body.state.updated_at
+        silence = max(0.0, context.now - since) if since else 0.0
+        self._body.felt_wake(silence)
+
+    def on_sleeping(self, context: SleepContext) -> None:
+        """Flush body state to disk before the transport can die."""
+        self._body._save_state()
+
+    def prompt_block(self, max_chars: int | None = None) -> str | None:
+        body_map = self._body_map_text()
+        state = self._body.state_for_prompt()
+        text = f"{body_map}\n\n{state}" if body_map else state
+        if not text:
+            return None
+        if max_chars is not None and len(text) > max_chars:
+            text = text[:max_chars]
+        return text
+
+    def event(
+        self,
+        *,
+        event: str | None = None,
+        raw_args: str | None = None,
+        **params: Any,
+    ) -> str:
+        kind = event
+        if not kind:
+            return "Usage: /state body <kind> [location] [intensity]"
+        location = params.get("location")
+        intensity = params.get("intensity", 0.5)
+        if raw_args:
+            parts = _split_unquoted(raw_args)
+            if not location and len(parts) >= 1:
+                location = parts[0]
+            if len(parts) >= 2:
+                try:
+                    intensity = float(parts[1])
+                except ValueError:
+                    intensity = 0.5
+        try:
+            intensity = float(intensity)
+        except (TypeError, ValueError):
+            intensity = 0.5
+        if kind == "felt":
+            summary = location or (raw_args or "")
+            self._body.set_felt(summary, intensity)
+            return "Felt line written."
+        self._body.event(kind, location, intensity)
+        return f"Felt: {kind} {location or ''} ({intensity}).".strip()
+
+    def memory_items(self, since: float) -> list[MemoryItem]:
+        return [
+            MemoryItem(
+                content=_body_event_description(event),
+                timestamp=_ts_iso(event.timestamp),
+                document_id=f"body-{self.chat_id}-{int(event.timestamp * 1000)}",
+                session_number=0,
+                metadata={
+                    "kind": event.kind,
+                    "location": event.location,
+                    "intensity": event.intensity,
+                    "chat_id": self.chat_id,
+                },
+                tags=["body", "sensation", f"chat:{self.chat_id}"],
+            )
+            for event in self._body.recent_events(since=since)
+        ]
+
+    def on_turn_end(self, turn: TurnInfo) -> None:
+        self._body.clear_events_before(turn.updated_at)
+        self._body.decay()
+        self._body.felt_turn_step()
+        self._body._save_state()
+
+
+def _body_event_description(event: BodyEvent) -> str:
+    return (
+        f"{event.kind}"
+        f"{f' at {event.location}' if event.location else ''}"
+        f" (intensity {event.intensity})"
+    )
+
+
+def _ts_iso(when: float) -> str:
+    from datetime import UTC, datetime
+
+    return datetime.fromtimestamp(when, tz=UTC).isoformat()
+
+
+def _split_unquoted(text: str) -> list[str]:
+    parts = re.findall(r'"([^"]*)"|(\S+)', text)
+    return [q or u for q, u in parts]