Merge pull request #844 from ruska-ai/feat/843-sandbox-composer-position

Move sandbox status above chat composer

Author: ryaneggz

.claude/plans/parsed-swimming-pnueli.md

@@ -0,0 +1,50 @@
+# Plan: Fix Sandbox "State" Selection Still Using Daytona
+
+## Context
+
+**Bug**: User switches sandbox from "Daytona" to "State" in the UI, but the backend still executes commands in Daytona (confirmed by `pwd` returning `/home/daytona`).
+
+**Root cause**: `toSandboxPatchValue("state")` in `frontend/src/lib/config/sandbox.ts:48-50` converts the default value to `null` before sending to the backend. The backend stores `default_sandbox = None`. Then `resolve_sandbox_backend(None)` in `backend/src/agents/__init__.py:332-340` treats `None` as "auto" — try Daytona first, fall back to State. So selecting "State" effectively becomes "Auto" behavior.
+
+**Resolution path**: The frontend `toSandboxPatchValue` function should always send the literal string value (`"state"` or `"daytona"`), never `null`. This ensures the backend receives and stores `"state"` explicitly, and `resolve_sandbox_backend("state")` correctly routes to StateBackend without trying Daytona.
+
+## Changes
+
+### 1. Frontend: `frontend/src/lib/config/sandbox.ts`
+
+**`toSandboxPatchValue()`** — always return the literal value, never `null`:
+```typescript
+// BEFORE (buggy):
+export function toSandboxPatchValue(value: SandboxType): string | null {
+    return value === DEFAULT_SANDBOX ? null : value;
+}
+
+// AFTER (fixed):
+export function toSandboxPatchValue(value: SandboxType): string {
+    return value;
+}
+```
+
+### 2. Frontend: `frontend/src/components/status/ThreadSandboxStatus.test.tsx`
+
+Update the test assertion that checks the PATCH payload:
+```typescript
+// BEFORE:
+expect(mockPatchDefaults).toHaveBeenCalledWith({ sandbox: null });
+
+// AFTER:
+expect(mockPatchDefaults).toHaveBeenCalledWith({ sandbox: "state" });
+```
+
+## Files to Modify
+
+| File | Change |
+|------|--------|
+| `frontend/src/lib/config/sandbox.ts` | `toSandboxPatchValue` always returns the literal string |
+| `frontend/src/components/status/ThreadSandboxStatus.test.tsx` | Update expected PATCH payload from `null` to `"state"` |
+
+## Verification
+
+1. `cd frontend && npx vitest run src/components/status/ThreadSandboxStatus.test.tsx` — tests pass
+2. `cd frontend && npm run test` — all tests pass
+3. Manual: Set sandbox to "State" → run a command → `pwd` should NOT return `/home/daytona`

.claude/plans/rosy-launching-narwhal.md

@@ -0,0 +1,30 @@
+# Plan: Move Links Above ChatInput in AgentSection
+
+## Context
+On the `/chat` page (initial landing view), the links row (Docs, Blog, Social, Slack) currently renders **below** the ChatInput. The user wants them moved **between the subtext and the ChatInput** — i.e., above the input area.
+
+## File to Modify
+
+### `frontend/src/components/sections/agent-section.tsx`
+
+Current order (lines 22-90):
+1. `<p>` subtext (line 23)
+2. `<div>` ChatInput wrapper (lines 24-26)
+3. `<div>` links row (lines 29-90)
+
+Target order:
+1. `<p>` subtext (line 23)
+2. `<div>` links row — moved here, update comment and change `mt-3` → `mb-3`
+3. `<div>` ChatInput wrapper
+
+**Changes:**
+- Cut the links `<div>` block (lines 28-90) and paste it between line 23 (`<p>` subtext) and line 24 (`<div>` ChatInput wrapper)
+- Change `mt-3` to `mb-3` on the links container so spacing flows downward toward the input
+- Update the comment to reflect new position
+
+No other files need changes.
+
+## Verification
+1. `npx tsc --noEmit` from `frontend/` — no type errors
+2. `npm run test` — no test regressions
+3. Navigate to `/chat` — links row (Docs, Blog, Social, Slack) appears between subtext and ChatInput

.claude/plans/structured-sniffing-dahl.md

@@ -0,0 +1,20 @@
+# Fix CI Tests Not Running on Push
+
+## Context
+CI tests stopped running on feature branch pushes after commit `9952aa01` (Feb 23) restricted the push trigger in `test.yml` to only `development` and `main` branches. The `pull_request` trigger was also commented out. This means no tests run for any feature branch work.
+
+## Change
+**File:** `.github/workflows/test.yml`
+
+1. **Line 5-7**: Change push branch filter from explicit list to wildcard:
+   ```yaml
+   push:
+       branches:
+           - "*"
+   ```
+2. **Leave `pull_request` commented out** — not needed since push covers all branches now.
+
+## Verification
+- Push to the current feature branch (`feat/843-sandbox-composer-position`)
+- Confirm the Test workflow appears in GitHub Actions
+- Verify both `test-frontend` and `test-backend` jobs run

.github/workflows/test.yml

@@ -3,8 +3,7 @@ name: Test
 on:
     push:
         branches:
-            - "development"
-            - "main"
+            - "*"
         paths-ignore:
             - "Changelog.md"
             - "docker/**"

backend/src/agents/__init__.py

@@ -22,11 +22,13 @@
 # Conditional import for Daytona sandbox support
 try:
     from daytona import Daytona, DaytonaConfig
+    from daytona.common.errors import DaytonaError
     from langchain_daytona import DaytonaSandbox
 except ImportError:
     Daytona = None  # type: ignore[assignment,misc]
     DaytonaConfig = None  # type: ignore[assignment,misc]
     DaytonaSandbox = None  # type: ignore[assignment,misc]
+    DaytonaError = None  # type: ignore[assignment,misc]
 
 from src.constants import APP_ENV, DAYTONA_API_KEY
 from src.contexts.service import ServiceContext
@@ -43,6 +45,13 @@
 from src.tools import default_tools
 
 
+def is_daytona_error(exc: Exception) -> bool:
+    """Check if an exception is a DaytonaError (safe when package not installed)."""
+    if DaytonaError is None:
+        return False
+    return isinstance(exc, DaytonaError)
+
+
 CACHE_LLM = InMemoryCache()
 
 
@@ -306,7 +315,7 @@ def _create_state_backend(
 def resolve_sandbox_backend(
     runtime: ToolRuntime,
     sandbox_type: str | None = None,
-) -> tuple[CompositeBackend, Any]:
+) -> tuple[CompositeBackend, Any, str]:
     """Resolve a sandbox backend based on *sandbox_type*.
 
     Dispatch rules:
@@ -315,20 +324,23 @@ def resolve_sandbox_backend(
     * ``"daytona"`` — try Daytona, fall back to State if unavailable.
     * Any unknown value — treated as ``"auto"``.
 
-    Returns ``(backend, daytona_sandbox_or_None)``.
+    Returns ``(backend, daytona_sandbox_or_None, effective_type)``
+    where effective_type is ``"daytona"`` or ``"state"``.
     """
     effective = sandbox_type if sandbox_type in _SANDBOX_FACTORIES else None
 
     if effective == "state":
-        return _create_state_backend(runtime)
+        backend, sandbox = _create_state_backend(runtime)
+        return backend, sandbox, "state"
 
     # "daytona" or auto (None) — try Daytona first
     result = _create_daytona_backend_checked(runtime)
     if result is not None:
-        return result
+        return result[0], result[1], "daytona"
 
     # Fallback: plain StateBackend (silent, no messages)
-    return _create_state_backend(runtime)
+    backend, sandbox = _create_state_backend(runtime)
+    return backend, sandbox, "state"
 
 
 ################################################################################

backend/src/controllers/llm.py

@@ -11,8 +11,10 @@
 from src.agents import (
     construct_agent,
     init_config,
+    is_daytona_error,
     prepare_memory_files,
     resolve_sandbox_backend,
+    _create_state_backend,
 )
 from src.services.db import get_checkpoint_db
 from src.utils.stream import stream_generator
@@ -125,7 +127,7 @@ async def llm_invoke(self, params: LLMRequest):
 
             async with get_checkpoint_db() as checkpointer:
                 runtime = self._init_runtime(params)
-                backend, _sandbox = resolve_sandbox_backend(runtime, sandbox_type=default_sandbox)
+                backend, _sandbox, effective_type = resolve_sandbox_backend(runtime, sandbox_type=default_sandbox)
                 agent: Orchestra = await construct_agent(
                     instructions=params.instructions,
                     system_prompt=params.system_prompt,
@@ -145,6 +147,42 @@ async def llm_invoke(self, params: LLMRequest):
                 )
                 return response
         except Exception as e:
+            if is_daytona_error(e):
+                if default_sandbox == "daytona":
+                    # Explicit daytona mode: surface the detailed error
+                    logger.error(f"Daytona sandbox error (daytona mode): {e}")
+                    if agent and config:
+                        await self._update_store(agent, config)
+                    raise
+                elif default_sandbox in (None, "auto") and effective_type == "daytona":
+                    # Auto mode: fallback to local StateBackend and retry
+                    logger.warning(f"Daytona sandbox error in auto mode, falling back to local: {e}")
+                    try:
+                        fallback_backend, _ = _create_state_backend(runtime)
+                        agent = await construct_agent(
+                            instructions=params.instructions,
+                            system_prompt=params.system_prompt,
+                            model=params.model,
+                            tools=params.tools,
+                            subagents=params.subagents,
+                            checkpointer=checkpointer,
+                            backend=fallback_backend,
+                            service_context=self.service_context,
+                            api_key=api_key,
+                            memory=memory_sources,
+                        )
+                        response = await agent.invoke(
+                            params.input,
+                            config=config,
+                            context=self._init_context(params),
+                        )
+                        return response
+                    except Exception as fallback_err:
+                        logger.exception(f"Fallback also failed in llm_invoke: {fallback_err}")
+                        if agent and config:
+                            await self._update_store(agent, config)
+                        raise fallback_err
+
             logger.exception(f"Error in llm_invoke: {e}")
             if agent and config:
                 await self._update_store(agent, config)

backend/src/schemas/entities/settings.py

@@ -9,7 +9,6 @@
 class SandboxType(str, Enum):
     """Supported sandbox backend types."""
 
-    AUTO = "auto"
     DAYTONA = "daytona"
     STATE = "state"
 

backend/src/utils/stream.py

@@ -14,7 +14,13 @@
 from src.contexts.service import ServiceContext
 from src.schemas.entities import LLMInput
 from src.constants import APP_LOG_LEVEL
-from src.agents import construct_agent, resolve_sandbox_backend, prepare_memory_files
+from src.agents import (
+    construct_agent,
+    resolve_sandbox_backend,
+    prepare_memory_files,
+    is_daytona_error,
+    _create_state_backend,
+)
 from src.services.db import get_checkpoint_db
 from src.utils.messages import from_message_to_dict
 from langchain_core.messages import (
@@ -223,7 +229,7 @@ async def stream_generator(
                 stream_writer=lambda _: None,
                 config=config,
             )
-            backend, _sandbox = resolve_sandbox_backend(runtime, sandbox_type=sandbox_type)
+            backend, _sandbox, effective_type = resolve_sandbox_backend(runtime, sandbox_type=sandbox_type)
             agent = await construct_agent(
                 instructions=instructions,
                 system_prompt=system_prompt,
@@ -281,16 +287,62 @@ async def stream_generator(
         except PIIDetectionError as e:
             # Yield error as SSE if streaming fails
             logger.warning(f"Sensitive data detected in the query: {e}")
-            # raise HTTPException(status_code=500, detail=str(e))
             error_msg = ujson.dumps(("error", str(e)))
             yield f"data: {error_msg}\n\n"
 
         except Exception as e:
-            # Yield error as SSE if streaming fails
-            logger.exception("Error in stream_generator: %s", e)
-            # raise HTTPException(status_code=500, detail=str(e))
-            error_msg = ujson.dumps(("error", str(e)))
-            yield f"data: {error_msg}\n\n"
+            if is_daytona_error(e):
+                if sandbox_type == "daytona":
+                    # Explicit daytona mode: surface the detailed error
+                    logger.error(f"Daytona sandbox error (daytona mode): {e}")
+                    error_msg = ujson.dumps(("error", f"Daytona sandbox error: {e}"))
+                    yield f"data: {error_msg}\n\n"
+                elif sandbox_type in (None, "auto") and effective_type == "daytona":
+                    # Auto mode: fallback to local StateBackend and retry
+                    logger.warning(f"Daytona sandbox error in auto mode, falling back to local: {e}")
+                    try:
+                        fallback_backend, _ = _create_state_backend(runtime)
+                        agent = await construct_agent(
+                            instructions=instructions,
+                            system_prompt=system_prompt,
+                            model=model,
+                            tools=tools,
+                            subagents=subagents,
+                            checkpointer=checkpointer,
+                            backend=fallback_backend,
+                            service_context=service_context,
+                            api_key=api_key,
+                            memory=memory_sources,
+                        )
+                        async for chunk in agent.astream(
+                            input,
+                            **astream_kwargs,
+                        ):
+                            stream_chunk = handle_multi_mode(chunk)
+                            if stream_chunk:
+                                stream_type = stream_chunk[0]
+                                chunk_data = stream_chunk[1]
+                                if stream_type == "values" and "files" in chunk_data:
+                                    files_map = {**files_map, **chunk_data["files"]}
+                                if stream_type == "values" and "todos" in chunk_data:
+                                    todos_list = chunk_data["todos"]
+                                data = ujson.dumps(stream_chunk)
+                                log_to_file(str(data), agent.model) and APP_LOG_LEVEL == "DEBUG"
+                                logger.debug(f"data: {str(data)}")
+                                yield f"data: {data}\n\n"
+                    except Exception as fallback_err:
+                        logger.exception("Fallback also failed in stream_generator: %s", fallback_err)
+                        error_msg = ujson.dumps(("error", str(fallback_err)))
+                        yield f"data: {error_msg}\n\n"
+                else:
+                    logger.exception("Error in stream_generator: %s", e)
+                    error_msg = ujson.dumps(("error", str(e)))
+                    yield f"data: {error_msg}\n\n"
+            else:
+                # Non-Daytona error: original behavior
+                logger.exception("Error in stream_generator: %s", e)
+                error_msg = ujson.dumps(("error", str(e)))
+                yield f"data: {error_msg}\n\n"
         finally:
             try:
                 if service_context.user_id and checkpointer and agent: