openmuse 0.1.0__py3-none-any.whl

openmuse/__init__.py

@@ -0,0 +1,10 @@
+"""OpenMuse: an open-source version of Meta's Muse personal agent.
+
+The agent does the work (search, browse, files, code, email, long-running goals);
+a separate Sentinel decides what may run and what leaves the machine; a credential
+vault keeps secrets out of the model's sight; every action lands in an audit log.
+``openmuse serve`` adds the phone app.
+"""
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

openmuse/__main__.py

@@ -0,0 +1,4 @@
+from openmuse.cli import app
+
+if __name__ == "__main__":
+    app()

openmuse/agent/__init__.py

@@ -0,0 +1,3 @@
+from openmuse.agent.core import MuseAgent
+
+__all__ = ["MuseAgent"]

openmuse/agent/core.py

@@ -0,0 +1,257 @@
+"""The agent loop: think (LLM) → act (tools through the Sentinel) → repeat."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from openmuse import prompts
+from openmuse.config import Settings
+from openmuse.goals import GoalStore
+from openmuse.llm.base import BaseLLM
+from openmuse.logger import logger
+from openmuse.memory import MemoryStore
+from openmuse.schema import AgentState, Message, Role, ToolResult
+from openmuse.sentinel import AuditLog, Sentinel
+from openmuse.tools.base import ToolCollection
+from openmuse.ui import UI
+
+
+class MuseAgent:
+    def __init__(
+        self,
+        settings: Settings,
+        llm: BaseLLM,
+        tools: ToolCollection,
+        sentinel: Sentinel,
+        ui: UI,
+        audit: AuditLog,
+        memory: MemoryStore | None = None,
+        goals: GoalStore | None = None,
+        session_file: Path | None = None,
+    ):
+        self.settings = settings
+        self.llm = llm
+        self.tools = tools
+        self.sentinel = sentinel
+        self.ui = ui
+        self.audit = audit
+        self.memory = memory
+        self.goals = goals
+        self.session_file = session_file
+        self.messages: list[Message] = []
+        self.state = AgentState.IDLE
+        self.turns = 0
+        # Optional queue of user messages that arrive *while* a run is in progress (the app
+        # lets you interrupt or pile on requests). They are folded into the conversation
+        # before the next model call instead of waiting for the current run to finish.
+        self.inbox: asyncio.Queue[str] | None = None
+
+    def _drain_inbox(self) -> int:
+        if self.inbox is None:
+            return 0
+        count = 0
+        while not self.inbox.empty():
+            try:
+                text = self.inbox.get_nowait()
+            except asyncio.QueueEmpty:  # pragma: no cover
+                break
+            self.messages.append(Message.user(text))
+            self.audit.record("user_message", content=text, interjected=True)
+            count += 1
+        return count
+
+    # ------------------------------------------------------------------ prompt
+    def build_system_prompt(self, user_input: str) -> str:
+        a = self.settings.agent
+        language_rule = (
+            prompts.LANGUAGE_AUTO.format(detected=prompts.detect_language(user_input))
+            if a.language in ("", "auto")
+            else prompts.LANGUAGE_FIXED.format(language=a.language)
+        )
+        memories = ""
+        if self.memory is not None and self.settings.memory.enabled:
+            items = self.memory.relevant(user_input, limit=self.settings.memory.max_inject)
+            if items:
+                memories = prompts.MEMORY_SECTION.format(
+                    items="\n".join(f"- {m.render()}" for m in items)
+                )
+        goals = ""
+        if self.goals is not None:
+            active = self.goals.list("active")[:5]
+            if active:
+                lines = []
+                for g in active:
+                    nxt = g.next_step
+                    lines.append(
+                        f"- {g.id}: {g.title} (progress {g.progress}"
+                        + (f", next: {nxt.idx}. {nxt.title}" if nxt else "")
+                        + ")"
+                    )
+                goals = prompts.GOALS_SECTION.format(items="\n".join(lines))
+        profile = (
+            prompts.USER_PROFILE_SECTION.format(profile=a.user_profile.strip())
+            if a.user_profile.strip()
+            else ""
+        )
+        extra = (
+            f"\n## Additional instructions\n{a.instructions.strip()}\n"
+            if a.instructions.strip()
+            else ""
+        )
+        return prompts.SYSTEM_PROMPT.format(
+            name=a.name,
+            language_rule=language_rule,
+            now=datetime.now().astimezone().strftime("%Y-%m-%d %H:%M (%A, UTC%z)"),
+            workspace=str(a.workspace.resolve()),
+            sentinel_mode=self.settings.sentinel.mode,
+            tool_names=", ".join(t.name for t in self.tools),
+            user_profile=profile,
+            memories=memories,
+            goals=goals,
+            extra=extra,
+        )
+
+    # ------------------------------------------------------------------ context window
+    def context_messages(self) -> list[Message]:
+        limit = self.settings.agent.max_context_messages
+        msgs = self.messages
+        if len(msgs) <= limit:
+            return list(msgs)
+        cutoff = len(msgs) - limit
+        # Never start in the middle of a tool exchange: advance to the next user message.
+        while cutoff < len(msgs) and msgs[cutoff].role != Role.USER:
+            cutoff += 1
+        return list(msgs[cutoff:]) if cutoff < len(msgs) else list(msgs[-limit:])
+
+    # ------------------------------------------------------------------ stuck detection
+    def _is_stuck(self) -> bool:
+        assistants = [m for m in self.messages if m.role == Role.ASSISTANT][-3:]
+        if len(assistants) < 3:
+            return False
+
+        def sig(m: Message) -> str:
+            calls = [(tc.function.name, tc.function.arguments) for tc in (m.tool_calls or [])]
+            return json.dumps([m.content, calls], ensure_ascii=False, sort_keys=True)
+
+        return len({sig(m) for m in assistants}) == 1
+
+    # ------------------------------------------------------------------ main loop
+    async def run(self, user_input: str) -> str:
+        if self.state == AgentState.RUNNING:
+            raise RuntimeError("agent is already running")
+        self.state = AgentState.RUNNING
+        self.turns += 1
+        self.messages.append(Message.user(user_input))
+        self.audit.record("user_message", content=user_input)
+        system_prompt = self.build_system_prompt(user_input)
+        tool_params = self.tools.to_params()
+        final: str | None = None
+        step = 0
+        empty_replies = 0
+        try:
+            while step < self.settings.agent.max_steps:
+                step += 1
+                if self._drain_inbox():
+                    logger.debug("folded queued user message(s) into the running turn")
+                    # the language rule and the memory section follow the latest message
+                    system_prompt = self.build_system_prompt(self.messages[-1].content or "")
+                context = [Message.system(system_prompt), *self.context_messages()]
+                response = await self.llm.ask(
+                    context, tools=tool_params, on_delta=self.ui.on_text_delta
+                )
+                assistant = response.to_message()
+                assistant.meta.update({"step": step, "usage": response.usage})
+                self.messages.append(assistant)
+                self.ui.on_assistant_message(response.content, response.reasoning)
+                self.audit.record(
+                    "assistant_message",
+                    step=step,
+                    content=response.content or "",
+                    tool_calls=[tc.function.name for tc in response.tool_calls],
+                    usage=response.usage,
+                )
+
+                if not response.tool_calls:
+                    if response.content:
+                        final = response.content
+                        break
+                    empty_replies += 1
+                    if empty_replies >= 2:
+                        final = ""
+                        break
+                    self.messages.append(
+                        Message.user(
+                            "(Your reply was empty. Continue the task, or call `terminate` if it is done.)"
+                        )
+                    )
+                    continue
+
+                stop = False
+                for call in response.tool_calls:
+                    tool = self.tools.get(call.name)
+                    summary = tool.assess(call.arguments).summary if tool else f"{call.name}(?)"
+                    self.ui.on_tool_call(call, summary)
+                    if tool is None:
+                        result = ToolResult.fail(
+                            f"unknown tool '{call.name}'. Available tools: {', '.join(t.name for t in self.tools)}"
+                        )
+                    else:
+                        result = await self.sentinel.guard(call, tool)
+                    self.ui.on_tool_result(call, result)
+                    self.messages.append(Message.tool(result.for_model(), call.id, call.name))
+                    if result.stop:
+                        final = result.output
+                        stop = True
+                if stop:
+                    break
+                if self._is_stuck():
+                    logger.warning("agent seems stuck – nudging")
+                    self.messages.append(Message.user(prompts.STUCK_PROMPT))
+            else:
+                # Step budget exhausted: ask for a wrap-up without tools.
+                self.messages.append(Message.user(prompts.MAX_STEPS_PROMPT))
+                context = [Message.system(system_prompt), *self.context_messages()]
+                response = await self.llm.ask(context, tools=None, on_delta=self.ui.on_text_delta)
+                self.messages.append(response.to_message())
+                self.ui.on_assistant_message(response.content, response.reasoning)
+                final = response.content or "(step limit reached)"
+            self.state = AgentState.FINISHED
+        except Exception:
+            self.state = AgentState.ERROR
+            raise
+        finally:
+            self._save_session()
+        return final or ""
+
+    # ------------------------------------------------------------------ session persistence
+    def reset(self) -> None:
+        self.messages.clear()
+        self.sentinel.tainted = False
+        self.state = AgentState.IDLE
+
+    def _save_session(self) -> None:
+        if not self.session_file:
+            return
+        try:
+            self.session_file.parent.mkdir(parents=True, exist_ok=True)
+            data: dict[str, Any] = {
+                "saved_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "turns": self.turns,
+                "messages": [m.model_dump(mode="json") for m in self.messages],
+            }
+            self.session_file.write_text(json.dumps(data, ensure_ascii=False, indent=1), "utf-8")
+        except OSError as exc:  # pragma: no cover
+            logger.warning("could not save session: {}", exc)
+
+    def load_session(self, path: Path) -> int:
+        data = json.loads(Path(path).read_text("utf-8"))
+        self.messages = [Message.model_validate(m) for m in data.get("messages", [])]
+        self.turns = int(data.get("turns", 0))
+        return len(self.messages)
+
+
+__all__ = ["MuseAgent"]

openmuse/app.py

@@ -0,0 +1,150 @@
+"""Composition root: wires settings → stores, vault, Sentinel, tools, LLM, agent."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from openmuse import prompts
+from openmuse.agent import MuseAgent
+from openmuse.config import Settings
+from openmuse.goals import GoalStore
+from openmuse.llm import BaseLLM, create_llm
+from openmuse.logger import logger, setup_logging
+from openmuse.memory import MemoryStore
+from openmuse.sentinel import AuditLog, Sentinel
+from openmuse.tools import (
+    AskUser,
+    Browser,
+    Files,
+    Forget,
+    Goals,
+    MCPManager,
+    PythonExecute,
+    ReadEmails,
+    Recall,
+    Remember,
+    SendEmail,
+    Shell,
+    Terminate,
+    ToolCollection,
+    WebFetch,
+    WebSearch,
+    playwright_available,
+)
+from openmuse.ui import UI
+from openmuse.vault import CredentialVault
+
+
+class OpenMuseApp:
+    def __init__(
+        self, settings: Settings, ui: UI, llm: BaseLLM | None = None, session_id: str | None = None
+    ):
+        self.settings = settings
+        self.ui = ui
+        setup_logging(settings.log_level, settings.data_dir / "logs")
+        settings.ensure_dirs()
+        self.session_id = (
+            session_id or datetime.now().strftime("%Y%m%d-%H%M%S-") + uuid.uuid4().hex[:4]
+        )
+
+        self.vault = CredentialVault(settings.vault_file, settings.vault_key_file)
+        self.memory = MemoryStore(settings.memory_db) if settings.memory.enabled else None
+        self.goals = GoalStore(settings.goals_db)
+        self.audit = AuditLog(settings.audit_file, session_id=self.session_id)
+        self.sentinel = Sentinel(
+            settings.sentinel,
+            audit=self.audit,
+            ui=ui,
+            vault=self.vault,
+            persistent_approvals_file=settings.data_dir / "approvals.json",
+        )
+        self.llm = llm or create_llm(settings.llm)
+        self.mcp = MCPManager(settings.mcp.servers) if settings.mcp.servers else None
+        self.tools = self._build_tools()
+        self.agent = MuseAgent(
+            settings=settings,
+            llm=self.llm,
+            tools=self.tools,
+            sentinel=self.sentinel,
+            ui=ui,
+            audit=self.audit,
+            memory=self.memory,
+            goals=self.goals,
+            session_file=settings.data_dir / "sessions" / f"{self.session_id}.json",
+        )
+
+    # ------------------------------------------------------------------ tools
+    def _build_tools(self) -> ToolCollection:
+        s = self.settings
+        ws: Path = s.agent.workspace
+        tools = ToolCollection(
+            Terminate(),
+            AskUser(ui=self.ui),
+            Files(workspace=ws),
+            Shell(workspace=ws),
+            PythonExecute(workspace=ws),
+            WebSearch(),
+            WebFetch(),
+            Goals(store=self.goals),
+        )
+        if self.memory is not None:
+            tools.add(
+                Remember(store=self.memory), Recall(store=self.memory), Forget(store=self.memory)
+            )
+        if s.connectors.email.enabled:
+            tools.add(
+                ReadEmails(settings=s.connectors.email, vault=self.vault),
+                SendEmail(settings=s.connectors.email, vault=self.vault),
+            )
+        if s.browser.enabled:
+            if playwright_available():
+                tools.add(
+                    Browser(
+                        headless=s.browser.headless, timeout_ms=s.browser.timeout_ms, workspace=ws
+                    )
+                )
+            else:
+                logger.warning(
+                    "browser.enabled=true but playwright is missing: pip install 'openmuse[browser]'"
+                )
+        return tools
+
+    async def start(self) -> OpenMuseApp:
+        """Connect optional MCP servers. Call once before using the agent."""
+        if self.mcp is not None:
+            for tool in await self.mcp.connect():
+                self.tools.add(tool)
+        return self
+
+    async def close(self) -> None:
+        await self.tools.cleanup()
+        if self.mcp is not None:
+            await self.mcp.close()
+        await self.llm.close()
+        if self.memory is not None:
+            self.memory.close()
+        self.goals.close()
+
+    async def __aenter__(self) -> OpenMuseApp:
+        return await self.start()
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.close()
+
+    # ------------------------------------------------------------------ high-level ops
+    async def run(self, task: str) -> str:
+        return await self.agent.run(task)
+
+    async def advance_goal(self, goal_id: str) -> str:
+        goal = self.goals.get(goal_id)
+        if goal is None:
+            raise ValueError(f"no goal {goal_id}")
+        if goal.status != "active":
+            raise ValueError(f"goal {goal_id} is {goal.status}")
+        self.agent.reset()
+        return await self.agent.run(prompts.ADVANCE_GOAL_PROMPT.format(goal=goal.render()))
+
+
+__all__ = ["OpenMuseApp"]