EvoScientist 0.0.1.dev7__tar.gz → 0.0.1.dev8__tar.gz

{evoscientist-0.0.1.dev7 → evoscientist-0.0.1.dev8}/EvoScientist/EvoScientist.py

@@ -13,6 +13,7 @@ Usage:
         ...
 """
 
+import json
 from datetime import datetime
 from pathlib import Path
 
@@ -23,17 +24,12 @@ 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 .middleware import create_memory_middleware, ToolErrorHandlerMiddleware
 from .prompts import RESEARCHER_INSTRUCTIONS, get_system_prompt
 from .utils import load_subagents
 from .tools import tavily_search, think_tool, skill_manager
-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,
-)
+from . import paths as _paths_mod
+from .paths import set_active_workspace, set_workspace_root
 
 # =============================================================================
 # Configuration
@@ -43,20 +39,25 @@ from .paths import (
 _config = get_effective_config()
 apply_config_to_env(_config)
 
-# Backend mode: "sandbox" (with execute) or "filesystem" (read/write only)
-BACKEND_MODE = "sandbox"
+# NOTE: We intentionally do NOT call set_workspace_root() at module level.
+# The CLI (commands.py) calls set_workspace_root() *before* importing this
+# module.  A module-level call here would overwrite the CLI's --workdir
+# value with config.default_workdir, violating the priority chain
+# (CLI args > config file).  Instead, config.default_workdir is applied
+# as a fallback inside create_cli_agent() when no explicit workspace_dir
+# is provided.
 
 # Research limits (from config)
 MAX_CONCURRENT = _config.max_concurrent
 MAX_ITERATIONS = _config.max_iterations
 
-# Workspace settings
-ensure_dirs()
-WORKSPACE_DIR = str(default_workspace_dir())
+# Workspace settings (defer dir creation to CLI; here we just resolve paths)
+# Read from the paths module so values reflect any earlier set_workspace_root().
+WORKSPACE_DIR = str(_paths_mod.WORKSPACE_ROOT)
 set_active_workspace(WORKSPACE_DIR)
-MEMORY_DIR = str(_MEMORY_DIR_PATH)  # Shared across sessions (not per-session)
+MEMORY_DIR = str(_paths_mod.MEMORY_DIR)  # Shared across sessions (not per-session)
 SKILLS_DIR = str(Path(__file__).parent / "skills")
-USER_SKILLS_DIR = str(_USER_SKILLS_DIR_PATH)
+USER_SKILLS_DIR = str(_paths_mod.USER_SKILLS_DIR)
 SUBAGENTS_CONFIG = Path(__file__).parent / "subagent.yaml"
 
 # =============================================================================
@@ -78,18 +79,12 @@ chat_model = get_chat_model(
     provider=_config.provider,
 )
 
-# Initialize workspace backend based on mode
-if BACKEND_MODE == "sandbox":
-    _workspace_backend = CustomSandboxBackend(
-        root_dir=WORKSPACE_DIR,
-        virtual_mode=True,
-        timeout=300,
-    )
-else:
-    _workspace_backend = FilesystemBackend(
-        root_dir=WORKSPACE_DIR,
-        virtual_mode=True,
-    )
+# Initialize workspace backend
+_workspace_backend = CustomSandboxBackend(
+    root_dir=WORKSPACE_DIR,
+    virtual_mode=True,
+    timeout=300,
+)
 
 # Skills backend: merge user-installed (./skills/) and system (package) skills
 _skills_backend = MergedReadOnlyBackend(
@@ -120,6 +115,44 @@ tool_registry = {
 # Base tools that every agent variant gets (before MCP)
 BASE_TOOLS = [think_tool, skill_manager]
 
+# Cache MCP tools by the effective config signature to avoid reconnecting
+# to MCP servers on every `/new` when config is unchanged.
+_MCP_TOOLS_CACHE_KEY: str | None = None
+_MCP_TOOLS_CACHE_VALUE: dict[str, list] | None = None
+
+
+def _mcp_config_signature() -> str:
+    """Return a stable signature for the effective MCP config."""
+    from .mcp.client import load_mcp_config
+
+    cfg = load_mcp_config()
+    if not cfg:
+        return ""
+    try:
+        return json.dumps(cfg, sort_keys=True, ensure_ascii=True)
+    except TypeError:
+        # Fallback for non-JSON-serializable values (should be rare)
+        return repr(cfg)
+
+
+def _load_mcp_tools_cached() -> dict[str, list]:
+    """Load MCP tools with config-aware caching."""
+    global _MCP_TOOLS_CACHE_KEY, _MCP_TOOLS_CACHE_VALUE
+
+    cfg_key = _mcp_config_signature()
+    if not cfg_key:
+        _MCP_TOOLS_CACHE_KEY = ""
+        _MCP_TOOLS_CACHE_VALUE = {}
+        return {}
+
+    if _MCP_TOOLS_CACHE_KEY == cfg_key and _MCP_TOOLS_CACHE_VALUE is not None:
+        return {k: list(v) for k, v in _MCP_TOOLS_CACHE_VALUE.items()}
+
+    loaded = load_mcp_tools()
+    _MCP_TOOLS_CACHE_KEY = cfg_key
+    _MCP_TOOLS_CACHE_VALUE = {k: list(v) for k, v in loaded.items()}
+    return {k: list(v) for k, v in loaded.items()}
+
 
 def _build_base_kwargs(base_backend, base_middleware):
     """Build agent kwargs *without* MCP (fast, no subprocess spawning)."""
@@ -136,16 +169,17 @@ def _build_base_kwargs(base_backend, base_middleware):
         subagents=subs,
         middleware=base_middleware,
         system_prompt=SYSTEM_PROMPT,
+        skills=["/skills/"],
     )
 
 
 def load_mcp_and_build_kwargs(base_backend, base_middleware):
-    """(Re-)load MCP tools and build agent kwargs.
+    """Load MCP tools (cached by config) 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.
+    Re-connects to MCP servers only when the effective MCP config changes.
+    Falls back to base kwargs if no MCP configured.
     """
-    mcp_by_agent = load_mcp_tools()
+    mcp_by_agent = _load_mcp_tools_cached()
     if not mcp_by_agent:
         return _build_base_kwargs(base_backend, base_middleware)
 
@@ -176,6 +210,7 @@ def load_mcp_and_build_kwargs(base_backend, base_middleware):
         subagents=subs,
         middleware=base_middleware,
         system_prompt=SYSTEM_PROMPT,
+        skills=["/skills/"],
     )
 
 
@@ -184,8 +219,8 @@ prompt_refs = {
 }
 
 base_middleware = [
+    ToolErrorHandlerMiddleware(),
     create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
-    create_skills_middleware(backend),
 ]
 
 # Default agent (no checkpointer) — used by langgraph dev / LangSmith / notebooks.
@@ -214,46 +249,66 @@ def __getattr__(name: str):
 def create_cli_agent(workspace_dir: str | None = None, checkpointer=None):
     """Create agent with checkpointer for CLI multi-turn support.
 
+    A fresh backend is constructed on every call using the current
+    ``paths.WORKSPACE_ROOT`` (or the explicit *workspace_dir*), so
+    runtime ``set_workspace_root()`` changes are always respected.
+
     Args:
-        workspace_dir: Optional per-session workspace directory. If provided,
-            creates a fresh backend rooted at this path. If None, uses the
-            module-level default backend (./workspace).
-        checkpointer: Optional LangGraph checkpointer. If None, falls back
-            to ``InMemorySaver`` (non-persistent).
+        workspace_dir: Per-session workspace directory. If ``None``,
+            defaults to the current ``paths.WORKSPACE_ROOT``.
+        checkpointer: Optional LangGraph checkpointer. If ``None``,
+            falls back to ``InMemorySaver`` (non-persistent).
     """
+    import os as _os
+    from . import paths as _paths
+
     if checkpointer is None:
         from langgraph.checkpoint.memory import InMemorySaver  # type: ignore[import-untyped]
         checkpointer = InMemorySaver()
 
-    if workspace_dir:
-        set_active_workspace(workspace_dir)
-        ws_backend = CustomSandboxBackend(
-            root_dir=workspace_dir,
-            virtual_mode=True,
-            timeout=300,
-        )
-        sk_backend = MergedReadOnlyBackend(
-            primary_dir=USER_SKILLS_DIR,
-            secondary_dir=SKILLS_DIR,
-        )
-        # Memory always uses SHARED directory (not per-session) for cross-session persistence
-        mem_backend = FilesystemBackend(
-            root_dir=MEMORY_DIR,
-            virtual_mode=True,
-        )
-        be = CompositeBackend(
-            default=ws_backend,
-            routes={
-                "/skills/": sk_backend,
-                "/memory/": mem_backend,
-            },
-        )
-    else:
-        be = backend
+    # When no explicit workspace_dir is provided, apply config.default_workdir
+    # as a fallback.  This covers direct callers (notebooks, iMessage server)
+    # that never call set_workspace_root() themselves.  CLI callers always
+    # pass workspace_dir explicitly, so their --workdir is never overwritten.
+    if workspace_dir is None:
+        if _config.default_workdir:
+            set_workspace_root(
+                _os.path.abspath(_os.path.expanduser(_config.default_workdir))
+            )
+        workspace_dir = str(_paths.WORKSPACE_ROOT)
+
+    # Read paths dynamically so runtime set_workspace_root() changes are picked up
+    _mem_dir = str(_paths.MEMORY_DIR)
+    _usr_skills_dir = str(_paths.USER_SKILLS_DIR)
+
+    # Always construct fresh backends from current paths (avoids stale
+    # module-level backend when workspace root changed at runtime).
+    set_active_workspace(workspace_dir)
+    ws_backend = CustomSandboxBackend(
+        root_dir=workspace_dir,
+        virtual_mode=True,
+        timeout=300,
+    )
+    sk_backend = MergedReadOnlyBackend(
+        primary_dir=_usr_skills_dir,
+        secondary_dir=SKILLS_DIR,
+    )
+    # Memory always uses SHARED directory (not per-session) for cross-session persistence
+    mem_backend = FilesystemBackend(
+        root_dir=_mem_dir,
+        virtual_mode=True,
+    )
+    be = CompositeBackend(
+        default=ws_backend,
+        routes={
+            "/skills/": sk_backend,
+            "/memory/": mem_backend,
+        },
+    )
 
     mw = [
-        create_memory_middleware(MEMORY_DIR, extraction_model=chat_model),
-        create_skills_middleware(be),
+        ToolErrorHandlerMiddleware(),
+        create_memory_middleware(_mem_dir, extraction_model=chat_model),
     ]
 
     # Re-load MCP tools from current config (picks up /mcp add changes)

{evoscientist-0.0.1.dev7 → evoscientist-0.0.1.dev8}/EvoScientist/__init__.py

@@ -28,8 +28,6 @@ _EXPORTS: dict[str, tuple[str, str]] = {
     "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"),
@@ -45,6 +43,17 @@ _EXPORTS: dict[str, tuple[str, str]] = {
 
 
 def __getattr__(name: str):
+    """Lazily import and cache package-level attributes.
+
+    Args:
+        name: The attribute name to look up.
+
+    Returns:
+        The resolved attribute value.
+
+    Raises:
+        AttributeError: If the name is not in _EXPORTS.
+    """
     target = _EXPORTS.get(name)
     if target is None:
         raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
@@ -58,6 +67,7 @@ def __getattr__(name: str):
 
 
 def __dir__() -> list[str]:
+    """List available public attributes including lazy exports."""
     return sorted(set(globals()) | set(_EXPORTS))
 
 

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

@@ -0,0 +1,44 @@
+"""Communication channels for EvoScientist.
+
+This module provides an extensible interface for different messaging channels
+(iMessage, Telegram, Discord, Slack, WeChat) to communicate with the EvoScientist agent.
+"""
+
+from .base import Channel, RawIncoming, IncomingMessage, OutgoingMessage, chunk_text
+from .bus import MessageBus, InboundMessage, OutboundMessage
+from .capabilities import ChannelCapabilities
+from .channel_manager import ChannelManager, register_channel, create_channel, available_channels
+from .consumer import InboundConsumer
+from .formatter import UnifiedFormatter
+from .middleware import TypingManager
+from .plugin import ChannelPlugin, ChannelMeta, ReloadPolicy
+from .standalone import run_standalone
+
+# Backward compat: ChannelServer is now Channel itself
+ChannelServer = Channel
+
+__all__ = [
+    "Channel",
+    "ChannelServer",
+    "ChannelManager",
+    "MessageBus",
+    "RawIncoming",
+    "IncomingMessage",
+    "OutgoingMessage",
+    "InboundMessage",
+    "OutboundMessage",
+    "InboundConsumer",
+    "run_standalone",
+    "register_channel",
+    "create_channel",
+    "available_channels",
+    # New modules
+    "ChannelCapabilities",
+    "UnifiedFormatter",
+    "TypingManager",
+    "chunk_text",
+    # Plugin architecture
+    "ChannelPlugin",
+    "ChannelMeta",
+    "ReloadPolicy",
+]