Merge pull request #44 from XSpoonAi/fix/streaming-thinking-timeout

fix: forward thinking param in stream mode and harden stream timeout

Author: veithly

.env.example

@@ -62,6 +62,13 @@ OPENROUTER_API_KEY=sk-or-your-openrouter-api-key-here
 # Examples: 128000 (128K), 200000 (200K), 1000000 (1M)
 # CONTEXT_WINDOW=128000
 
+# ======= YOLO Mode (optional) =======
+#
+# When enabled, the agent operates directly in SPOON_BOT_WORKSPACE_PATH
+# without sandbox isolation — all shell commands and file operations run
+# against your real filesystem.  Useful for local dev workflows.
+# SPOON_BOT_YOLO_MODE=false
+
 # ======= Channel Bot Tokens (optional) =======
 # Set these to auto-enable channels without needing config.yaml.
 # If config.yaml also specifies a token, the YAML value takes priority.

Dockerfile

@@ -113,6 +113,15 @@ ENV SPOON_BOT_LOG_LEVEL=INFO
 # --- Workspace ---
 ENV SPOON_BOT_WORKSPACE_PATH=/data/workspace
 
+# --- YOLO Mode ---
+# When true, the agent operates directly in the user-mounted path
+# instead of the sandboxed /data/workspace.  Mount your host directory
+# to SPOON_BOT_WORKSPACE_PATH and set YOLO_MODE to activate.
+#   docker run -v /home/user/project:/project \
+#     -e SPOON_BOT_YOLO_MODE=true \
+#     -e SPOON_BOT_WORKSPACE_PATH=/project ...
+ENV SPOON_BOT_YOLO_MODE=false
+
 # Create workspace directory with correct ownership
 RUN mkdir -p /data/workspace/memory /data/workspace/skills \
     && chown -R spoonbot:spoonbot /data /app

config.example.yaml

@@ -16,6 +16,10 @@ agent:
   workspace: "~/.spoon-bot/workspace"
   max_iterations: 20
   tool_profile: "core"  # Options: core, coding, web3, research, full
+  # yolo_mode: false     # YOLO mode: work directly in `workspace` path
+                          # instead of a sandboxed directory.  The agent
+                          # reads/writes/executes against your real filesystem.
+                          # Enable via config or env: SPOON_BOT_YOLO_MODE=true
   # enabled_tools:        # Optional fine-grained override
   #   - shell
   #   - read_file

spoon_bot/agent/context.py

@@ -22,14 +22,17 @@ class ContextBuilder:
     BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md"]
     SANDBOX_WORKSPACE_ROOT = "/workspace"
 
-    def __init__(self, workspace: Path):
+    def __init__(self, workspace: Path, *, yolo_mode: bool = False):
         """
         Initialize context builder.
 
         Args:
             workspace: Path to the workspace directory.
+            yolo_mode: When True, the agent operates directly in the user's
+                       filesystem path without sandbox isolation.
         """
         self.workspace = Path(workspace).expanduser().resolve()
+        self.yolo_mode = yolo_mode
         self._memory_context: str = ""
         self._skills_summary: str = ""
         self._skill_context: str = ""
@@ -98,12 +101,20 @@ def _to_posix(p: str) -> str:
         else:
             shell_path = display_path
 
+        yolo_banner = ""
+        if self.yolo_mode:
+            yolo_banner = (
+                "\n**YOLO MODE ACTIVE** — You are operating directly on the "
+                "user's filesystem. All file reads, writes, and shell commands "
+                "execute against this real directory tree. Proceed with care.\n"
+            )
+
         return f"""# spoon-bot
 
 You are spoon-bot, an AI agent that completes tasks by calling tools.
 Current time: {now}
 Workspace: {display_path}
-
+{yolo_banner}
 ## Core Behavior — ALWAYS USE TOOLS
 
 You MUST use your tools to accomplish tasks. NEVER fabricate results, NEVER pretend to execute commands, NEVER invent output. If a tool exists for the job, call it.

spoon_bot/agent/loop.py

@@ -337,6 +337,7 @@ def __init__(
         auto_reload: bool = False,
         auto_reload_interval: float = 5.0,
         config_path: Path | str | None = None,
+        yolo_mode: bool = False,
     ) -> None:
         """
         Initialize the agent loop.
@@ -362,6 +363,7 @@ def __init__(
             session_store_dsn: PostgreSQL DSN for 'postgres' backend.
             session_store_db_path: SQLite DB path for 'sqlite' backend.
             context_window: Override context window in tokens (auto-resolved from model if None).
+            yolo_mode: Operate directly in user's path without sandbox isolation.
         """
         # Validate parameters
         try:
@@ -374,13 +376,15 @@ def __init__(
                 session_key=session_key,
                 skill_paths=skill_paths,
                 mcp_config=mcp_config,
+                yolo_mode=yolo_mode,
             )
         except Exception as e:
             logger.error(f"Configuration validation failed: {e}")
             raise ValueError(f"Invalid AgentLoop configuration: {e}") from e
 
         # Store config — callers must provide model/provider explicitly
         self.workspace = self._config.workspace
+        self.yolo_mode = self._config.yolo_mode
         self.model = model
         self.provider = provider
         self.api_key = api_key
@@ -405,9 +409,12 @@ def __init__(
         self._mcp_tools: list[MCPTool] = []
 
         # spoon-bot components
-        self.context = ContextBuilder(self.workspace)
+        self.context = ContextBuilder(self.workspace, yolo_mode=self.yolo_mode)
         self.tools = ToolRegistry()
 
+        if self.yolo_mode:
+            logger.info(f"YOLO mode enabled — operating directly in: {self.workspace}")
+
         # Session persistence — configurable backend
         _store_backend = session_store_backend or "file"
         _store_db_path = session_store_db_path
@@ -712,7 +719,12 @@ def _register_native_tools(self) -> None:
         # skill-managed data (e.g. ~/.agent-wallet, ~/.spoon-bot/skills) is
         # accessible.  The PathValidator blocklist still blocks truly sensitive
         # paths (.ssh, .aws, etc.).
-        _extra_read = [Path.home()]
+        #
+        # In YOLO mode the workspace IS the user's directory, so we add its
+        # parents as extra read paths to let the agent navigate freely.
+        _extra_read: list[Path] = [Path.home()]
+        if self.yolo_mode:
+            _extra_read.extend(p for p in self.workspace.parents if p != Path.home())
         self.tools.register(ReadFileTool(workspace=self.workspace, additional_read_paths=_extra_read, max_output=15000))
         self.tools.register(WriteFileTool(workspace=self.workspace))
         self.tools.register(EditFileTool(workspace=self.workspace))
@@ -2079,7 +2091,10 @@ async def stream(
             async def _run_and_signal() -> None:
                 nonlocal run_result_text
                 try:
-                    result = await self._agent.run()
+                    run_kwargs: dict[str, Any] = {}
+                    if thinking and self._callable_accepts_kwarg(self._agent.run, "thinking"):
+                        run_kwargs["thinking"] = True
+                    result = await self._agent.run(**run_kwargs)
                     if hasattr(result, "content"):
                         run_result_text = result.content or ""
                     elif isinstance(result, str):
@@ -2109,14 +2124,27 @@ async def _run_and_signal() -> None:
             oq = self._agent.output_queue
             td = self._agent.task_done
             logger.debug(f"output_queue type={type(oq).__name__}, task_done type={type(td).__name__}")
-            stream_timeout = 120.0
+            stream_timeout = 600.0 if thinking else 300.0
             deadline = asyncio.get_event_loop().time() + stream_timeout
             chunk_count = 0
 
             logger.debug(f"Entering stream loop: td={td.is_set()}, qempty={oq.empty()}, qsize={oq.qsize()}")
             while not (td.is_set() and oq.empty()):
                 if asyncio.get_event_loop().time() > deadline:
-                    logger.warning("Streaming deadline reached, stopping")
+                    logger.warning(
+                        f"Streaming deadline reached ({stream_timeout}s), "
+                        f"stopping after {chunk_count} chunks"
+                    )
+                    yield {
+                        "type": "error",
+                        "delta": f"Stream timeout after {int(stream_timeout)}s",
+                        "metadata": {
+                            "error": "STREAM_TIMEOUT",
+                            "error_code": "STREAM_TIMEOUT",
+                            "timeout_seconds": stream_timeout,
+                            "chunks_received": chunk_count,
+                        },
+                    }
                     break
 
                 try:
@@ -2815,6 +2843,7 @@ async def create_agent(
     auto_reload: bool = False,
     auto_reload_interval: float = 5.0,
     config_path: Path | str | None = None,
+    yolo_mode: bool = False,
     **kwargs: Any,
 ) -> AgentLoop:
     """
@@ -2839,6 +2868,7 @@ async def create_agent(
         auto_commit: Whether to auto-commit workspace changes after each message.
         enabled_tools: Explicit set of tool names to enable. None = core only.
         tool_profile: Named profile ('core', 'coding', 'web3', 'research', 'full').
+        yolo_mode: Operate directly in user's path without sandbox isolation.
         **kwargs: Additional arguments for AgentLoop.
 
     Returns:
@@ -2851,9 +2881,8 @@ async def create_agent(
         >>> # Load all tools
         >>> agent = await create_agent(tool_profile="full")
 
-        >>> # Dynamically add a tool after creation
-        >>> agent = await create_agent()
-        >>> agent.add_tool("web_search")
+        >>> # YOLO mode — work in /home/user/project directly
+        >>> agent = await create_agent(yolo_mode=True, workspace="/home/user/project")
     """
     agent = AgentLoop(
         model=model,
@@ -2871,6 +2900,7 @@ async def create_agent(
         auto_reload=auto_reload,
         auto_reload_interval=auto_reload_interval,
         config_path=config_path,
+        yolo_mode=yolo_mode,
         **kwargs,
     )
 

spoon_bot/channels/config.py

@@ -535,7 +535,7 @@ def load_agent_config(config_path: str | Path | None = None) -> dict[str, Any]:
 
     Supported fields::
 
-        model, provider, api_key, base_url, workspace,
+        model, provider, api_key, base_url, workspace, yolo_mode,
         max_iterations, tool_profile, enabled_tools, enable_skills,
         shell_timeout, max_output, context_window,
         session_store_backend, session_store_dsn, session_store_db_path,
@@ -683,19 +683,22 @@ def _resolve_env_deep(value: Any) -> Any:
         "workspace":      ["SPOON_BOT_WORKSPACE_PATH"],
         "max_iterations": ["SPOON_BOT_MAX_ITERATIONS", "SPOON_MAX_STEPS"],
         "enable_skills":  ["SPOON_BOT_ENABLE_SKILLS"],
+        "yolo_mode":      ["SPOON_BOT_YOLO_MODE"],
         "shell_timeout":  ["SPOON_BOT_SHELL_TIMEOUT"],
         "max_output":     ["SPOON_BOT_MAX_OUTPUT"],
         "context_window": ["CONTEXT_WINDOW"],
     }
+    _bool_fields = {"enable_skills", "yolo_mode"}
+    _int_fields = {"max_iterations", "shell_timeout", "max_output", "context_window"}
     for field, env_vars in agent_env_map.items():
         if not resolved.get(field):
             for var in env_vars:
                 val = os.environ.get(var)
                 if val:
-                    if field in {"max_iterations", "shell_timeout", "max_output", "context_window"}:
+                    if field in _int_fields:
                         resolved[field] = int(val)
-                    elif field == "enable_skills":
-                        resolved[field] = val.lower() == "true"
+                    elif field in _bool_fields:
+                        resolved[field] = val.lower() in ("true", "1", "yes")
                     else:
                         resolved[field] = val
                     logger.debug(f"Agent config: {field} from env var {var}")

spoon_bot/config.py

@@ -362,6 +362,16 @@ class AgentLoopConfig(BaseModel):
         default_factory=lambda: Path.home() / ".spoon-bot" / "workspace",
         description="Workspace directory path"
     )
+
+    yolo_mode: bool = Field(
+        default=False,
+        description=(
+            "YOLO mode: operate directly in the user's filesystem path "
+            "instead of the sandboxed workspace. When enabled, the agent "
+            "reads/writes files and runs commands in 'workspace' as a plain "
+            "directory without sandbox isolation."
+        ),
+    )
     model: str | None = Field(
         default=None,
         description="LLM model name (uses provider default if not specified)"
@@ -468,12 +478,21 @@ def coerce_skill_paths(cls, v: list[Path | str] | None) -> list[Path]:
 
     @model_validator(mode="after")
     def validate_workspace_accessible(self) -> "AgentLoopConfig":
-        """Validate that workspace path can be created and is writable."""
+        """Validate that workspace path can be created and is writable.
+
+        In YOLO mode the directory must already exist; we skip the
+        mkdir + write-test since the user is responsible for the path.
+        """
+        if self.yolo_mode:
+            if not self.workspace.is_dir():
+                raise ValueError(
+                    f"YOLO mode workspace path does not exist: {self.workspace}"
+                )
+            return self
+
         try:
-            # Try to create the workspace directory
             self.workspace.mkdir(parents=True, exist_ok=True)
 
-            # Check if it's writable by creating a test file
             test_file = self.workspace / ".write_test"
             try:
                 test_file.touch()
@@ -559,6 +578,10 @@ class SpoonBotSettings(BaseSettings):
         default_factory=lambda: Path.home() / ".spoon-bot" / "workspace",
         description="Default workspace directory"
     )
+    yolo_mode: bool = Field(
+        default=False,
+        description="YOLO mode: operate in user's path instead of sandbox"
+    )
 
     # LLM settings
     default_provider: LLMProviderType = Field(
@@ -671,6 +694,7 @@ def validate_agent_loop_params(
     session_key: str = "default",
     skill_paths: list[Path | str] | None = None,
     mcp_config: dict[str, dict[str, Any]] | None = None,
+    yolo_mode: bool = False,
 ) -> AgentLoopConfig:
     """
     Validate AgentLoop initialization parameters.
@@ -684,6 +708,7 @@ def validate_agent_loop_params(
         session_key: Session identifier.
         skill_paths: Additional skill search paths.
         mcp_config: MCP server configurations.
+        yolo_mode: If True, operate directly in the user path without sandbox.
 
     Returns:
         Validated AgentLoopConfig.
@@ -696,6 +721,10 @@ def validate_agent_loop_params(
     if mcp_config:
         mcp_servers = validate_mcp_configs(mcp_config)
 
+    # In YOLO mode, default workspace to CWD instead of ~/.spoon-bot/workspace
+    if yolo_mode and workspace is None:
+        workspace = Path.cwd()
+
     return AgentLoopConfig(
         workspace=workspace,  # type: ignore
         model=model,
@@ -705,4 +734,5 @@ def validate_agent_loop_params(
         session_key=session_key,
         skill_paths=skill_paths,  # type: ignore
         mcp_servers=mcp_servers,
+        yolo_mode=yolo_mode,
     )

spoon_bot/gateway/server.py

@@ -91,6 +91,14 @@ async def _lifespan(app: FastAPI):
         _ctx_env = os.environ.get("CONTEXT_WINDOW")
         context_window = int(_ctx_env) if _ctx_env else None
 
+        # YOLO mode: operate directly in user's path without sandbox
+        yolo_mode = (
+            agent_cfg.get("yolo_mode")
+            or os.environ.get("SPOON_BOT_YOLO_MODE", "").lower() in ("1", "true", "yes")
+        )
+        if yolo_mode:
+            logger.info("YOLO mode enabled — agent will work directly in user path")
+
         create_kwargs: dict = dict(
             model=model,
             provider=provider,
@@ -103,6 +111,7 @@ async def _lifespan(app: FastAPI):
             session_store_dsn=session_store_dsn,
             session_store_db_path=session_store_db_path,
             context_window=context_window,
+            yolo_mode=bool(yolo_mode),
         )
         if agent_cfg.get("mcp_config") is not None:
             create_kwargs["mcp_config"] = agent_cfg["mcp_config"]
@@ -179,6 +188,7 @@ async def _lifespan(app: FastAPI):
     logger.info(f"  Provider : {agent_cfg.get('provider', '(not set)')}")
     logger.info(f"  Model    : {agent_cfg.get('model', '(not set)')}")
     logger.info(f"  Workspace: {agent_cfg.get('workspace', '/data/workspace')}")
+    logger.info(f"  YOLO mode: {bool(yolo_mode)}")
     if channel_manager:
         logger.info(
             f"  Channels : {channel_manager.running_channels_count} running "

spoon_bot/gateway/websocket/handler.py

@@ -433,12 +433,13 @@ def __init__(self, connection_id: str, session_id: str | None = None):
         self._concurrent_tasks: set[asyncio.Task] = set()
         agent = get_agent()
         workspace = Path(getattr(agent, "workspace", Path.home() / ".spoon-bot" / "workspace"))
+        yolo_mode = bool(getattr(agent, "yolo_mode", False))
         self._sandbox_id = _runtime_sandbox_id()
         self._workspace_watch_service = WorkspaceWatchService(
             workspace_root=workspace,
             emit_change=self._emit_workspace_change,
         )
-        self._workspace_fs_service = WorkspaceFSService(workspace_root=workspace)
+        self._workspace_fs_service = WorkspaceFSService(workspace_root=workspace, yolo_mode=yolo_mode)
         self._workspace_terminal_service = WorkspaceTerminalService(
             workspace_root=workspace,
             emit_stdout=self._emit_terminal_stdout,