opencomputer 0.1.0__py3-none-any.whl

opencomputer/__init__.py

@@ -0,0 +1,3 @@
+"""OpenComputer — personal AI agent framework."""
+
+__version__ = "0.1.0"

opencomputer/agent/__init__.py

@@ -0,0 +1 @@
+"""Agent subsystem — loop, memory, state, prompt building."""

opencomputer/agent/compaction.py

@@ -0,0 +1,245 @@
+"""
+CompactionEngine — auto-summarize old turns when the context fills up.
+
+Design notes (per Phase 6a review):
+
+1. Trigger uses the ACTUAL input_tokens from the last ProviderResponse.usage
+   (not a character-count estimate). Different providers tokenize differently.
+2. Preserves the last N messages (default 20) untouched.
+3. Preserves assistant+tool_result message PAIRS atomically. Splitting a
+   tool_use from its matching tool_result causes Anthropic's API to 400.
+4. On aux-LLM failure or timeout, falls back to a deterministic
+   "truncate-and-drop-oldest-N" strategy so the turn can still proceed.
+5. Hooks and injection providers DO NOT fire inside the compaction LLM call
+   (no recursion). Iteration budget is not charged.
+
+Returns a NEW message list with the compacted range replaced by one synthetic
+assistant message tagged `[compacted-summary]` so downstream tools (FTS5
+search) can distinguish it from the model's own output.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+
+from plugin_sdk.core import Message
+from plugin_sdk.provider_contract import BaseProvider
+
+logger = logging.getLogger("opencomputer.agent.compaction")
+
+
+#: Sensible per-model-family context windows. Compaction fires at 80% of these.
+#: Keep conservative — better to compact early than hit a real-limit error.
+DEFAULT_CONTEXT_WINDOWS: dict[str, int] = {
+    # Anthropic Claude 4.x models with extended context
+    "claude-opus-4-7": 200_000,
+    "claude-sonnet-4-6": 200_000,
+    "claude-haiku-4-5": 200_000,
+    # OpenAI GPT 5.x
+    "gpt-5.4": 400_000,
+    # Fallback
+    "_default": 200_000,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class CompactionConfig:
+    preserve_recent: int = 20
+    threshold_ratio: float = 0.8
+    summarize_max_tokens: int = 1024
+    summarize_timeout_s: float = 30.0
+    #: Number of messages to drop on aux-LLM failure fallback.
+    fallback_drop_count: int = 10
+
+
+@dataclass(slots=True)
+class CompactionResult:
+    messages: list[Message]
+    did_compact: bool = False
+    degraded: bool = False  # True when aux LLM failed and we truncated instead
+    reason: str = ""
+
+
+def context_window_for(model: str) -> int:
+    """Look up the context window for a model. Falls back to default."""
+    if model in DEFAULT_CONTEXT_WINDOWS:
+        return DEFAULT_CONTEXT_WINDOWS[model]
+    # Fuzzy family match
+    for key, v in DEFAULT_CONTEXT_WINDOWS.items():
+        if key != "_default" and model.startswith(key.split("-")[0]):
+            return v
+    return DEFAULT_CONTEXT_WINDOWS["_default"]
+
+
+class CompactionEngine:
+    """Decide when to compact, and do it with safety rails."""
+
+    def __init__(
+        self,
+        provider: BaseProvider,
+        model: str,
+        config: CompactionConfig | None = None,
+        disabled: bool = False,
+    ) -> None:
+        self.provider = provider
+        self.model = model
+        self.config = config or CompactionConfig()
+        self.disabled = disabled
+        #: Flag the loop checks to suppress hook firing while compaction runs.
+        self._in_progress = False
+
+    @property
+    def in_progress(self) -> bool:
+        """True while compaction's own LLM call is in flight — hooks must not fire."""
+        return self._in_progress
+
+    def should_compact(self, last_input_tokens: int) -> bool:
+        """Use actual measured tokens, not an estimate."""
+        if self.disabled:
+            return False
+        window = context_window_for(self.model)
+        threshold = int(window * self.config.threshold_ratio)
+        return last_input_tokens >= threshold
+
+    async def maybe_run(
+        self, messages: list[Message], last_input_tokens: int
+    ) -> CompactionResult:
+        """Check the threshold; compact if needed; otherwise return unchanged."""
+        if not self.should_compact(last_input_tokens):
+            return CompactionResult(messages=messages, did_compact=False)
+
+        # Decide which messages to compact. Preserve:
+        #  - System messages at the start
+        #  - The last N messages untouched
+        recent_count = self.config.preserve_recent
+        if len(messages) <= recent_count + 1:
+            # Not enough old messages to bother — no-op
+            return CompactionResult(messages=messages, did_compact=False)
+
+        # Split at a SAFE boundary — must not split tool_use from tool_result.
+        split_idx = self._safe_split_index(messages, recent_count)
+        if split_idx <= 0:
+            return CompactionResult(messages=messages, did_compact=False)
+
+        old_block = messages[:split_idx]
+        recent_block = messages[split_idx:]
+
+        # Try the aux LLM summary
+        try:
+            summary_text = await asyncio.wait_for(
+                self._summarize(old_block), timeout=self.config.summarize_timeout_s
+            )
+        except Exception as e:  # noqa: BLE001 — fall back on any failure
+            logger.warning("compaction aux LLM failed, falling back to truncate: %s", e)
+            return self._truncate_fallback(messages, split_idx)
+
+        # Success — replace old_block with one synthetic summary message
+        synthetic = Message(
+            role="assistant",
+            content=f"[compacted-summary]\n\n{summary_text}",
+        )
+        new_msgs = [synthetic, *recent_block]
+        return CompactionResult(messages=new_msgs, did_compact=True, reason="aux-summary")
+
+    # ─── internals ────────────────────────────────────────────────
+
+    def _safe_split_index(
+        self, messages: list[Message], preserve_recent: int
+    ) -> int:
+        """
+        Find a split point at `len(messages) - preserve_recent` that does NOT
+        break a tool_use / tool_result pair.
+
+        Walk backwards from the target index. If the candidate boundary has
+        a tool_result right after a tool_use, move earlier until we're between
+        a clean turn boundary.
+        """
+        if len(messages) <= preserve_recent:
+            return 0
+        target = len(messages) - preserve_recent
+
+        # Scan backward: if messages[target] is a tool result, move back until
+        # we land right BEFORE its originating assistant tool_use message
+        # (ideally at a user message or a clean assistant reply).
+        idx = target
+        while idx > 0:
+            msg = messages[idx]
+            prev = messages[idx - 1] if idx > 0 else None
+            # Unsafe: `idx` points to a tool result and prev is an assistant
+            # message containing tool_use blocks — splitting would orphan them.
+            prev_has_tool_use = (
+                prev is not None
+                and prev.role == "assistant"
+                and bool(prev.tool_calls)
+            )
+            if msg.role == "tool" or prev_has_tool_use:
+                idx -= 1
+                continue
+            break
+        return idx
+
+    async def _summarize(self, old_block: list[Message]) -> str:
+        """Call the provider to summarize. Hooks/injection must NOT fire here."""
+        self._in_progress = True
+        try:
+            # Keep the prompt simple. The provider returns a plain Message.
+            prompt = Message(
+                role="user",
+                content=(
+                    "Summarize the following conversation history tightly. "
+                    "Keep facts, decisions, file paths, and any commands run. "
+                    "Output plain prose, no markdown headers. Target ~300 words."
+                ),
+            )
+            # Flatten history into text — providers need canonical messages.
+            synth_history = _flatten_for_summary(old_block)
+            resp = await self.provider.complete(
+                model=self.model,
+                messages=[Message(role="user", content=synth_history), prompt],
+                max_tokens=self.config.summarize_max_tokens,
+                temperature=0.3,
+            )
+            return resp.message.content or "[compaction returned empty]"
+        finally:
+            self._in_progress = False
+
+    def _truncate_fallback(
+        self, messages: list[Message], split_idx: int
+    ) -> CompactionResult:
+        """Degraded path: drop N oldest non-system messages."""
+        drop = min(self.config.fallback_drop_count, split_idx)
+        new_msgs = messages[drop:]
+        synthetic = Message(
+            role="assistant",
+            content=f"[compacted-truncated] — {drop} oldest messages removed due to compaction failure",
+        )
+        return CompactionResult(
+            messages=[synthetic, *new_msgs],
+            did_compact=True,
+            degraded=True,
+            reason="aux-failed-truncated",
+        )
+
+
+def _flatten_for_summary(messages: list[Message]) -> str:
+    """Render a message list as plain text for the summarizer."""
+    parts: list[str] = []
+    for m in messages:
+        role = m.role.upper()
+        content = m.content or ""
+        if m.tool_calls:
+            tool_names = ", ".join(tc.name for tc in m.tool_calls)
+            content = (content + f"\n[called tools: {tool_names}]").strip()
+        parts.append(f"{role}: {content}")
+    return "\n\n".join(parts)
+
+
+__all__ = [
+    "CompactionEngine",
+    "CompactionConfig",
+    "CompactionResult",
+    "context_window_for",
+    "DEFAULT_CONTEXT_WINDOWS",
+]

opencomputer/agent/config.py

@@ -0,0 +1,108 @@
+"""
+Typed configuration — replaces the 58-parameter __init__ nightmare.
+
+All agent config lives in small, composable dataclasses. Load from
+~/.opencomputer/config.yaml (or TOML — TBD). Environment variables
+can override individual fields.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def _home() -> Path:
+    """Return ~/.opencomputer/, creating it if needed."""
+    home = Path(os.environ.get("OPENCOMPUTER_HOME", Path.home() / ".opencomputer"))
+    home.mkdir(parents=True, exist_ok=True)
+    return home
+
+
+@dataclass(frozen=True, slots=True)
+class ModelConfig:
+    """Which LLM to use and how."""
+
+    provider: str = "anthropic"  # maps to a provider plugin name
+    model: str = "claude-opus-4-7"
+    max_tokens: int = 4096
+    temperature: float = 1.0
+    api_key_env: str = "ANTHROPIC_API_KEY"
+
+
+@dataclass(frozen=True, slots=True)
+class LoopConfig:
+    """Behavior of the main agent loop."""
+
+    max_iterations: int = 50
+    parallel_tools: bool = True
+    iteration_timeout_s: int = 600
+
+
+@dataclass(frozen=True, slots=True)
+class SessionConfig:
+    """Where sessions are stored and how."""
+
+    db_path: Path = field(default_factory=lambda: _home() / "sessions.db")
+    session_id: str | None = None  # None = create new session each run
+
+
+@dataclass(frozen=True, slots=True)
+class MemoryConfig:
+    """The three-pillar memory configuration."""
+
+    declarative_path: Path = field(default_factory=lambda: _home() / "MEMORY.md")
+    skills_path: Path = field(default_factory=lambda: _home() / "skills")
+    # episodic memory uses SessionConfig.db_path
+
+
+@dataclass(frozen=True, slots=True)
+class MCPServerConfig:
+    """One MCP server the agent should connect to."""
+
+    name: str = ""
+    transport: str = "stdio"  # "stdio" or "http"
+    command: str = ""  # for stdio: the executable (e.g. "python3")
+    args: tuple[str, ...] = ()  # for stdio: argv (use tuple for hashability)
+    url: str = ""  # for http: endpoint URL
+    env: dict[str, str] = field(default_factory=dict)  # optional env vars
+    enabled: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class MCPConfig:
+    """MCP integration — list of servers + global toggles."""
+
+    servers: tuple[MCPServerConfig, ...] = ()
+    # Connect servers in the background after startup (kimi-cli pattern).
+    deferred: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+    """Root configuration — composed of small focused configs."""
+
+    model: ModelConfig = field(default_factory=ModelConfig)
+    loop: LoopConfig = field(default_factory=LoopConfig)
+    session: SessionConfig = field(default_factory=SessionConfig)
+    memory: MemoryConfig = field(default_factory=MemoryConfig)
+    mcp: MCPConfig = field(default_factory=MCPConfig)
+    home: Path = field(default_factory=_home)
+
+
+def default_config() -> Config:
+    """Return the default configuration with filesystem-appropriate paths."""
+    return Config()
+
+
+__all__ = [
+    "Config",
+    "ModelConfig",
+    "LoopConfig",
+    "SessionConfig",
+    "MemoryConfig",
+    "MCPConfig",
+    "MCPServerConfig",
+    "default_config",
+]

opencomputer/agent/config_store.py

@@ -0,0 +1,210 @@
+"""
+Config persistence — load/save ~/.opencomputer/config.yaml.
+
+Users can edit this file by hand or via `opencomputer config set key=value`.
+Defaults from ModelConfig/LoopConfig/etc. apply if the file is missing
+or if a given key isn't set.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, fields, is_dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from opencomputer.agent.config import (
+    Config,
+    _home,
+    default_config,
+)
+
+
+def config_file_path() -> Path:
+    return _home() / "config.yaml"
+
+
+# ─── load ────────────────────────────────────────────────────────
+
+
+def _apply_overrides(base: Any, overrides: dict[str, Any]) -> Any:
+    """Recursively apply a dict over a dataclass, returning a new dataclass."""
+    if not is_dataclass(base) or not isinstance(overrides, dict):
+        return base
+    field_map = {f.name: f for f in fields(base)}
+    kwargs: dict[str, Any] = {}
+    for name, current in asdict(base).items():
+        if name in overrides:
+            new = overrides[name]
+            nested = getattr(base, name)
+
+            if is_dataclass(nested) and isinstance(new, dict):
+                # Nested dataclass (e.g. model, loop, mcp)
+                kwargs[name] = _apply_overrides(nested, new)
+            elif isinstance(nested, tuple) and isinstance(new, list):
+                # Tuple-of-dataclasses field (e.g. mcp.servers = [MCPServerConfig, ...])
+                inner_type = _extract_tuple_inner_type(type(base), name, nested)
+                if inner_type is not None:
+                    built = []
+                    for item in new:
+                        if isinstance(item, dict):
+                            # build a default instance then apply overrides
+                            try:
+                                default_instance = inner_type()
+                            except TypeError:
+                                default_instance = None
+                            if default_instance is not None:
+                                built.append(_apply_overrides(default_instance, item))
+                            else:
+                                built.append(item)
+                        else:
+                            built.append(item)
+                    kwargs[name] = tuple(built)
+                else:
+                    kwargs[name] = tuple(new)
+            else:
+                field_type = field_map[name].type
+                if "Path" in str(field_type) and isinstance(new, str):
+                    kwargs[name] = Path(new)
+                else:
+                    kwargs[name] = new
+        else:
+            kwargs[name] = getattr(base, name)
+    return type(base)(**kwargs)
+
+
+def _extract_tuple_inner_type(
+    base_cls: type, field_name: str, existing_tuple: tuple
+) -> type | None:
+    """Best-effort: figure out the dataclass type stored in a tuple field.
+
+    Uses typing.get_type_hints so 'from __future__ import annotations'
+    string annotations are resolved to real types.
+    """
+    if existing_tuple and is_dataclass(existing_tuple[0]):
+        return type(existing_tuple[0])
+    import typing
+
+    try:
+        hints = typing.get_type_hints(base_cls)
+    except Exception:
+        return None
+    annotation = hints.get(field_name)
+    if annotation is None:
+        return None
+    origin = typing.get_origin(annotation)
+    if origin is tuple:
+        args = typing.get_args(annotation)
+        if args and is_dataclass(args[0]):
+            return args[0]
+    return None
+
+
+def load_config(path: Path | None = None) -> Config:
+    """Load config from YAML, applying overrides on top of defaults.
+
+    Missing file or empty file → returns defaults. Invalid YAML is an error.
+    """
+    cfg_path = path or config_file_path()
+    base = default_config()
+    if not cfg_path.exists():
+        return base
+    try:
+        raw = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError as e:
+        raise RuntimeError(f"Failed to parse {cfg_path}: {e}") from e
+    if not isinstance(raw, dict):
+        raise RuntimeError(f"Config file {cfg_path} must be a YAML mapping")
+    return _apply_overrides(base, raw)
+
+
+# ─── save ────────────────────────────────────────────────────────
+
+
+def _to_yaml_dict(cfg: Config) -> dict[str, Any]:
+    """Convert a Config dataclass to a YAML-friendly dict (Paths as strings)."""
+
+    def _encode(v: Any) -> Any:
+        if isinstance(v, Path):
+            return str(v)
+        if is_dataclass(v):
+            return {k: _encode(getattr(v, k)) for k in [f.name for f in fields(v)]}
+        if isinstance(v, tuple):
+            return [_encode(item) for item in v]
+        return v
+
+    return {
+        "model": _encode(cfg.model),
+        "loop": _encode(cfg.loop),
+        "session": _encode(cfg.session),
+        "memory": _encode(cfg.memory),
+        "mcp": _encode(cfg.mcp),
+    }
+
+
+def save_config(cfg: Config, path: Path | None = None) -> Path:
+    """Write config to YAML. Returns the path written."""
+    cfg_path = path or config_file_path()
+    cfg_path.parent.mkdir(parents=True, exist_ok=True)
+    data = _to_yaml_dict(cfg)
+    cfg_path.write_text(
+        yaml.safe_dump(data, default_flow_style=False, sort_keys=False),
+        encoding="utf-8",
+    )
+    return cfg_path
+
+
+# ─── get / set by dotted key ────────────────────────────────────
+
+
+def get_value(cfg: Config, key: str) -> Any:
+    """Get a value by dotted key like 'model.provider'."""
+    parts = key.split(".")
+    current: Any = cfg
+    for p in parts:
+        if is_dataclass(current):
+            if not hasattr(current, p):
+                raise KeyError(f"Unknown config key: {key} (failed at '{p}')")
+            current = getattr(current, p)
+        else:
+            raise KeyError(f"Unknown config key: {key} (not a config section at '{p}')")
+    return current
+
+
+def set_value(cfg: Config, key: str, value: Any) -> Config:
+    """Return a NEW Config with `key` set to `value`. Dotted key supported."""
+    parts = key.split(".")
+    if len(parts) == 1:
+        raise KeyError("Top-level set not supported: use e.g. 'model.provider'")
+    section_name, *rest = parts
+    if not hasattr(cfg, section_name):
+        raise KeyError(f"Unknown section: {section_name}")
+
+    section = getattr(cfg, section_name)
+    if not is_dataclass(section):
+        raise KeyError(f"'{section_name}' is not a config section")
+
+    # Descend into nested sections (rare in this flat schema but future-proof)
+    section_overrides: dict[str, Any] = {}
+    cursor = section_overrides
+    for i, p in enumerate(rest):
+        if i == len(rest) - 1:
+            cursor[p] = value
+        else:
+            cursor[p] = {}
+            cursor = cursor[p]
+
+    new_section = _apply_overrides(section, section_overrides)
+    kwargs = {f.name: getattr(cfg, f.name) for f in fields(cfg)}
+    kwargs[section_name] = new_section
+    return Config(**kwargs)
+
+
+__all__ = [
+    "config_file_path",
+    "load_config",
+    "save_config",
+    "get_value",
+    "set_value",
+]

opencomputer/agent/injection.py

@@ -0,0 +1,60 @@
+"""
+InjectionEngine — queries all registered DynamicInjectionProviders per turn.
+
+Deterministic ordering (priority asc, then provider_id asc) so repeated turns
+with the same state produce the same system prompt. Critical for prompt cache
+stability on the LLM side.
+
+Providers register via `opencomputer.plugins.loader.PluginAPI.register_injection_provider`.
+"""
+
+from __future__ import annotations
+
+from plugin_sdk.injection import DynamicInjectionProvider, InjectionContext
+
+
+class InjectionEngine:
+    """Singleton registry + composer for injection providers."""
+
+    def __init__(self) -> None:
+        self._providers: dict[str, DynamicInjectionProvider] = {}
+
+    def register(self, provider: DynamicInjectionProvider) -> None:
+        pid = provider.provider_id
+        if pid in self._providers:
+            raise ValueError(f"Injection provider '{pid}' already registered")
+        self._providers[pid] = provider
+
+    def unregister(self, provider_id: str) -> None:
+        self._providers.pop(provider_id, None)
+
+    def providers(self) -> list[DynamicInjectionProvider]:
+        return list(self._providers.values())
+
+    def collect(self, ctx: InjectionContext) -> list[str]:
+        """Call each provider, return non-empty injections in deterministic order."""
+        # Deterministic: sort by (priority, provider_id). Same inputs → same output.
+        ordered = sorted(
+            self._providers.values(),
+            key=lambda p: (p.priority, p.provider_id),
+        )
+        out: list[str] = []
+        for p in ordered:
+            try:
+                text = p.collect(ctx)
+            except Exception:  # noqa: BLE001 — providers never break the loop
+                continue
+            if text and text.strip():
+                out.append(text.strip())
+        return out
+
+    def compose(self, ctx: InjectionContext, separator: str = "\n\n") -> str:
+        """Convenience: collect() + join."""
+        return separator.join(self.collect(ctx))
+
+
+#: Global singleton (matches tool_registry pattern)
+engine = InjectionEngine()
+
+
+__all__ = ["InjectionEngine", "engine"]