fix: 修复无法使用自定义镜像以及自定义镜像无法校验的问题

backend/app/api/endpoints/adapter/shells.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import asyncio
 import logging
 import os
 import re
@@ -26,6 +27,18 @@
 # Redis key prefix and TTL for validation status
 VALIDATION_STATUS_KEY_PREFIX = "shell_validation:"
 VALIDATION_STATUS_TTL = 300  # 5 minutes
+# Delay before cleaning up validation container after successful validation.
+# Default is immediate cleanup (0 seconds). Keeps backward compatibility with
+# the previous variable name.
+VALIDATION_CONTAINER_CLEANUP_DELAY_SECONDS = int(
+    os.getenv(
+        "VALIDATION_SUCCESS_CLEANUP_DELAY_SECONDS",
+        os.getenv("VALIDATION_CONTAINER_CLEANUP_DELAY_SECONDS", "0"),
+    )
+)
+VALIDATION_SUBMIT_TIMEOUT_SECONDS = float(
+    os.getenv("VALIDATION_SUBMIT_TIMEOUT_SECONDS", "90")
+)
 
 
 # Request/Response Models
@@ -745,7 +758,9 @@ async def validate_image(
 
         # Call executor manager's validate-image API with validation_id
         # Use AsyncClient to avoid blocking the event loop
-        async with httpx.AsyncClient(timeout=30.0) as client:
+        async with httpx.AsyncClient(
+            timeout=VALIDATION_SUBMIT_TIMEOUT_SECONDS
+        ) as client:
             response = await client.post(
                 validate_url,
                 json={
@@ -796,18 +811,24 @@ async def validate_image(
         logger.error(f"Timeout submitting validation task for image: {image}")
         await _update_validation_status(
             validation_id,
-            status="completed",
-            stage="Error",
-            progress=100,
-            valid=False,
-            error_message="Request timed out while submitting validation task",
+            status="submitted",
+            stage="Submission timed out, validation may still be running",
+            progress=15,
+            valid=None,
+            error_message=(
+                "Submission request timed out. Validation may still be in progress; "
+                "continue polling status."
+            ),
         )
         return ImageValidationResponse(
-            status="error",
-            message="Request timed out while submitting validation task",
+            status="submitted",
+            message=(
+                "Validation submission timed out, but task may still be running. "
+                "Please continue polling."
+            ),
             validationId=validation_id,
-            valid=False,
-            errors=["Validation request timed out"],
+            valid=None,
+            errors=["Validation submission timed out; continue polling"],
         )
     except httpx.RequestError as e:
         logger.error(f"Error calling executor manager: {e}")
@@ -970,9 +991,10 @@ async def update_validation_status(
                 status_code=500, detail="Failed to update validation status"
             )
 
-        # Cleanup validation container if validation is completed
+        # Cleanup validation container if validation is completed.
+        # Run cleanup asynchronously to avoid blocking callback response.
         if request.executor_name and request.valid is True:
-            await _cleanup_validation_container(request.executor_name)
+            asyncio.create_task(_cleanup_validation_container(request.executor_name))
 
         return {"status": "success", "message": "Validation status updated"}
     except HTTPException:
@@ -997,6 +1019,14 @@ async def _cleanup_validation_container(executor_name: str) -> None:
         logger.warning("No executor_name provided for cleanup")
         return
 
+    if VALIDATION_CONTAINER_CLEANUP_DELAY_SECONDS > 0:
+        logger.info(
+            "Delaying validation container cleanup by %s seconds: %s",
+            VALIDATION_CONTAINER_CLEANUP_DELAY_SECONDS,
+            executor_name,
+        )
+        await asyncio.sleep(VALIDATION_CONTAINER_CLEANUP_DELAY_SECONDS)
+
     executor_manager_url = os.getenv("EXECUTOR_MANAGER_URL", "http://localhost:8001")
     delete_url = f"{executor_manager_url}/executor-manager/executor/delete"
 

backend/app/services/execution/request_builder.py

@@ -58,8 +58,9 @@ def __init__(self, db: Session):
             db: Database session
         """
         self.db = db
-        # Cache shell_type to avoid repeated database queries
-        self._cached_shell_type: str | None = None
+        # Cache shell info by (user_id, namespace, shell_name)
+        # to avoid repeated database queries while keeping per-shell isolation.
+        self._cached_shell_info: dict[tuple[int, str, str], dict] = {}
 
     def build(
         self,
@@ -643,6 +644,22 @@ def _resolve_shell_type(self, bot: Kind, user_id: int) -> str:
         This method queries the Shell CRD to get the shell_type.
         It's called once per builder instance and the result is cached.
 
+        Args:
+            bot: Bot Kind object
+            user_id: User ID for shell lookup
+
+        Returns:
+            Shell type string (e.g., "Chat", "ClaudeCode", "Agno")
+        """
+        shell_info = self._resolve_shell_info(bot, user_id)
+        return shell_info["shell_type"]
+
+    def _resolve_shell_info(self, bot: Kind, user_id: int) -> dict:
+        """Resolve shell info from bot's shellRef.
+
+        This method queries the Shell CRD to get shell_type and base_image.
+        It's called once per builder instance and the result is cached.
+
         Search order:
         1. User's private shell (user_id == user_id, namespace == shell_ref.namespace)
         2. Group shell (any user_id, namespace == shell_ref.namespace) - for group scenarios
@@ -653,22 +670,29 @@ def _resolve_shell_type(self, bot: Kind, user_id: int) -> str:
             user_id: User ID for shell lookup
 
         Returns:
-            Shell type string (e.g., "Chat", "ClaudeCode", "Agno")
+            dict: {"shell_type": str, "base_image": Optional[str]}
         """
-        # Return cached value if available
-        if self._cached_shell_type is not None:
-            return self._cached_shell_type
+        bot_crd = Bot.model_validate(bot.json)
 
-        # Default value
+        # Default values
         shell_type = "Chat"
-
-        bot_crd = Bot.model_validate(bot.json)
+        base_image = None
 
         if not (bot_crd.spec and bot_crd.spec.shellRef):
-            self._cached_shell_type = shell_type
-            return shell_type
+            return {
+                "shell_type": shell_type,
+                "base_image": base_image,
+            }
 
         shell_ref = bot_crd.spec.shellRef
+        cache_key = (user_id, shell_ref.namespace, shell_ref.name)
+
+        # Return cached value if available
+        cached = self._cached_shell_info.get(cache_key)
+        if cached is not None:
+            return cached
+
+        shell = None
 
         # 1. Query user's private shell first
         shell = (
@@ -710,22 +734,29 @@ def _resolve_shell_type(self, bot: Kind, user_id: int) -> str:
                 .first()
             )
 
-        # Extract shell_type from Shell CRD
+        # Extract shell_type and base_image from Shell CRD
         if shell and shell.json:
             shell_crd = Shell.model_validate(shell.json)
-            if shell_crd.spec and shell_crd.spec.shellType:
-                shell_type = shell_crd.spec.shellType
+            if shell_crd.spec:
+                if shell_crd.spec.shellType:
+                    shell_type = shell_crd.spec.shellType
+                base_image = shell_crd.spec.baseImage
 
         logger.debug(
-            "[TaskRequestBuilder] Resolved shell_type=%s for bot=%s (shell_ref=%s/%s)",
-            shell_type,
+            "[TaskRequestBuilder] Resolved shell_info for bot=%s (shell_ref=%s/%s): shell_type=%s, base_image=%s",
             bot_crd.metadata.name if bot_crd.metadata else "unknown",
             shell_ref.namespace,
             shell_ref.name,
+            shell_type,
+            base_image,
         )
 
-        self._cached_shell_type = shell_type
-        return shell_type
+        resolved_shell_info = {
+            "shell_type": shell_type,
+            "base_image": base_image,
+        }
+        self._cached_shell_info[cache_key] = resolved_shell_info
+        return resolved_shell_info
 
     # =========================================================================
     # Skill Resolution (from ChatConfigBuilder)
@@ -1227,8 +1258,10 @@ def _build_bot_config(
             bot_json = bot.json or {}
             bot_spec_json = bot_json.get("spec", {})
 
-            # Get shell_type
-            shell_type = self._resolve_shell_type(bot, team.user_id)
+            # Get shell_type and base_image from Shell CRD
+            shell_info = self._resolve_shell_info(bot, team.user_id)
+            shell_type = shell_info["shell_type"]
+            base_image = shell_info["base_image"]
 
             # Get ghost info for system_prompt and skills
             ghost_system_prompt = ""
@@ -1272,7 +1305,7 @@ def _build_bot_config(
                 "mcp_servers": ghost_mcp_servers,
                 "skills": ghost_skills,
                 "role": member.role or "worker",
-                "base_image": bot_spec_json.get("baseImage"),
+                "base_image": base_image,
             }
             bot_configs.append(bot_config)
 

backend/tests/services/execution/test_request_builder_user_mcp.py

@@ -211,3 +211,52 @@ def test_get_bot_skills_returns_four_tuple_when_ghost_not_found(
 
         assert len(result) == 4
         assert result == ([], [], [], {})
+
+    def test_resolve_shell_info_cache_isolated_by_shell_ref(self, test_db, mocker):
+        builder = TaskRequestBuilder(test_db)
+
+        bot_one = SimpleNamespace(
+            json={
+                "kind": "Bot",
+                "metadata": {"name": "bot-one", "namespace": "default"},
+                "spec": {
+                    "ghostRef": {"name": "ghost-a", "namespace": "default"},
+                    "shellRef": {"name": "shell-a", "namespace": "default"},
+                },
+            }
+        )
+        bot_two = SimpleNamespace(
+            json={
+                "kind": "Bot",
+                "metadata": {"name": "bot-two", "namespace": "default"},
+                "spec": {
+                    "ghostRef": {"name": "ghost-b", "namespace": "default"},
+                    "shellRef": {"name": "shell-b", "namespace": "default"},
+                },
+            }
+        )
+
+        shell_a = SimpleNamespace(
+            json={
+                "kind": "Shell",
+                "metadata": {"name": "shell-a", "namespace": "default"},
+                "spec": {"shellType": "ClaudeCode", "baseImage": "img-a"},
+            }
+        )
+        shell_b = SimpleNamespace(
+            json={
+                "kind": "Shell",
+                "metadata": {"name": "shell-b", "namespace": "default"},
+                "spec": {"shellType": "Agno", "baseImage": "img-b"},
+            }
+        )
+
+        mock_query = mocker.Mock()
+        mock_query.filter.return_value.first.side_effect = [shell_a, shell_b]
+        mocker.patch.object(builder.db, "query", return_value=mock_query)
+
+        shell_info_one = builder._resolve_shell_info(bot_one, user_id=1)
+        shell_info_two = builder._resolve_shell_info(bot_two, user_id=1)
+
+        assert shell_info_one == {"shell_type": "ClaudeCode", "base_image": "img-a"}
+        assert shell_info_two == {"shell_type": "Agno", "base_image": "img-b"}