mifunedev
diff --git a/‎.ralph/prd.json‎
Lines changed: 124 additions & 51 deletions b/‎.ralph/prd.json‎
Lines changed: 124 additions & 51 deletions
diff --git a/‎.ralph/progress.txt‎
Lines changed: 100 additions & 86 deletions b/‎.ralph/progress.txt‎
Lines changed: 100 additions & 86 deletions
diff --git a/‎backend/pyproject.toml‎
Lines changed: 4 additions & 0 deletions b/‎backend/pyproject.toml‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎backend/src/agents/__init__.py‎
Lines changed: 100 additions & 10 deletions b/‎backend/src/agents/__init__.py‎
Lines changed: 100 additions & 10 deletions
diff --git a/‎backend/src/agents/daytona.py‎
Lines changed: 18 additions & 0 deletions b/‎backend/src/agents/daytona.py‎
Lines changed: 18 additions & 0 deletions
diff --git a/‎backend/src/constants/__init__.py‎
Lines changed: 2 additions & 0 deletions b/‎backend/src/constants/__init__.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎backend/src/controllers/llm.py‎
Lines changed: 32 additions & 23 deletions b/‎backend/src/controllers/llm.py‎
Lines changed: 32 additions & 23 deletions
diff --git a/‎backend/src/repos/user_settings_repo.py‎
Lines changed: 14 additions & 1 deletion b/‎backend/src/repos/user_settings_repo.py‎
Lines changed: 14 additions & 1 deletion
diff --git a/‎backend/src/routes/v0/settings.py‎
Lines changed: 24 additions & 0 deletions b/‎backend/src/routes/v0/settings.py‎
Lines changed: 24 additions & 0 deletions
@@ -12,13 +12,17 @@ dependencies = [
     "authlib>=1.6.3",
     "bs4>=0.0.2",
     "cryptography>=45.0.7",
+    "daytona>=0.140.0",
     "deepagents==0.3.8",
     "fastapi>=0.116.1",
+    "langchain-daytona>=0.0.2",
     "langchain-sandbox>=0.0.3", # TODO: Update to 0.0.6 when langchain-core>=1.0 is released
     "langchain[aws]>=1.2.0",
     "langchain-anthropic>=1.3.0",
     # "langchain-arcade>=1.3.1",
     "langchain-community>=0.4.1",
+    "langchain-daytona>=0.0.2",
+    "daytona>=0.140.0",
     "langchain-google-genai>=4.1.2",
     "langchain-groq>=1.1.1",
     "langchain-mcp-adapters>=0.2.1",
 
@@ -20,7 +20,16 @@
 from deepagents.backends.utils import create_file_data
 
 
-from src.constants import APP_ENV
+# Conditional import for Daytona sandbox support
+try:
+    from daytona import Daytona, DaytonaConfig
+    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]
+
+from src.constants import APP_ENV, DAYTONA_API_KEY
 from src.contexts.service import ServiceContext
 from src.constants.llm import DEFAULT_CHAT_MODEL, DEFAULT_SYSTEM_PROMPT
 from src.schemas.entities.llm import Assistant, LLMInput
@@ -232,16 +241,97 @@ def init_config(
     )
 
 
-def init_backend(runtime: ToolRuntime, *, routes):
-    """Factory function that creates a CompositeBackend with custom routes."""
-    built_routes = {}
-    for prefix, backend_or_factory in routes.items():
-        if callable(backend_or_factory):
-            built_routes[prefix] = backend_or_factory(runtime)
-        else:
-            built_routes[prefix] = backend_or_factory
+def create_daytona_backend():
+    """Create a Daytona sandbox and return (sandbox, backend).
+
+    Returns ``(None, None)`` when the package is not installed, the API key is
+    missing, or sandbox creation fails for any reason.
+    """
+    if DaytonaSandbox is None or Daytona is None:
+        return None, None
+
+    key = DAYTONA_API_KEY
+    if not key:
+        return None, None
+
+    try:
+        client = Daytona(DaytonaConfig(api_key=key))  # type: ignore[misc]
+        sandbox = client.create()
+        backend = DaytonaSandbox(sandbox=sandbox)
+        return sandbox, backend
+    except Exception as exc:
+        logger.error(f"Failed to create Daytona sandbox: {exc}")
+        return None, None
+
+
+def _create_daytona_backend_checked(
+    runtime: ToolRuntime,
+) -> tuple[CompositeBackend, Any] | None:
+    """Try to create a Daytona-backed CompositeBackend.
+
+    Returns ``(backend, sandbox)`` on success, or ``None`` if Daytona is
+    unavailable or not capable.  Cleans up the sandbox on failure.
+    """
+    from src.agents.daytona import validate_daytona_execute_capability
+
+    sandbox, daytona_backend = create_daytona_backend()
+    if daytona_backend is not None:
+        supported, _reason = validate_daytona_execute_capability(daytona_backend)
+        if supported:
+            backend = CompositeBackend(default=daytona_backend, routes={})
+            return backend, sandbox
+
+        # Daytona not capable — clean up sandbox silently
+        if sandbox is not None:
+            try:
+                sandbox.stop()
+            except Exception:
+                pass
+
+    return None
+
+
+def _create_state_backend(
+    runtime: ToolRuntime,
+) -> tuple[CompositeBackend, None]:
+    """Create a plain StateBackend-backed CompositeBackend."""
     default_state = StateBackend(runtime)
-    return CompositeBackend(default=default_state, routes=built_routes)
+    backend = CompositeBackend(default=default_state, routes={})
+    return backend, None
+
+
+_SANDBOX_FACTORIES: dict[str, Callable] = {
+    "daytona": _create_daytona_backend_checked,
+    "state": _create_state_backend,
+}
+
+
+def resolve_sandbox_backend(
+    runtime: ToolRuntime,
+    sandbox_type: str | None = None,
+) -> tuple[CompositeBackend, Any]:
+    """Resolve a sandbox backend based on *sandbox_type*.
+
+    Dispatch rules:
+    * ``None`` / ``"auto"`` — try Daytona first, fall back to State.
+    * ``"state"`` — use StateBackend directly (never attempts Daytona).
+    * ``"daytona"`` — try Daytona, fall back to State if unavailable.
+    * Any unknown value — treated as ``"auto"``.
+
+    Returns ``(backend, daytona_sandbox_or_None)``.
+    """
+    effective = sandbox_type if sandbox_type in _SANDBOX_FACTORIES else None
+
+    if effective == "state":
+        return _create_state_backend(runtime)
+
+    # "daytona" or auto (None) — try Daytona first
+    result = _create_daytona_backend_checked(runtime)
+    if result is not None:
+        return result
+
+    # Fallback: plain StateBackend (silent, no messages)
+    return _create_state_backend(runtime)
 
 
 ################################################################################
 
@@ -0,0 +1,18 @@
+"""Daytona sandbox helpers for the agents module."""
+
+from typing import Any
+
+
+def validate_daytona_execute_capability(backend: Any) -> tuple[bool, str | None]:
+    """Check whether a Daytona backend supports the execute() method.
+
+    Returns ``(True, None)`` when the backend is capable, or
+    ``(False, reason)`` explaining why it is not.
+    """
+    if backend is None:
+        return False, "backend is None"
+
+    if not callable(getattr(backend, "execute", None)):
+        return False, "backend does not support execute()"
+
+    return True, None
@@ -107,6 +107,7 @@ class UserTokenKey(Enum):
     EXA_API_KEY = "EXA_API_KEY"
     ARCADE_API_KEY = "ARCADE_API_KEY"
     LANGCONNECT_SERVER_URL = "LANGCONNECT_SERVER_URL"
+    DAYTONA_API_KEY = "DAYTONA_API_KEY"
 
     @classmethod
     def values(cls) -> list[str]:
@@ -133,6 +134,7 @@ def values(cls) -> list[str]:
 TAVILY_API_KEY = os.getenv(UserTokenKey.TAVILY_API_KEY.value)
 EXA_API_KEY = os.getenv(UserTokenKey.EXA_API_KEY.value)
 LANGCONNECT_SERVER_URL = os.getenv(UserTokenKey.LANGCONNECT_SERVER_URL.value)
+DAYTONA_API_KEY = os.getenv(UserTokenKey.DAYTONA_API_KEY.value)
 
 # Storage
 MINIO_HOST = os.getenv("MINIO_HOST")
 
@@ -1,4 +1,3 @@
-from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
 from langchain.tools import ToolRuntime
 import ujson
 
@@ -9,7 +8,12 @@
 from src.schemas.entities.schedule import ScheduleCreate
 from src.schemas.entities import LLMRequest
 from src.contexts.service import ServiceContext
-from src.agents import construct_agent, init_config, prepare_memory_files
+from src.agents import (
+    construct_agent,
+    init_config,
+    prepare_memory_files,
+    resolve_sandbox_backend,
+)
 from src.services.db import get_checkpoint_db
 from src.utils.stream import stream_generator
 from src.agents import Orchestra
@@ -41,15 +45,6 @@ def _init_runtime(self, request: LLMRequest) -> ToolRuntime:
             config=self.service_context.config,
         )
 
-    def init_backend(self, request: LLMRequest) -> CompositeBackend:
-        runtime = self._init_runtime(request)
-        store_backend = StoreBackend(runtime)
-        built_routes = {
-            f"/users/{runtime.context.user_id}/memories/": store_backend,
-            f"/users/{runtime.context.user_id}/config/": store_backend,
-        }
-        return CompositeBackend(default=StateBackend(runtime), routes=built_routes)
-
     async def _update_store(self, agent: Orchestra, config: RunnableConfig) -> None:
         final_state = await agent.graph.aget_state(config)
         configurable = {
@@ -71,17 +66,20 @@ async def _update_store(self, agent: Orchestra, config: RunnableConfig) -> None:
         )
         logger.info(f"checkpoint: {ujson.dumps(configurable)}")
 
-    async def _resolve_user_settings(self, model: str) -> tuple[str, str | None]:
-        """Resolve user default model and API key.
+    async def _resolve_user_settings(
+        self, model: str
+    ) -> tuple[str, str | None, str | None]:
+        """Resolve user default model, API key, and sandbox preference.
 
-        Returns (model, api_key) where model may be overridden by user default
-        and api_key is the resolved key for the provider.
+        Returns (model, api_key, default_sandbox) where model may be overridden
+        by user default, api_key is the resolved key for the provider, and
+        default_sandbox is the user's sandbox backend preference.
         """
         if not self.user_id:
             # Unauthenticated users: fall back to system default if no model
             if not model:
                 model = DEFAULT_CHAT_MODEL
-            return model, None
+            return model, None, None
 
         settings_repo = UserSettingsRepo(self.user_id, self.store)
         settings = await settings_repo._get_or_create()
@@ -95,12 +93,15 @@ async def _resolve_user_settings(self, model: str) -> tuple[str, str | None]:
         if not model:
             model = DEFAULT_CHAT_MODEL
 
+        # Read sandbox preference from settings
+        default_sandbox = getattr(settings, "default_sandbox", None)
+
         # Guard against None model before resolving API key
         if not model:
-            return model, None
+            return model, None, default_sandbox
 
         api_key = resolve_api_key(model, user_keys if user_keys else None)
-        return model, api_key
+        return model, api_key, default_sandbox
 
     async def llm_invoke(self, params: LLMRequest):
         """Invoke the agent synchronously and return the final response.
@@ -117,8 +118,10 @@ async def llm_invoke(self, params: LLMRequest):
             config = init_config(params, user_id=self.user_id)
             params = await self.service_context.llm_service.assistant(params)
 
-            # Resolve user-configured API key and default model
-            params.model, api_key = await self._resolve_user_settings(params.model)
+            # Resolve user-configured API key, default model, and sandbox
+            params.model, api_key, default_sandbox = await self._resolve_user_settings(
+                params.model
+            )
 
             # Load user memories into files_map for MemoryMiddleware
             memory_files, memory_sources = await prepare_memory_files(
@@ -129,7 +132,10 @@ async def llm_invoke(self, params: LLMRequest):
                 params.input.files = {**memory_files, **existing_files}
 
             async with get_checkpoint_db() as checkpointer:
-                backend = self.init_backend(params)
+                runtime = self._init_runtime(params)
+                backend, _sandbox = resolve_sandbox_backend(
+                    runtime, sandbox_type=default_sandbox
+                )
                 agent: Orchestra = await construct_agent(
                     instructions=params.instructions,
                     system_prompt=params.system_prompt,
@@ -161,8 +167,10 @@ async def llm_invoke(self, params: LLMRequest):
     async def llm_stream(self, params: LLMRequest):
         assistant = await self.service_context.llm_service.assistant(params)
 
-        # Resolve user-configured API key and default model
-        assistant.model, api_key = await self._resolve_user_settings(assistant.model)
+        # Resolve user-configured API key, default model, and sandbox
+        assistant.model, api_key, default_sandbox = await self._resolve_user_settings(
+            assistant.model
+        )
 
         return stream_generator(
             input=assistant.input,
@@ -174,6 +182,7 @@ async def llm_stream(self, params: LLMRequest):
             service_context=self.service_context,
             instructions=assistant.instructions,
             api_key=api_key,
+            sandbox_type=default_sandbox,
         )
 
     async def llm_task(self, job: ScheduleCreate):
 
@@ -3,7 +3,7 @@
 from datetime import datetime, timezone
 
 from src.repos.base_repo import BaseRepo
-from src.schemas.entities.settings import UserSettings, ProviderKeyStatus
+from src.schemas.entities.settings import UserSettings, ProviderKeyStatus, SandboxType
 from src.utils.security import encrypt_value, decrypt_value
 from src.constants import UserTokenKey
 
@@ -71,6 +71,19 @@ async def set_default_model(self, model: Optional[str]) -> UserSettings:
         await self._set(_SETTINGS_KEY, settings)
         return settings
 
+    async def set_default_sandbox(self, sandbox: Optional[str]) -> UserSettings:
+        if sandbox is not None:
+            valid = [e.value for e in SandboxType]
+            if sandbox not in valid:
+                raise ValueError(
+                    f"Invalid sandbox '{sandbox}'. Must be one of: {valid}"
+                )
+        settings = await self._get_or_create()
+        settings.default_sandbox = sandbox
+        settings.updated_at = datetime.now(timezone.utc)
+        await self._set(_SETTINGS_KEY, settings)
+        return settings
+
     async def upsert_provider_key(self, provider: str, api_key: str) -> UserSettings:
         self._validate_provider(provider)
         settings = await self._get_or_create()
 
@@ -5,6 +5,7 @@
 from src.schemas.entities.settings import (
     UserSettingsResponse,
     UpdateDefaultModelRequest,
+    UpdateDefaultSandboxRequest,
     UpsertProviderKeyRequest,
 )
 from src.repos.user_settings_repo import UserSettingsRepo
@@ -27,6 +28,7 @@ async def get_settings(
     settings, statuses = await repo.get_settings()
     return UserSettingsResponse(
         default_model=settings.default_model,
+        default_sandbox=settings.default_sandbox,
         provider_keys=statuses,
     )
 
@@ -42,6 +44,26 @@ async def update_default_model(
     settings, statuses = await repo.get_settings()
     return UserSettingsResponse(
         default_model=settings.default_model,
+        default_sandbox=settings.default_sandbox,
+        provider_keys=statuses,
+    )
+
+
+@router.put("/settings/default-sandbox", response_model=UserSettingsResponse)
+async def update_default_sandbox(
+    req: UpdateDefaultSandboxRequest,
+    user: User = Depends(verify_credentials),
+    store: BaseStore = Depends(get_store),
+) -> UserSettingsResponse:
+    repo = _get_repo(user, store)
+    try:
+        await repo.set_default_sandbox(req.sandbox)
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    settings, statuses = await repo.get_settings()
+    return UserSettingsResponse(
+        default_model=settings.default_model,
+        default_sandbox=settings.default_sandbox,
         provider_keys=statuses,
     )
 
@@ -60,6 +82,7 @@ async def upsert_provider_key(
     settings, statuses = await repo.get_settings()
     return UserSettingsResponse(
         default_model=settings.default_model,
+        default_sandbox=settings.default_sandbox,
         provider_keys=statuses,
     )
 
@@ -80,5 +103,6 @@ async def delete_provider_key(
     settings, statuses = await repo.get_settings()
     return UserSettingsResponse(
         default_model=settings.default_model,
+        default_sandbox=settings.default_sandbox,
         provider_keys=statuses,
     )