fix: extract_agent_only for /evaluate - no tasks/ dir required

Author: echobt

src/handlers.rs

@@ -1229,24 +1229,25 @@ async fn evaluate_with_stored_agent(
         )
     })?;
 
-    // Extract agent code
+    // Extract agent code only (no tasks/ required - we use HF tasks)
     let extract_dir = state.config.workspace_base.join("_extract_evaluate");
     let _ = tokio::fs::remove_dir_all(&extract_dir).await;
-    let extracted = crate::task::extract_uploaded_archive(&archive_bytes, &extract_dir)
-        .await
-        .map_err(|e| {
-            (
-                StatusCode::BAD_REQUEST,
-                Json(serde_json::json!({"error": format!("Failed to extract agent: {}", e)})),
-            )
-        })?;
+    let (agent_code, agent_language) =
+        crate::task::extract_agent_only(&archive_bytes, &extract_dir)
+            .await
+            .map_err(|e| {
+                (
+                    StatusCode::BAD_REQUEST,
+                    Json(serde_json::json!({"error": format!("Failed to extract agent: {}", e)})),
+                )
+            })?;
     let _ = tokio::fs::remove_dir_all(&extract_dir).await;
 
     let hf_tasks: Vec<crate::task::SweForgeTask> = registry.get_tasks().to_vec();
     let final_archive = crate::task::ExtractedArchive {
         tasks: hf_tasks,
-        agent_code: extracted.agent_code,
-        agent_language: extracted.agent_language,
+        agent_code,
+        agent_language,
     };
 
     if state.sessions.has_active_batch() {

src/task/mod.rs

@@ -79,6 +79,31 @@ pub fn extract_archive_bytes(data: &[u8], dest: &Path) -> Result<()> {
     Ok(())
 }
 
+/// Extract only the agent code from an archive (no tasks/ required).
+pub async fn extract_agent_only(data: &[u8], dest: &Path) -> Result<(String, String)> {
+    if data.len() > MAX_ARCHIVE_SIZE {
+        anyhow::bail!(
+            "Archive too large: {} bytes (max {})",
+            data.len(),
+            MAX_ARCHIVE_SIZE
+        );
+    }
+
+    tokio::fs::create_dir_all(dest)
+        .await
+        .context("Failed to create extraction directory")?;
+    let dest_owned = dest.to_path_buf();
+    let data_vec = data.to_vec();
+    tokio::task::spawn_blocking(move || extract_archive_bytes(&data_vec, &dest_owned))
+        .await
+        .context("Extract task panicked")??;
+
+    let root = find_agent_root(dest)?;
+    let agent_code = load_agent_code(&root)?;
+    let agent_language = detect_agent_language(&root);
+    Ok((agent_code, agent_language))
+}
+
 pub async fn extract_uploaded_archive(data: &[u8], dest: &Path) -> Result<ExtractedArchive> {
     if data.len() > MAX_ARCHIVE_SIZE {
         anyhow::bail!(
@@ -119,6 +144,20 @@ pub async fn extract_uploaded_archive(data: &[u8], dest: &Path) -> Result<Extrac
     })
 }
 
+fn find_agent_root(base: &Path) -> Result<PathBuf> {
+    if base.join("agent_code").exists() {
+        return Ok(base.to_path_buf());
+    }
+    for entry in std::fs::read_dir(base).context("Failed to read extracted directory")? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() && path.join("agent_code").exists() {
+            return Ok(path);
+        }
+    }
+    anyhow::bail!("No agent_code/ found in archive at {}", base.display())
+}
+
 fn find_archive_root(base: &Path) -> Result<PathBuf> {
     if base.join("tasks").exists() || base.join("agent_code").exists() {
         return Ok(base.to_path_buf());