dslighting 1.3.9__py3-none-any.whl

dsat/workflows/search/aide_workflow.py

@@ -0,0 +1,283 @@
+# dsat/workflows/search/aide_workflow.py
+
+import logging
+import shutil
+from pathlib import Path
+from typing import Dict, Optional, Any, List
+
+from dsat.workflows.base import DSATWorkflow
+from dsat.services.states.journal import JournalState, Node, MetricValue
+from dsat.benchmark.benchmark import BaseBenchmark
+from dsat.services.llm import LLMService
+
+from dsat.prompts.aide_prompt import create_improve_prompt, create_debug_prompt
+from dsat.prompts.common import create_draft_prompt
+
+from dsat.utils.context import ContextManager, summarize_repetitive_logs
+
+logger = logging.getLogger(__name__)
+
+
+class AIDEWorkflow(DSATWorkflow):
+    """
+    Implements the AIDE iterative search algorithm.
+    This class serves as the base for search-based workflows, containing shared
+    logic for the main search loop, node selection policy, and final artifact generation.
+    """
+    def __init__(self, operators: Dict[str, Any], services: Dict[str, Any], agent_config: Dict[str, Any], benchmark: Optional[BaseBenchmark] = None):
+        """
+        Initializes the AIDEWorkflow and its required services and operators.
+        """
+        super().__init__(operators, services, agent_config)
+        self.state: JournalState = services["state"]
+        self.sandbox_service = services["sandbox"]
+        self.workspace_service = services.get("workspace")
+        self.llm_service: LLMService = services["llm"]
+        self.benchmark = benchmark
+        
+        self.execute_op = self.operators["execute"]
+        
+        self.generate_op = self.operators["generate"]
+        self.review_op = self.operators["review"]
+        
+        self.context_manager = ContextManager()
+
+    def _get_error_history(self, node: Node, max_depth: int = 3) -> str:
+        """
+        Traverses up a chain of buggy parent nodes to build a concise error history.
+        """
+        history = []
+        current = node
+        depth = 0
+        while current and current.is_buggy and depth < max_depth:
+            error_summary = self.context_manager.summarize_error(current.term_out, current.exc_type)
+            entry = (
+                f"--- Failure at Step #{current.step} ---\n"
+                f"Plan: {current.plan}\n"
+                f"Code:\n```python\n{current.code}\n```\n"
+                f"Error:\n```\n{error_summary}\n```"
+            )
+            history.append(entry)
+            depth += 1
+            current = self.state.get_node(current.parent_id) if current.parent_id else None
+        
+        if not history:
+            return "No error history found."
+
+        # Reverse to show chronological order (oldest failure first)
+        return "\n".join(reversed(history))
+
+    def _llm_history_length(self) -> int:
+        return len(self.llm_service.get_call_history())
+
+    def _capture_llm_calls_since(self, start_index: int) -> List[Dict[str, Any]]:
+        history = self.llm_service.get_call_history()
+        if start_index < len(history):
+            return history[start_index:]
+        return []
+
+    async def solve(self, description: str, io_instructions: str, data_dir: Path, output_path: Path) -> None:
+        """
+        The main entry point for the workflow.
+        ...
+        """
+        logger.info(f"{self.__class__.__name__} starting to solve task. Target output: {output_path}")
+
+        max_iterations = self.agent_config.get("search", {}).get("max_iterations", 3)
+
+        for i in range(max_iterations):
+            logger.info(f"--- Starting {self.__class__.__name__} Solve Step {i + 1}/{max_iterations} ---")
+            
+            task_context = {
+                "goal_and_data": description,
+                "io_instructions": io_instructions
+            }
+            
+            await self._execute_search_step(task_context, output_path)
+        
+        logger.info("Max iterations reached. Generating final output from the best found solution.")
+        best_node = self.state.get_best_node()
+
+        if best_node:
+            logger.info(f"Executing code from best node #{best_node.step} to generate final artifact.")
+            final_exec_result = await self.execute_op(code=best_node.code, mode="script")
+            if not final_exec_result.success:
+                logger.warning(f"Final execution of best node's code failed: {final_exec_result.stderr}")
+            final_solution_path = self._write_final_submission(best_node, output_path)
+            if final_solution_path:
+                logger.info(f"Final solution code saved to {final_solution_path}")
+        else:
+            logger.warning("No successful solution was found during the search.")
+
+    async def _execute_search_step(self, task_context: Dict, output_path: Path):
+        """
+        Execute a single, concrete step of the AIDE search loop.
+        This involves selecting a node to expand, generating new code, executing it,
+        and performing **grounded validation** against the benchmark's grading function.
+        
+        Args:
+            task_context: A dictionary containing the task goal, data report, and I/O instructions.
+            output_path: The path where the final output file is expected. Used for grounded validation.
+        """
+        # 1. Select a node
+        parent_node = self._select_node_to_expand()
+
+        # 2. Create a prompt
+        if parent_node is None:
+            prompt = create_draft_prompt(task_context, self.state.generate_summary())
+        elif parent_node.is_buggy:
+            error_history = self._get_error_history(parent_node)
+            prompt = create_debug_prompt(task_context, parent_node.code, error_history, previous_plan=parent_node.plan, memory_summary=self.state.generate_summary())
+        else:
+            summarized_output = summarize_repetitive_logs(parent_node.term_out)
+            prompt = create_improve_prompt(
+                task_context, self.state.generate_summary(), parent_node.code,
+                parent_node.analysis, previous_plan=parent_node.plan, previous_output=summarized_output
+            )
+
+        # 3. Generate a new plan and code using the LLM.
+        generate_start = self._llm_history_length()
+        plan, code = await self.generate_op(system_prompt=prompt)
+        new_node = Node(plan=plan, code=code)
+        new_node.generate_prompt = prompt
+        new_node.task_context = task_context
+        new_calls = self._capture_llm_calls_since(generate_start)
+        if new_calls:
+            new_node.llm_generate = new_calls[-1]
+
+        # 4. Execute the new code in the sandbox.
+        exec_result = await self.execute_op(code=new_node.code, mode="script")
+        new_node.absorb_exec_result(exec_result)
+
+        # Perform grounded validation if code execution was successful.
+        if exec_result.success:
+            submission_file_in_sandbox = self.sandbox_service.workspace.get_path("sandbox_workdir") / output_path.name
+            
+            if not submission_file_in_sandbox.exists():
+                new_node.is_buggy = True
+                new_node.analysis = "Code executed without error, but failed to produce the required output file."
+                new_node.metric = MetricValue(value=0.0, maximize=True)
+            elif self.benchmark and hasattr(self.benchmark, 'grade'):
+                logger.info(f"Performing grounded validation using benchmark grader on '{submission_file_in_sandbox}'...")
+                score = await self.benchmark.grade(submission_file_in_sandbox)
+                
+                # A score > 0 from the grader is the ground truth for a non-buggy, valid submission.
+                if score > 0:
+                    new_node.is_buggy = False
+                    new_node.metric = MetricValue(value=score, maximize=True)
+                    logger.info(f"Grounded validation PASSED. Score: {score:.4f}")
+                    review_context = {
+                        "task": task_context,
+                        "code": new_node.code,
+                        "output": new_node.term_out
+                    }
+                    new_node.review_context = review_context
+                    review_start = self._llm_history_length()
+                    review = await self.review_op(prompt_context=review_context)
+                    review_calls = self._capture_llm_calls_since(review_start)
+                    if review_calls:
+                        new_node.llm_review = review_calls[-1]
+                    new_node.analysis = f"Grounded Score: {score:.4f}. Reviewer Summary: {review.summary}"
+                else:
+                    new_node.is_buggy = True
+                    new_node.metric = MetricValue(value=score, maximize=True)
+                    new_node.analysis = "Grounded validation FAILED: The generated submission file was invalid or scored 0.0."
+                    logger.warning(f"Grounded validation FAILED. Score: {score}")
+            else:
+                review_context = {
+                    "task": task_context,
+                    "code": new_node.code,
+                    "output": new_node.term_out
+                }
+                new_node.review_context = review_context
+                review_start = self._llm_history_length()
+                review = await self.review_op(prompt_context=review_context)
+                review_calls = self._capture_llm_calls_since(review_start)
+                if review_calls:
+                    new_node.llm_review = review_calls[-1]
+                new_node.analysis = review.summary
+                new_node.is_buggy = review.is_buggy
+                new_node.metric = MetricValue(value=review.metric_value, maximize=not review.lower_is_better) if review.metric_value is not None else MetricValue(value=None)
+        
+        # 7. Add the new node to the search tree state and persist artifacts.
+        self.state.append(new_node, parent=parent_node)
+        self._persist_node_artifacts(new_node)
+        logger.info(f"Step {new_node.step} complete. Buggy: {new_node.is_buggy}. Metric: {new_node.metric}.")
+
+    def _persist_node_artifacts(self, node: Node) -> None:
+        """
+        保存每个节点生成的代码，以便后续分析和还原完整路径。
+        """
+        if not self.workspace_service:
+            return
+        code_steps_dir = self.workspace_service.get_path("artifacts") / "code_steps"
+        code_steps_dir.mkdir(parents=True, exist_ok=True)
+        filename = f"step_{node.step:03d}_{node.id}.py"
+        file_path = code_steps_dir / filename
+        file_path.write_text(node.code, encoding="utf-8")
+        node.code_artifact_path = str(file_path)
+
+    def _write_final_submission(self, node: Node, expected_output: Path) -> Optional[Path]:
+        """
+        将最终成功的代码与输出复制到固定位置，便于后续复现。
+        """
+        if not self.workspace_service:
+            return None
+        final_dir = self.workspace_service.get_path("artifacts") / "final_submission"
+        final_dir.mkdir(parents=True, exist_ok=True)
+
+        final_solution_path = final_dir / "final_solution.py"
+        final_solution_path.write_text(node.code, encoding="utf-8")
+        node.final_submission_path = str(final_solution_path)
+
+        if expected_output and expected_output.exists():
+            try:
+                shutil.copy2(expected_output, final_dir / expected_output.name)
+            except Exception as copy_error:
+                logger.warning(f"Failed to copy final submission artifact '{expected_output}': {copy_error}")
+
+        return final_solution_path
+
+    def _select_node_to_expand(self) -> Optional[Node]:
+        """
+        Implements the REVISED, DEBUG-FIRST search policy.
+        The policy prioritizes:
+        1. Debugging failed solutions.
+        2. Improving the current best solution if no bugs exist.
+        3. Drafting a new solution only as a last resort.
+        """
+        search_cfg = self.agent_config.get("search", {})
+        # num_drafts is no longer used to block debugging
+        max_debug_depth = search_cfg.get("max_debug_depth", 3)
+
+        buggy_nodes = [n for n in self.state.nodes.values() if n.is_buggy]
+        # Find nodes that are leaves in the bug-chain and haven't exceeded debug depth
+        debuggable = [
+            n for n in buggy_nodes 
+            if not n.children_ids and self._get_debug_depth(n) < max_debug_depth
+        ]
+        
+        if debuggable:
+            # Select the most recent buggy node to work on
+            selected = max(debuggable, key=lambda n: n.step)
+            logger.info(f"[Search Policy] Debugging: Prioritizing most recent failed node #{selected.step}.")
+            return selected
+
+        best_node = self.state.get_best_node()
+        if best_node:
+            logger.info(f"[Search Policy] Improving: No bugs to fix. Selected best node #{best_node.step} with metric {best_node.metric}.")
+            return best_node
+
+        logger.info("[Search Policy] Drafting: No bugs to fix and no successful nodes to improve. Creating new solution.")
+        return None
+
+    def _get_debug_depth(self, node: Node) -> int:
+        depth = 0
+        current = node
+        while current.parent_id:
+            parent = self.state.get_node(current.parent_id)
+            if not parent or not parent.is_buggy:
+                break
+            depth += 1
+            current = parent
+        return depth

dsat/workflows/search/automind_workflow.py

@@ -0,0 +1,237 @@
+import logging
+import json
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+from .aide_workflow import AIDEWorkflow
+from dsat.services.states.journal import Node, MetricValue
+from dsat.common.typing import ExecutionResult
+from dsat.benchmark.benchmark import BaseBenchmark
+
+from dsat.services.vdb import VDBService
+
+from dsat.prompts.common import create_draft_prompt 
+from dsat.prompts.automind_prompt import create_stepwise_code_prompt, create_stepwise_debug_prompt
+from dsat.prompts.aide_prompt import create_improve_prompt, create_debug_prompt
+
+from dsat.utils.context import (
+    ContextManager,
+    MAX_HISTORY_CHARS,
+    MAX_OUTPUT_CHARS,
+    summarize_repetitive_logs,
+    truncate_output,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AutoMindWorkflow(AIDEWorkflow):
+    """
+    Implements the AUTOMIND iterative search algorithm.
+    This workflow extends AIDE by incorporating a knowledge base (VDB),
+    a self-adaptive coding strategy (one-pass vs. stepwise), and more
+    sophisticated context management for complex tasks.
+    """
+    def __init__(self, operators: Dict[str, Any], services: Dict[str, Any], agent_config: Dict[str, Any], benchmark: Optional[BaseBenchmark] = None):
+        """
+        Initializes the AutoMindWorkflow, building upon the AIDE base.
+        """
+        # Initialize base AIDE components, now passing the benchmark instance up.
+        super().__init__(operators, services, agent_config, benchmark=benchmark)
+        
+        self.vdb_service: VDBService = services.get("vdb")
+        
+        self.complexity_scorer_op = self.operators.get("complexity_scorer")
+        self.plan_decomposer_op = self.operators.get("plan_decomposer")
+        
+        # AutoMind's context manager requires an LLM service to summarize knowledge and history.
+        self.context_manager = ContextManager(llm_service=services.get("llm"))
+
+    async def _execute_search_step(self, task_context: Dict, output_path: Path):
+        """
+        Execute a single step of the AutoMind search loop.
+        This overrides the AIDE implementation to add knowledge retrieval, the
+        self-adaptive coding strategy, and now uses **grounded validation**.
+        
+        Args:
+            task_context: A dictionary containing the task goal, data report, and I/O instructions.
+            output_path: The path where the final output file is expected. Used for grounded validation.
+        """
+        # 1. Select a node
+        parent_node = self._select_node_to_expand()
+        
+        task_goal = task_context.get('goal_and_data', 'Solve the data science task.')
+        io_instructions = task_context.get('io_instructions', 'N/A')
+
+        # 2. Create a prompt
+        if parent_node is None:
+            # For new drafts, retrieve similar examples from the knowledge base.
+            retrieved_knowledge = ""
+            if self.vdb_service:
+                cases = self.vdb_service.retrieve(task_goal, top_k=2)
+                retrieved_knowledge = await self.context_manager.summarize_knowledge(cases, task_goal)
+            
+            prompt = create_draft_prompt(task_context, self.state.generate_summary(), retrieved_knowledge)
+        elif parent_node.is_buggy:
+            error_summary = self.context_manager.summarize_error(parent_node.term_out, parent_node.exc_type)
+            prompt = create_debug_prompt(task_context, parent_node.code, error_summary, previous_plan=parent_node.plan, memory_summary=self.state.generate_summary())
+        else:
+            summarized_output = summarize_repetitive_logs(parent_node.term_out)
+            prompt = create_improve_prompt(
+                task_context, self.state.generate_summary(), parent_node.code,
+                parent_node.analysis, previous_plan=parent_node.plan, previous_output=summarized_output
+            )
+
+        # 3. Generate initial plan and one-pass code.
+        plan, one_pass_code = await self.generate_op(system_prompt=prompt)
+        
+        # 4. Apply the self-adaptive coding strategy for new drafts.
+        use_adaptive = self.complexity_scorer_op and self.plan_decomposer_op
+        if use_adaptive and parent_node is None:
+            final_code, exec_result = await self._execute_step_adaptively(plan, one_pass_code, task_goal, io_instructions)
+        else:
+            # For simpler tasks, improvements, or debugging, use the one-pass code.
+            final_code = one_pass_code
+            exec_result = await self.execute_op(code=final_code, mode="script")
+
+        # 5. Create a new node and absorb the execution result.
+        new_node = Node(plan=plan, code=final_code)
+        new_node.absorb_exec_result(exec_result)
+
+        if exec_result.success:
+            submission_file_in_sandbox = self.sandbox_service.workspace.get_path("sandbox_workdir") / output_path.name
+            
+            if not submission_file_in_sandbox.exists():
+                new_node.is_buggy = True
+                new_node.analysis = "Code executed without error, but failed to produce the required output file."
+                new_node.metric = MetricValue(value=0.0, maximize=True)
+            elif self.benchmark and hasattr(self.benchmark, 'grade'):
+                logger.info(f"Performing grounded validation using benchmark grader on '{submission_file_in_sandbox}'...")
+                score = await self.benchmark.grade(submission_file_in_sandbox)
+                
+                if score > 0:
+                    new_node.is_buggy = False
+                    new_node.metric = MetricValue(value=score, maximize=True)
+                    logger.info(f"Grounded validation PASSED. Score: {score:.4f}")
+                    review = await self.review_op(prompt_context={
+                        "task": task_context, "code": new_node.code, "output": new_node.term_out
+                    })
+                    new_node.analysis = f"Grounded Score: {score:.4f}. Reviewer Summary: {review.summary}"
+                else:
+                    new_node.is_buggy = True
+                    new_node.metric = MetricValue(value=score, maximize=True)
+                    new_node.analysis = "Grounded validation FAILED: The generated submission file was invalid or scored 0.0."
+                    logger.warning(f"Grounded validation FAILED. Score: {score}")
+            else:
+                logger.warning("No benchmark with 'grade' method found. Falling back to unreliable LLM-based review.")
+                review = await self.review_op(prompt_context={
+                    "task": task_context, "code": new_node.code, "output": new_node.term_out
+                })
+                new_node.analysis = review.summary
+                new_node.is_buggy = review.is_buggy
+                new_node.metric = MetricValue(value=review.metric_value, maximize=not review.lower_is_better) if review.metric_value is not None else MetricValue(value=None)
+        
+        # 8. Add the new node to the search tree state.
+        self.state.append(new_node, parent=parent_node)
+        logger.info(f"Step {new_node.step} complete. Buggy: {new_node.is_buggy}. Metric: {new_node.metric}.")
+
+    async def _execute_step_adaptively(self, plan: str, one_pass_code: str, task_goal: str, io_instructions: str) -> tuple[str, ExecutionResult]:
+        """
+        Core of the Self-Adaptive Coding Strategy.
+        It scores the complexity of a plan and chooses to either execute the provided
+        one-pass code directly or decompose the plan into smaller steps and execute them
+        sequentially in a notebook context.
+        
+        Args:
+            plan: The overall plan for the task.
+            one_pass_code: The single block of code generated for the entire plan.
+            task_goal: The user's primary goal.
+            
+        Returns:
+            A tuple containing the final code (either one-pass or combined steps) and the
+            final ExecutionResult.
+        """
+        final_code = one_pass_code
+        
+        # 1. Score plan complexity using the dedicated operator.
+        score = await self.complexity_scorer_op(plan=plan, task_goal=task_goal)
+
+        # 2. Choose strategy based on the complexity score.
+        if score.complexity <= 3:  # Threshold for one-pass vs stepwise
+            logger.info("Plan is simple. Executing in one-pass mode.")
+            exec_result = await self.execute_op(code=final_code, mode="script")
+        else:
+            logger.info("Plan is complex. Decomposing and executing in stepwise mode.")
+            # 3. Decompose the complex plan into a sequence of smaller tasks.
+            decomposed_plan = await self.plan_decomposer_op(plan=plan, task_goal=task_goal)
+            
+            step_codes = []
+            history_steps = []
+            final_exec_result = None
+            # Get max retries config
+            max_step_retries = self.agent_config.get("max_retries", 3)
+
+            async with self.sandbox_service.notebook_executor() as notebook:
+                for task in decomposed_plan.tasks:
+                    logger.info(f"Executing step {task.task_id}: {task.instruction}")
+                    
+                    step_succeeded = False
+                    current_code = ""
+                    step_failure_history = []  # History for the current step
+
+                    # Implement retry loop for robustness
+                    for attempt in range(max_step_retries):
+                        logger.info(f"Step {task.task_id}, Attempt {attempt + 1}/{max_step_retries}")
+
+                        # Build a concise history of recent steps to provide context for the next step.
+                        recent_history_str = self.context_manager.build_history_context(
+                            history_steps, 
+                            key_order=["task_id", "code", "output"]
+                        )
+                        
+                        if attempt == 0:
+                            step_prompt = create_stepwise_code_prompt(task_goal, plan, recent_history_str, task.instruction, io_instructions)
+                        else:
+                            error_summary = self.context_manager.summarize_error(exec_result.stderr, exec_result.exc_type)
+                            step_failure_history.append({
+                                "attempt": attempt,
+                                "code": truncate_output(current_code, MAX_OUTPUT_CHARS),
+                                "error": error_summary
+                            })
+                            
+                            formatted_failure_history = "\n".join([
+                                f"--- Attempt {f['attempt']} Failed ---\nCode:\n```python\n{f['code']}\n```\nError: {f['error']}\n---"
+                                for f in step_failure_history
+                            ])
+                            safe_failure_history = truncate_output(formatted_failure_history, MAX_HISTORY_CHARS)
+                            
+                            step_prompt = create_stepwise_debug_prompt(
+                                task_goal, plan, recent_history_str, task.instruction,
+                                current_code, safe_failure_history, io_instructions
+                            )
+
+                        _, current_code = await self.generate_op(system_prompt=step_prompt)
+                        exec_result = await self.execute_op(code=current_code, mode="notebook", executor_context=notebook)
+                        
+                        if exec_result.success:
+                            step_succeeded = True
+                            break
+
+                    if not step_succeeded:
+                        logger.error(f"Step {task.task_id} failed after {max_step_retries} attempts. Aborting stepwise execution.")
+                        final_exec_result = exec_result  # Capture the failed result
+                        break
+
+                    step_codes.append(f"# --- Step {task.task_id}: {task.instruction} ---\n{current_code}")
+                    # Record the successful step for future context.
+                    history_steps.append({
+                        "task_id": task.task_id,
+                        "code": truncate_output(current_code, MAX_OUTPUT_CHARS),
+                        "output": truncate_output(exec_result.stdout, MAX_OUTPUT_CHARS),
+                    })
+                    final_exec_result = exec_result  # Update with the latest successful result
+            
+            final_code = "\n\n".join(step_codes)
+            exec_result = final_exec_result
+
+        return final_code, exec_result

dsat/workflows/templates/basic_kaggle_loop.py

@@ -0,0 +1,71 @@
+"""
+A simple, baseline workflow that serves as the starting point (seed)
+for the meta-optimization evolutionary algorithm.
+"""
+
+def get_initial_workflow_code() -> str:
+    """Returns the source code for a simple workflow using injected operators."""
+    return '''
+import shutil
+from pathlib import Path
+from dsat.workflows.base import DSATWorkflow
+from dsat.services.llm import LLMService
+from dsat.services.sandbox import SandboxService
+from dsat.utils.parsing import parse_plan_and_code
+from typing import Dict, Any, List
+
+class Workflow(DSATWorkflow):
+    """
+    An initial workflow that generates Python code to solve a Kaggle-style task,
+    executes it in a sandbox, and produces a submission file.
+    This is a strong starting point for the optimization process.
+    """
+    def __init__(self, operators: Dict[str, Any], services: Dict[str, Any], agent_config: Dict[str, Any]):
+        """
+        The driver injects the llm_service and sandbox_service.
+        """
+        super().__init__(operators, services, agent_config)
+        self.llm_service: LLMService = services["llm"]
+        self.sandbox_service: SandboxService = services["sandbox"]
+        
+    async def solve(self, description: str, io_instructions: str, data_dir: Path, output_path: Path):
+        """
+        The main entry point for executing the workflow.
+        """
+        print(f"  Initial Workflow: Starting task. Target: {output_path.name}")
+
+        prompt = (
+            f"You are an expert AI developer and data scientist. Your task is to write a single, complete Python script to solve the following problem. "
+            f"Provide only the Python code in a single code block.\\n\\n"
+            f"# PROBLEM DESCRIPTION AND DATA REPORT\\n{description}\\n\\n"
+            f"# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)\\n{io_instructions}\\n\\n"
+            f"Ensure the script strictly follows the CRITICAL I/O REQUIREMENTS."
+        )
+        
+        # 1. Generate the code
+        llm_response = await self.llm_service.call(prompt)
+        _, code_to_execute = parse_plan_and_code(llm_response)
+
+        if "# ERROR" in code_to_execute:
+            print("  ERROR: Failed to generate valid code from LLM.")
+            return
+
+        # 2. Execute the code in the sandbox
+        # The sandbox will have its own isolated workspace.
+        print("  Initial Workflow: Executing generated script in sandbox...")
+        exec_result = self.sandbox_service.run_script(code_to_execute)
+
+        if not exec_result.success:
+            print(f"  ERROR: Code execution failed.\\\\n{exec_result.stderr}")
+            return
+
+        # 3. Verify the generated submission file exists.
+        sandbox_workdir = self.sandbox_service.workspace.get_path("sandbox_workdir")
+        generated_file = sandbox_workdir / output_path.name
+        
+        if generated_file.exists():
+            print(f"  SUCCESS: Submission file '{output_path.name}' successfully generated in sandbox.")
+        else:
+            print(f"  ERROR: Execution succeeded, but the required output file '{output_path.name}' was not created in {sandbox_workdir}.")
+
+'''