loopy-agent-fs 0.0.2__py3-none-any.whl

loopy/__init__.py

@@ -0,0 +1,66 @@
+"""loopy — an extensible, evaluable agent SDK."""
+
+from loopy._version import __version__
+from loopy.agent import Agent
+from loopy.errors import (
+    ConfigError,
+    LLMError,
+    LLMLoopError,
+    LoopyError,
+    SessionCancelledError,
+    SessionError,
+    ToolError,
+    ToolExecutionError,
+    ToolNotFoundError,
+)
+from loopy.events import CompositeEventSink, EventSink
+from loopy.logging import JsonlSink
+from loopy.session import Session
+from loopy.tools.base import (
+    BatchTool,
+    StreamingTool,
+    Tool,
+    ToolContext,
+    ToolMethod,
+    ToolResult,
+)
+from loopy.tools.builtins import AskUserQuestion, Bash, Grep, Write, Read, Edit, Exec
+from loopy.client import ToolClient
+from loopy.tools.runtime import ToolRuntime
+from loopy.types import FinalResponse, RedactedThinkingBlock, ThinkingBlock
+
+__all__ = [
+    "Agent",
+    "AskUserQuestion",
+    "Bash",
+    "BatchTool",
+    "CompositeEventSink",
+    "ConfigError",
+    "EventSink",
+    "FinalResponse",
+    "Grep",
+    "JsonlSink",
+    "LLMError",
+    "LLMLoopError",
+    "LoopyError",
+    "RedactedThinkingBlock",
+    "Session",
+    "SessionCancelledError",
+    "SessionError",
+    "StreamingTool",
+    "ThinkingBlock",
+    "Tool",
+    "ToolContext",
+    "ToolMethod",
+    "ToolRuntime",
+    "ToolClient",
+    "ToolError",
+    "ToolExecutionError",
+    "ToolNotFoundError",
+    "ToolResult",
+    "Write",
+    "Read",
+    "Edit",
+    "Exec",
+    "__version__",
+]

loopy/_version.py

@@ -0,0 +1 @@
+__version__ = "0.0.2"

loopy/agent.py

@@ -0,0 +1,277 @@
+"""Agent configuration and session lifecycle."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from loopy.errors import ConfigError, SessionError
+from loopy.events import CompositeEventSink, EventSink
+from loopy.llm import LLMClient
+from loopy.logging.jsonl import JsonlSink
+from loopy.session import Session
+from loopy.tools.builtins import AskUserQuestion
+from loopy.tools.builtins.ask_user import Handler
+from loopy.tools.dispatcher import ToolDispatcher
+from loopy.tools.registry import ToolRegistry
+from loopy.tools.runtime import ToolRuntime
+from loopy.types import Message
+
+
+class Agent:
+    def __init__(
+        self,
+        *,
+        name: str,
+        system_prompt: str,
+        model: str,
+        working_dir: Path,
+        tool_runtime: ToolRuntime,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        max_tokens: int = 4096,
+        thinking: dict[str, Any] | None = None,
+        tagged_thinking_compat: bool = False,
+        event_sinks: list[EventSink] | None = None,
+        stream_responses: bool = False,
+        max_output_continuations: int = 3,
+        context_config=None,
+        context_summarizer=None,
+        ask_user_handler: Handler | None = None,
+        client_factory: Callable[..., Any] | None = None,
+    ) -> None:
+        if not name:
+            raise ConfigError("name must be non-empty")
+        if not system_prompt:
+            raise ConfigError("system_prompt must be non-empty")
+        if not model:
+            raise ConfigError("model must be non-empty")
+        if max_tokens <= 0:
+            raise ConfigError("max_tokens must be greater than zero")
+        if max_output_continuations < 0:
+            raise ConfigError("max_output_continuations must be non-negative")
+
+        self.name = name
+        self.system_prompt = system_prompt
+        self.model = model
+        self.max_output_continuations = max_output_continuations
+        self._event_sinks = tuple(event_sinks or ())
+        self.stream_responses = stream_responses
+        self.working_dir = Path(working_dir).resolve()
+        if not self.working_dir.is_dir():
+            raise ConfigError(
+                f"working_dir does not exist or is not a directory: {self.working_dir}"
+            )
+        (self.working_dir / "sessions").mkdir(parents=True, exist_ok=True)
+
+        if not isinstance(tool_runtime, ToolRuntime):
+            raise ConfigError("tool_runtime must be a ToolRuntime instance")
+        if tool_runtime.closed:
+            raise ConfigError("tool_runtime is closed")
+        if tool_runtime.working_dir != self.working_dir:
+            raise ConfigError("tool_runtime working_dir does not match Agent")
+        self.tool_runtime = tool_runtime
+
+        if ask_user_handler is not None:
+            if any(tool.name == "Ask_User_Question" for tool in self.registry.all()):
+                raise ConfigError(
+                    "AskUserQuestion registered twice; pass ask_user_handler or the tool"
+                )
+            self.registry.register(AskUserQuestion(on_answer=ask_user_handler))
+
+        if client_factory is not None:
+            self.llm = client_factory(model=model, api_key=api_key)
+        else:
+            self.llm = LLMClient(
+                model=model,
+                api_key=api_key,
+                base_url=base_url,
+                max_tokens=max_tokens,
+                thinking=thinking,
+                tagged_thinking_compat=tagged_thinking_compat,
+            )
+
+        self.context_config = context_config
+        self.context_summarizer = context_summarizer
+        self._sessions: list[Session] = []
+        self._closed = False
+
+    @property
+    def registry(self) -> ToolRegistry:
+        """Access the registry owned by this Agent's runtime."""
+        return self.tool_runtime.registry
+
+    def new_session(self, session_id: str | None = None) -> Session:
+        if self._closed:
+            raise SessionError("agent is closed")
+        if session_id is not None and not session_id:
+            raise SessionError("session_id must be non-empty")
+        return self._create_live_session(
+            session_id if session_id is not None else self.tool_runtime.session_id,
+            messages=[],
+        )
+
+    def resume_session(self, session_id: str, messages: list[Message]) -> Session:
+        """Create a writable session from a caller-owned canonical history."""
+        if not session_id:
+            raise SessionError("session_id must be non-empty")
+        if not isinstance(messages, list):
+            raise SessionError("messages must be a list")
+        return self._create_live_session(session_id, messages=list(messages), resumed=True)
+
+    def resume_stored_session(self, session_id: str) -> Session:
+        if self.context_config is None:
+            raise SessionError('Stored context requires context_config')
+        return self._create_live_session(session_id, messages=[], resumed=True, stored=True)
+
+    def _create_live_session(
+        self,
+        session_id: str,
+        *,
+        messages: list[Message],
+        resumed: bool = False,
+        stored: bool = False,
+    ) -> Session:
+        if self._closed:
+            raise SessionError("agent is closed")
+        ToolDispatcher._check_id(session_id)
+        if self.tool_runtime.closed or session_id != self.tool_runtime.session_id:
+            raise SessionError("runtime is closed or session_id does not match")
+        if self.tool_runtime.model_active:
+            raise SessionError("runtime already has an active model run")
+        session_dir = self.working_dir / "sessions" / session_id
+        session_dir.mkdir(parents=True, exist_ok=True)
+        if self.context_config is not None:
+            bound = getattr(self.tool_runtime, 'context_session', None)
+            if bound is not None and not bound.closed:
+                raise SessionError('Runtime already has a bound context session')
+            if not stored and (session_dir / 'context' / 'HEAD.json').exists():
+                raise SessionError('Stored context exists; use resume_stored_session')
+        log_sink = JsonlSink(session_dir / "messages.jsonl")
+        sink: EventSink = (
+            CompositeEventSink(log_sink, *self._event_sinks) if self._event_sinks else log_sink
+        )
+        lifecycle_event = "session_resumed" if resumed else "session_created"
+        sink.emit(
+            lifecycle_event,
+            {
+                "session_id": session_id,
+                "system_prompt": self.system_prompt,
+                "model": self.model,
+                "working_dir": str(self.working_dir),
+                "resumed": resumed,
+            },
+        )
+        runtime = self.tool_runtime
+        dispatcher = runtime.dispatcher
+        session = Session(
+            agent=self,
+            session_id=session_id,
+            messages=messages,
+            sink=sink,
+            log_sink=log_sink,
+            working_dir=self.working_dir,
+            dispatcher=dispatcher,
+            tool_runtime=runtime,
+            _last_emitted_index=len(messages),
+        )
+        if self.context_config is not None:
+            from loopy.context import ContextConfig, ContextSession, ContextTool, LLMSummarizer
+
+            config = (
+                ContextConfig(**self.context_config)
+                if isinstance(self.context_config, dict)
+                else self.context_config
+            )
+            root = session_dir / "context"
+            if messages and (root / "HEAD.json").exists():
+                raise SessionError("Stored context exists; use resume_stored_session")
+            if stored and not (root / "HEAD.json").exists():
+                raise SessionError("Stored context not found")
+            context = ContextSession(
+                root,
+                config=config,
+                summarizer=self.context_summarizer
+                or LLMSummarizer(self.llm, config.summary_timeout),
+                sink=sink,
+            )
+            for message in messages:
+                context.append_message(message)
+            context.end_turn()
+            session.context = context
+            runtime.context_session = context
+            if not any(t.name == "Context" for t in runtime.registry.all()):
+                runtime.register(ContextTool(runtime))
+        self._sessions.append(session)
+        return session
+
+    def get_session(self, session_id: str) -> Session:
+        session_dir = self.working_dir / "sessions" / session_id
+        log_path = session_dir / "messages.jsonl"
+        if not log_path.is_file():
+            raise SessionError(f"session not found: {session_id}")
+
+        messages: list[dict] = []
+        for event in JsonlSink.read_all(log_path):
+            if event.get("event") != "message":
+                continue
+            payload = event.get("payload") or {}
+            messages.append(
+                {
+                    "role": payload.get("role"),
+                    "content": list(payload.get("content") or []),
+                }
+            )
+        return Session(
+            agent=self,
+            session_id=session_id,
+            messages=messages,
+            sink=None,
+            working_dir=self.working_dir,
+            dispatcher=None,
+            read_only=True,
+            _last_emitted_index=len(messages),
+        )
+
+    async def aclose(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+
+        for session in self._sessions:
+            session.cancel()
+        await asyncio.gather(
+            *(
+                s._active_run
+                for s in self._sessions
+                if s._active_run and s._active_run is not asyncio.current_task()
+            ),
+            return_exceptions=True,
+        )
+        errors = []
+
+        for session in self._sessions:
+            if session.context is not None:
+                await session.context.aclose()
+                if getattr(self.tool_runtime, "context_session", None) is session.context:
+                    self.tool_runtime.context_session = None
+            if session.log_sink is not None:
+                session.log_sink.close()
+
+        client = getattr(self.llm, "_client", None)
+        aclose = getattr(client, "aclose", None)
+        if aclose is not None:
+            try:
+                await aclose()
+            except Exception as exc:
+                errors.append(exc)
+        if errors:
+            raise ExceptionGroup("Agent cleanup failed", errors)
+
+    def _resolve_dispatcher(self, session: Session) -> ToolDispatcher:
+        """Compatibility helper for callers that used the internal method."""
+        if session.dispatcher is None:
+            raise SessionError("Session has no dispatcher")
+        return session.dispatcher

loopy/application/__init__.py

@@ -0,0 +1,15 @@
+"""Application SDK. Importing the core SDK does not load this package."""
+__all__ = ["LoopyApplication", "LoopyClient", "Settings"]
+
+
+def __getattr__(name):
+    if name == "LoopyApplication":
+        from .application import LoopyApplication
+        return LoopyApplication
+    if name == "LoopyClient":
+        from .client import LoopyClient
+        return LoopyClient
+    if name == "Settings":
+        from .config import Settings
+        return Settings
+    raise AttributeError(name)