EvoScientist 0.0.1.dev3__tar.gz → 0.0.1.dev5__tar.gz

{evoscientist-0.0.1.dev3 → evoscientist-0.0.1.dev5}/EvoScientist/EvoScientist.py

@@ -13,22 +13,24 @@ Usage:
         ...
 """
 
-import os
 from datetime import datetime
 from pathlib import Path
 
 from deepagents import create_deep_agent
 from deepagents.backends import FilesystemBackend, CompositeBackend
-from langchain.chat_models import init_chat_model
 
 from .backends import CustomSandboxBackend, MergedReadOnlyBackend
+from .config import get_effective_config, apply_config_to_env
+from .llm import get_chat_model
+from .mcp import load_mcp_tools
 from .middleware import create_skills_middleware, create_memory_middleware
 from .prompts import RESEARCHER_INSTRUCTIONS, get_system_prompt
 from .utils import load_subagents
-from .tools import tavily_search, think_tool, skill_manager
+from .tools import tavily_search, think_tool, skill_manager, view_image
 from .paths import (
     ensure_dirs,
     default_workspace_dir,
+    set_active_workspace,
     MEMORY_DIR as _MEMORY_DIR_PATH,
     USER_SKILLS_DIR as _USER_SKILLS_DIR_PATH,
 )
@@ -37,16 +39,21 @@ from .paths import (
 # Configuration
 # =============================================================================
 
+# Load configuration from file/env/defaults
+_config = get_effective_config()
+apply_config_to_env(_config)
+
 # Backend mode: "sandbox" (with execute) or "filesystem" (read/write only)
 BACKEND_MODE = "sandbox"
 
-# Research limits
-MAX_CONCURRENT = 3  # Max parallel sub-agents
-MAX_ITERATIONS = 3  # Max delegation rounds
+# Research limits (from config)
+MAX_CONCURRENT = _config.max_concurrent
+MAX_ITERATIONS = _config.max_iterations
 
 # Workspace settings
 ensure_dirs()
 WORKSPACE_DIR = str(default_workspace_dir())
+set_active_workspace(WORKSPACE_DIR)
 MEMORY_DIR = str(_MEMORY_DIR_PATH)  # Shared across sessions (not per-session)
 SKILLS_DIR = str(Path(__file__).parent / "skills")
 USER_SKILLS_DIR = str(_USER_SKILLS_DIR_PATH)
@@ -65,11 +72,10 @@ SYSTEM_PROMPT = get_system_prompt(
     max_iterations=MAX_ITERATIONS,
 )
 
-# Initialize chat model
-chat_model = init_chat_model(
-    model="claude-sonnet-4-5-20250929",
-    model_provider="anthropic",
-    # thinking={"type": "enabled", "budget_tokens": 2000},
+# Initialize chat model using the LLM module (respects config settings)
+chat_model = get_chat_model(
+    model=_config.model,
+    provider=_config.provider,
 )
 
 # Initialize workspace backend based on mode
@@ -109,33 +115,84 @@ backend = CompositeBackend(
 tool_registry = {
     "think_tool": think_tool,
     "tavily_search": tavily_search,
+    "view_image": view_image,
 }
 
+# Base tools that every agent variant gets (before MCP)
+BASE_TOOLS = [think_tool, skill_manager, view_image]
+
+
+def _build_base_kwargs(base_backend, base_middleware):
+    """Build agent kwargs *without* MCP (fast, no subprocess spawning)."""
+    subs = load_subagents(
+        SUBAGENTS_CONFIG,
+        tool_registry=tool_registry,
+        prompt_refs=prompt_refs,
+    )
+    return dict(
+        name="EvoScientist",
+        model=chat_model,
+        tools=list(BASE_TOOLS),
+        backend=base_backend,
+        subagents=subs,
+        middleware=base_middleware,
+        system_prompt=SYSTEM_PROMPT,
+    )
+
+
+def load_mcp_and_build_kwargs(base_backend, base_middleware):
+    """(Re-)load MCP tools and build agent kwargs.
+
+    Called on every ``create_cli_agent()`` call so that ``/new`` picks up
+    MCP config changes. Falls back to base kwargs if no MCP configured.
+    """
+    mcp_by_agent = load_mcp_tools()
+    if not mcp_by_agent:
+        return _build_base_kwargs(base_backend, base_middleware)
+
+    # Fresh tool registry — start from base tools + MCP tools
+    registry = dict(tool_registry)
+    for tools in mcp_by_agent.values():
+        for t in tools:
+            registry[t.name] = t
+
+    mcp_main = mcp_by_agent.pop("main", [])
+
+    subs = load_subagents(
+        SUBAGENTS_CONFIG,
+        tool_registry=registry,
+        prompt_refs=prompt_refs,
+    )
+
+    # Inject MCP tools into subagents by name
+    for sa in subs:
+        if sa_tools := mcp_by_agent.get(sa["name"], []):
+            sa.setdefault("tools", []).extend(sa_tools)
+
+    return dict(
+        name="EvoScientist",
+        model=chat_model,
+        tools=BASE_TOOLS + mcp_main,
+        backend=base_backend,
+        subagents=subs,
+        middleware=base_middleware,
+        system_prompt=SYSTEM_PROMPT,
+    )
+
+
 prompt_refs = {
     "RESEARCHER_INSTRUCTIONS": RESEARCHER_INSTRUCTIONS.format(date=current_date),
 }
 
-subagents = load_subagents(
-    SUBAGENTS_CONFIG,
-    tool_registry=tool_registry,
-    prompt_refs=prompt_refs,
-)
+base_middleware = [
+    create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
+    create_skills_middleware(backend),
+]
 
-# Shared kwargs for agent creation
-_AGENT_KWARGS = dict(
-    name="EvoScientist",
-    model=chat_model,
-    tools=[think_tool, skill_manager],
-    backend=backend,
-    subagents=subagents,
-    middleware=[
-        create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
-        create_skills_middleware(SKILLS_DIR, user_skills_dir=USER_SKILLS_DIR),
-    ],
-    system_prompt=SYSTEM_PROMPT,
-)
-
-# Default agent (no checkpointer) — used by langgraph dev / LangSmith / notebooks
+# Default agent (no checkpointer) — used by langgraph dev / LangSmith / notebooks.
+# Built WITHOUT MCP at import time to avoid spawning subprocesses on every import.
+# MCP tools are loaded on-demand in create_cli_agent().
+_AGENT_KWARGS = _build_base_kwargs(backend, base_middleware)
 EvoScientist_agent = create_deep_agent(**_AGENT_KWARGS).with_config({"recursion_limit": 500})
 
 
@@ -150,6 +207,7 @@ def create_cli_agent(workspace_dir: str | None = None):
     from langgraph.checkpoint.memory import InMemorySaver  # type: ignore[import-untyped]
 
     if workspace_dir:
+        set_active_workspace(workspace_dir)
         ws_backend = CustomSandboxBackend(
             root_dir=workspace_dir,
             virtual_mode=True,
@@ -171,17 +229,16 @@ def create_cli_agent(workspace_dir: str | None = None):
                 "/memory/": mem_backend,
             },
         )
-        mw = [
-            create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
-            create_skills_middleware(SKILLS_DIR, user_skills_dir=USER_SKILLS_DIR),
-        ]
-        kwargs = dict(
-            _AGENT_KWARGS,
-            backend=be,
-            middleware=mw,
-        )
     else:
-        kwargs = dict(_AGENT_KWARGS)
+        be = backend
+
+    mw = [
+        create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
+        create_skills_middleware(be),
+    ]
+
+    # Re-load MCP tools from current config (picks up /mcp add changes)
+    kwargs = load_mcp_and_build_kwargs(be, mw)
 
     return create_deep_agent(
         **kwargs,

evoscientist-0.0.1.dev5/EvoScientist/__init__.py

@@ -0,0 +1,60 @@
+"""EvoScientist Agent - AI-powered research and code execution.
+
+This package exposes a convenience API at the package root while keeping
+imports lazy, so lightweight modules (for example config helpers) can be used
+without importing heavy runtime dependencies.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+
+_EXPORTS: dict[str, tuple[str, str]] = {
+    # Agent graph (lazy to avoid expensive initialization at import time)
+    "EvoScientist_agent": (".EvoScientist", "EvoScientist_agent"),
+    "create_cli_agent": (".EvoScientist", "create_cli_agent"),
+    # Backends
+    "CustomSandboxBackend": (".backends", "CustomSandboxBackend"),
+    "ReadOnlyFilesystemBackend": (".backends", "ReadOnlyFilesystemBackend"),
+    # Configuration
+    "EvoScientistConfig": (".config", "EvoScientistConfig"),
+    "load_config": (".config", "load_config"),
+    "save_config": (".config", "save_config"),
+    "get_effective_config": (".config", "get_effective_config"),
+    "get_config_path": (".config", "get_config_path"),
+    # LLM
+    "get_chat_model": (".llm", "get_chat_model"),
+    "MODELS": (".llm", "MODELS"),
+    "list_models": (".llm", "list_models"),
+    "DEFAULT_MODEL": (".llm", "DEFAULT_MODEL"),
+    # Middleware
+    "create_skills_middleware": (".middleware", "create_skills_middleware"),
+    # Prompts
+    "get_system_prompt": (".prompts", "get_system_prompt"),
+    "RESEARCHER_INSTRUCTIONS": (".prompts", "RESEARCHER_INSTRUCTIONS"),
+    # Tools
+    "tavily_search": (".tools", "tavily_search"),
+    "think_tool": (".tools", "think_tool"),
+    "view_image": (".tools", "view_image"),
+}
+
+
+def __getattr__(name: str):
+    target = _EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    module_name, attr_name = target
+    module = import_module(module_name, package=__name__)
+    value = getattr(module, attr_name)
+    # Cache after first load to avoid repeated import lookups.
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_EXPORTS))
+
+
+__all__ = list(_EXPORTS)

{evoscientist-0.0.1.dev3 → evoscientist-0.0.1.dev5}/EvoScientist/backends.py

@@ -3,11 +3,13 @@
 import os
 import re
 import subprocess
+import uuid
 from pathlib import Path
 
 from deepagents.backends import FilesystemBackend
 from deepagents.backends.filesystem import WriteResult, EditResult
 from deepagents.backends.protocol import (
+    BackendProtocol,
     ExecuteResponse,
     FileDownloadResponse,
     FileUploadResponse,
@@ -132,7 +134,7 @@ class ReadOnlyFilesystemBackend(FilesystemBackend):
         )
 
 
-class MergedReadOnlyBackend:
+class MergedReadOnlyBackend(BackendProtocol):
     """Read-only backend that merges two directories.
 
     Reads from *primary* first (user skills in workspace/skills/),
@@ -205,27 +207,7 @@ class MergedReadOnlyBackend:
             error="This directory is read-only. Edit operations are not permitted here."
         )
 
-    # -- async variants (required by middleware) --
-
-    async def aread(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
-        return self.read(file_path, offset, limit)
-
-    async def als_info(self, path: str = "/") -> list:
-        return self.ls_info(path)
-
-    async def agrep_raw(self, pattern: str, path: str | None = None, glob: str | None = None) -> list:
-        return self.grep_raw(pattern, path, glob)
-
-    async def aglob_info(self, pattern: str, path: str = "/") -> list:
-        return self.glob_info(pattern, path)
-
-    async def awrite(self, file_path: str, content: str) -> WriteResult:
-        return self.write(file_path, content)
-
-    async def aedit(self, file_path: str, old_string: str, new_string: str, replace_all: bool = False) -> EditResult:
-        return self.edit(file_path, old_string, new_string, replace_all)
-
-    # -- download / upload (required by BackendProtocol) --
+    # -- download / upload --
 
     def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
         """Download files, trying primary then secondary."""
@@ -237,18 +219,12 @@ class MergedReadOnlyBackend:
             responses.append(resp)
         return responses
 
-    async def adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
-        return self.download_files(paths)
-
     def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
         return [
             FileUploadResponse(path=path, error="permission_denied")
             for path, _ in files
         ]
 
-    async def aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
-        return self.upload_files(files)
-
 
 class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
     """
@@ -269,6 +245,9 @@ class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
         working_dir: str | None = None,
         timeout: int = 300,
         shell: str = "/bin/bash",
+        max_output_bytes: int = 100_000,
+        env: dict[str, str] | None = None,
+        inherit_env: bool = True,
     ):
         """
         Initialize custom sandbox backend.
@@ -279,17 +258,33 @@ class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
             working_dir: Working directory for command execution (defaults to root_dir)
             timeout: Command execution timeout in seconds
             shell: Shell program to use
+            max_output_bytes: Max output size before truncation (default 100KB)
+            env: Extra environment variables for subprocess
+            inherit_env: Whether to inherit parent process env (default True)
         """
         super().__init__(root_dir=root_dir, virtual_mode=virtual_mode)
 
+        self._sandbox_id = f"evosci-{uuid.uuid4().hex[:8]}"
         self.working_dir = working_dir or root_dir
         self.timeout = timeout
         self.shell = shell
         self.virtual_mode = virtual_mode
+        self._max_output_bytes = max_output_bytes
+
+        # Build subprocess environment
+        if inherit_env:
+            self._env = {**os.environ, **(env or {})}
+        else:
+            self._env = dict(env) if env else {}
 
         # Ensure working directory exists
         os.makedirs(self.working_dir, exist_ok=True)
 
+    @property
+    def id(self) -> str:
+        """Unique identifier for the sandbox backend instance."""
+        return self._sandbox_id
+
     def _resolve_path(self, key: str) -> Path:
         """Resolve path with sanitization to prevent nested directories.
 
@@ -359,18 +354,30 @@ class CustomSandboxBackend(FilesystemBackend, SandboxBackendProtocol):
                 capture_output=True,
                 text=True,
                 timeout=self.timeout,
+                env=self._env,
             )
 
-            output = ""
+            output_parts = []
             if result.stdout:
-                output += result.stdout
+                output_parts.append(result.stdout)
             if result.stderr:
-                output += result.stderr
+                stderr_lines = result.stderr.strip().split("\n")
+                output_parts.extend(f"[stderr] {line}" for line in stderr_lines)
+            output = "\n".join(output_parts) if output_parts else ""
+
+            if result.returncode != 0:
+                output = f"{output.rstrip()}\n\nExit code: {result.returncode}"
+
+            truncated = False
+            if len(output) > self._max_output_bytes:
+                output = output[:self._max_output_bytes]
+                output += f"\n\n... Output truncated at {self._max_output_bytes} bytes."
+                truncated = True
 
             return ExecuteResponse(
                 output=output,
                 exit_code=result.returncode,
-                truncated=False,
+                truncated=truncated,
             )
 
         except subprocess.TimeoutExpired:

evoscientist-0.0.1.dev5/EvoScientist/channels/__init__.py

@@ -0,0 +1,9 @@
+"""Communication channels for EvoScientist.
+
+This module provides an extensible interface for different messaging channels
+(iMessage, WeChat, etc.) to communicate with the EvoScientist agent.
+"""
+
+from .base import Channel, IncomingMessage, OutgoingMessage
+
+__all__ = ["Channel", "IncomingMessage", "OutgoingMessage"]

evoscientist-0.0.1.dev5/EvoScientist/channels/base.py

@@ -0,0 +1,110 @@
+"""Abstract base class for communication channels.
+
+This module defines the Channel interface that all messaging channels
+(iMessage, WeChat, etc.) must implement.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import AsyncIterator
+
+
+@dataclass
+class IncomingMessage:
+    """Represents a message received from a channel."""
+
+    sender: str  # Phone number, email, or unique identifier
+    content: str  # Message text content
+    timestamp: datetime  # When the message was sent
+    message_id: str  # Unique identifier for the message
+    metadata: dict = field(default_factory=dict)  # Channel-specific metadata
+
+
+@dataclass
+class OutgoingMessage:
+    """Represents a message to be sent through a channel."""
+
+    recipient: str  # Phone number, email, or unique identifier
+    content: str  # Message text content
+    reply_to: str | None = None  # Optional message ID being replied to
+    metadata: dict = field(default_factory=dict)  # Channel-specific metadata
+
+
+class Channel(ABC):
+    """Abstract base class for messaging channels.
+
+    Subclasses must implement:
+    - start(): Initialize the channel (connect, authenticate, etc.)
+    - stop(): Clean up resources
+    - receive(): Async iterator yielding incoming messages
+    - send(): Send a message through the channel
+    """
+
+    @abstractmethod
+    async def start(self) -> None:
+        """Initialize and start the channel.
+
+        This method should:
+        - Establish connections
+        - Verify permissions/authentication
+        - Start any background tasks needed
+
+        Raises:
+            ChannelError: If initialization fails
+        """
+        pass
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop the channel and clean up resources.
+
+        This method should:
+        - Close connections
+        - Cancel background tasks
+        - Release any held resources
+        """
+        pass
+
+    @abstractmethod
+    async def receive(self) -> AsyncIterator[IncomingMessage]:
+        """Async iterator that yields incoming messages.
+
+        Yields:
+            IncomingMessage: Each new message received
+
+        Example:
+            async for msg in channel.receive():
+                print(f"From {msg.sender}: {msg.content}")
+        """
+        pass
+
+    @abstractmethod
+    async def send(self, message: OutgoingMessage) -> bool:
+        """Send a message through the channel.
+
+        Args:
+            message: The message to send
+
+        Returns:
+            True if sent successfully, False otherwise
+        """
+        pass
+
+
+class ChannelError(Exception):
+    """Base exception for channel-related errors."""
+
+    pass
+
+
+class ChannelPermissionError(ChannelError):
+    """Raised when the channel lacks required permissions."""
+
+    pass
+
+
+class ChannelConnectionError(ChannelError):
+    """Raised when the channel cannot establish a connection."""
+
+    pass

evoscientist-0.0.1.dev5/EvoScientist/channels/imessage/__init__.py

@@ -0,0 +1,33 @@
+"""iMessage channel implementation for EvoScientist.
+
+Uses imsg CLI via JSON-RPC for real-time message streaming.
+
+Requirements:
+- macOS only
+- imsg CLI: brew install steipete/tap/imsg
+- Full Disk Access permission
+- Messages.app logged into iCloud
+"""
+
+from .channel_rpc import IMessageChannelRpc as IMessageChannel
+from .channel_rpc import IMessageConfig
+from .probe import probe_imessage, ProbeResult
+from .targets import (
+    parse_target,
+    normalize_handle,
+    normalize_e164,
+    IMessageTarget,
+    IMessageService,
+)
+
+__all__ = [
+    "IMessageChannel",
+    "IMessageConfig",
+    "probe_imessage",
+    "ProbeResult",
+    "parse_target",
+    "normalize_handle",
+    "normalize_e164",
+    "IMessageTarget",
+    "IMessageService",
+]