dslighting 1.3.9__py3-none-any.whl

dsat/prompts/aide_prompt.py

@@ -0,0 +1,52 @@
+from typing import Dict
+
+from dsat.utils.context import MAX_HISTORY_CHARS, MAX_OUTPUT_CHARS, truncate_output
+from dsat.prompts.common import _dict_to_str, _get_common_guidelines, create_draft_prompt
+
+def create_improve_prompt(task_context: Dict, memory_summary: str, previous_code: str, previous_analysis: str, previous_plan: str = "", previous_output: str = "") -> str:
+    """Creates the system prompt for improving an existing solution."""
+    safe_previous_code = truncate_output(previous_code, MAX_OUTPUT_CHARS)
+    safe_previous_analysis = truncate_output(previous_analysis, MAX_OUTPUT_CHARS)
+    safe_previous_plan = truncate_output(previous_plan, MAX_OUTPUT_CHARS)
+    safe_previous_output = truncate_output(previous_output, MAX_OUTPUT_CHARS)
+    prompt_dict = {
+        "Role": "You are an expert AI Developer tasked with improving a previous solution.",
+        "Task Goal and Data Overview": task_context.get("goal_and_data", "N/A"),
+        "CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)": task_context.get("io_instructions", "N/A"),
+        "Memory of Past Attempts": memory_summary,
+        "Previous Successful Solution": {
+            "Plan": safe_previous_plan,
+            "Analysis": safe_previous_analysis,
+            "Execution Output (Summarized)": safe_previous_output,
+            "Code": f"```python\n{safe_previous_code}\n```",
+        },
+        "Instructions": {
+            "Goal": "Propose a single, atomic improvement and implement the complete, updated code. Ensure the improved code still adheres to the CRITICAL I/O REQUIREMENTS.",
+            "Improvement Guideline": "Focus on one specific change to the approach, algorithm, data processing pipeline, or parameters to better meet the task requirements.",
+            **_get_common_guidelines()
+        }
+    }
+    return _dict_to_str(prompt_dict)
+
+def create_debug_prompt(task_context: Dict, buggy_code: str, error_history: str, previous_plan: str = "", memory_summary: str = "") -> str:
+    """Creates the system prompt for debugging a failed solution."""
+    safe_buggy_code = truncate_output(buggy_code, MAX_OUTPUT_CHARS)
+    safe_error_history = truncate_output(error_history, MAX_HISTORY_CHARS)
+    safe_previous_plan = truncate_output(previous_plan, MAX_OUTPUT_CHARS)
+    prompt_dict = {
+        "Role": "You are an expert Python programmer debugging a data science script.",
+        "Task Goal and Data Overview": task_context.get("goal_and_data", "N/A"),
+        "CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)": task_context.get("io_instructions", "N/A"),
+        "Memory of Past Attempts": memory_summary,
+        "Most Recent Failed Attempt": {
+            "Plan": safe_previous_plan,
+            "Code": f"```python\n{safe_buggy_code}\n```",
+        },
+        "History of Failures (Oldest to Newest)": safe_error_history,
+        "Instructions": {
+            "Goal": "Analyze the full history of failures for this task. Identify the root cause, propose a fix, and implement the complete, corrected code.",
+            "Debugging Guideline": "Your plan should state the root cause and the fix. The new code must be a complete, runnable script.",
+            **_get_common_guidelines()
+        }
+    }
+    return _dict_to_str(prompt_dict)

dsat/prompts/autokaggle_prompt.py

@@ -0,0 +1,290 @@
+from typing import Dict, Any, List
+import json
+from dsat.services.states.autokaggle_state import TaskContract, AutoKaggleState, PhaseMemory
+from dsat.models.formats import StepPlan
+from dsat.utils.context import MAX_OUTPUT_CHARS, truncate_output
+
+
+def get_deconstructor_prompt(description: str, schema: Dict) -> str:
+    return f"""
+# TASK
+You are an expert AI system designer. Your job is to analyze the user's request, the provided Comprehensive Data Exploration Report, AND the CRITICAL I/O REQUIREMENTS, and deconstruct it into a structured JSON Task Contract according to the schema.
+
+# USER REQUEST, DATA REPORT, AND I/O REQUIREMENTS
+"{description}"
+
+# INSTRUCTIONS
+1. Analyze the 'COMPREHENSIVE DATA EXPLORATION REPORT (Ground Truth)'.
+2. Reconcile the findings in the data report with the 'USER DESCRIPTION'.
+3. Populate the 'input_files' field accurately.
+4. **CRITICAL: Determine the output files.** You MUST use the filename specified in the 'CRITICAL I/O REQUIREMENTS' section for the 'output_files' field. This requirement overrides any other filename mentioned elsewhere.
+5. Extract the overall goal, type, outputs, and metrics from the user request, informed by the insights in the data report.
+
+# RESPONSE JSON SCHEMA (Task Contract)
+{json.dumps(schema, indent=2)}
+
+# RESPONSE
+Provide ONLY the JSON object that conforms to the schema.
+"""
+
+
+def get_phase_planner_prompt(contract: TaskContract) -> str:
+    return f"""
+# TASK
+You are an expert project manager. Based on the provided Task Contract, break down the project into a sequence of high-level, logical phases.
+
+# TASK CONTRACT
+{contract.model_dump_json(indent=2)}
+
+# INSTRUCTIONS
+- The phases should be a logical progression from start to finish.
+- Each phase should represent a distinct stage of work.
+- The workflow must adapt dynamically based on the specific task type ('{contract.task_type}') and the `task_goal`. Do not assume a standard ML pipeline (e.g., do not include "Build Model" unless the task explicitly requires it).
+- Do not be overly specific. These are high-level phases.
+
+# RESPONSE FORMAT
+Provide ONLY a JSON object with a single key "phases" containing a list of strings.
+Example: {{"phases": ["Phase 1 Goal", "Phase 2 Goal", "Phase 3 Goal"]}}
+"""
+
+
+def _summarize_phase_history_and_artifacts(state: AutoKaggleState) -> str:
+    """Helper function to summarize phase history AND available artifacts."""
+    history_summary_parts = []
+    if not state.phase_history:
+        history_summary = "This is the first phase. No previous phases to report."
+    else:
+        for ph in state.phase_history:
+            artifacts_list = "\\n".join([f"- ./{key}" for key in ph.output_artifacts.keys()])
+            history_summary_parts.append(
+                f"## Report for Phase: {ph.phase_goal}\\n"
+                f"{ph.final_report}\\n"
+                f"**Generated Artifacts:**\\n{artifacts_list if artifacts_list else 'None'}"
+            )
+        history_summary = "\\n\\n".join(history_summary_parts)
+    
+    # NEW: Add a clear summary of all available artifacts
+    available_artifacts_str = "\\n".join([f"- {fname}" for fname in state.global_artifacts.keys()])
+    if not available_artifacts_str:
+        available_artifacts_str = "None"
+        
+    return f"""
+# PREVIOUSLY COMPLETED PHASES SUMMARY
+{history_summary}
+
+# CUMULATIVE ARTIFACTS AVAILABLE IN CWD
+```
+{available_artifacts_str}
+```
+"""
+
+
+def get_step_planner_prompt(state: AutoKaggleState, phase_goal: str) -> str:
+    history_summary = _summarize_phase_history_and_artifacts(state)
+
+    return f"""
+# TASK
+You are a meticulous planner. Your task is to create a detailed, step-by-step plan for the developer to execute the CURRENT PHASE. You must also specify ALL input artifacts to be used and ALL output artifacts to be generated.
+
+# COMPREHENSIVE DATA REPORT AND OVERALL GOAL
+{state.full_task_description}
+
+# OVERALL TASK CONTRACT
+{state.contract.model_dump_json(indent=2)}
+
+# CRITICAL I/O REQUIREMENTS
+{state.io_instructions}
+
+{history_summary}
+
+# CURRENT PHASE GOAL
+"{phase_goal}"
+
+# INSTRUCTIONS
+1.  **Analyze Available Artifacts**: Review the list of available artifacts. Your plan MUST use these as inputs where appropriate (e.g., use 'train_preprocessed.csv' for model training).
+2.  **Create Plan**: Create a detailed, numbered list of actions for the developer. Be specific.
+3.  **Specify Inputs**: In the `input_artifacts` field of your JSON response, list the EXACT filenames of all artifacts your plan requires.
+4.  **Specify Outputs**: In the `output_files` field, list the EXACT filenames of all new artifacts the plan will create (e.g., models, reports, processed data). It is CRITICAL to include files for saving state, like models (`.pkl`, `.joblib`) or scalers.
+
+# RESPONSE JSON SCHEMA
+Provide ONLY a JSON object that conforms to the following schema.
+```json
+{json.dumps(StepPlan.model_json_schema(), indent=2)}
+```
+"""
+
+
+def get_developer_prompt(state: AutoKaggleState, phase_goal: str, plan: str, attempt_history: List) -> str:
+    history_summary = _summarize_phase_history_and_artifacts(state)
+    
+    error_context = ""
+    if attempt_history:
+        history_str_parts = []
+        # Iterate over all previous attempts to build a comprehensive history
+        for attempt in reversed(attempt_history): # Show most recent failure first
+            safe_validation = truncate_output(json.dumps(attempt.validation_result), MAX_OUTPUT_CHARS)
+            safe_error = truncate_output(attempt.execution_error or "No runtime error.", MAX_OUTPUT_CHARS)
+            safe_code = truncate_output(attempt.code or "", MAX_OUTPUT_CHARS)
+            history_str_parts.append(f"""
+---
+### FAILED ATTEMPT {attempt.attempt_number + 1}
+#### Reviewer's Suggestion: "{attempt.review_suggestion}"
+#### Validation Failure: {safe_validation}
+#### Execution Error:
+```
+{safe_error}
+```
+#### Previous Code for this Attempt:
+```python
+{safe_code}
+```
+---
+""")
+        
+        error_context = f"""
+# PREVIOUS ATTEMPTS FAILED
+Your previous attempts to complete this phase failed. Analyze the full history below (most recent first) to write a corrected version and avoid repeating mistakes.
+{''.join(history_str_parts)}
+"""
+
+    return f"""
+# TASK
+You are an expert developer. Your task is to write a complete Python script to execute the provided plan for the current phase.
+
+# COMPREHENSIVE DATA REPORT AND OVERALL GOAL
+{state.full_task_description}
+
+# OVERALL TASK CONTRACT
+{state.contract.model_dump_json(indent=2)}
+
+# CRITICAL I/O REQUIREMENTS
+{state.io_instructions}
+
+{history_summary}
+
+# CURRENT PHASE GOAL
+"{phase_goal}"
+
+# DETAILED PLAN FOR THIS PHASE
+{plan}
+
+{error_context}
+
+# INSTRUCTIONS
+- Your script MUST load any necessary input artifacts listed in the "CUMULATIVE ARTIFACTS AVAILABLE" section using their exact filenames.
+- Your script MUST generate and save all output files specified in the plan. Use libraries like `joblib` or `pickle` to save Python objects like models or scalers.
+- All file operations must be relative to the current working directory.
+
+# RESPONSE FORMAT
+Provide ONLY the complete, runnable Python code in a single code block. Do not add explanations.
+"""
+
+
+def get_validator_prompt(contract: TaskContract, filename: str, content_snippet: str) -> str:
+    return f"""
+# TASK
+
+You are an automated QA agent. Validate if the generated file conforms to the Task Contract.
+
+# TASK CONTRACT
+
+{contract.model_dump_json(indent=2)}
+
+# GENERATED FILE: {filename}
+
+# FILE CONTENT (first 20 lines):
+
+{content_snippet}
+
+# VALIDATION
+
+Based on the contract, does this file meet the requirements for '{filename}'? Check format, content, data types, and any other constraints mentioned in the contract's description for this file.
+
+# RESPONSE FORMAT
+
+Respond with a single JSON object: {{"passed": <true_or_false>, "reason": "A detailed explanation."}}
+"""
+
+
+def get_reviewer_prompt(phase_goal: str, dev_result: Dict, plan: str = "") -> str:
+    safe_code = truncate_output(dev_result.get('code', '# N/A'), MAX_OUTPUT_CHARS)
+    safe_error = truncate_output(dev_result.get('error') or "None", MAX_OUTPUT_CHARS)
+    safe_validation = truncate_output(json.dumps(dev_result.get('validation_result')), MAX_OUTPUT_CHARS)
+    return f"""
+# TASK
+
+You are a meticulous reviewer. Assess the developer's work for the given phase. Provide a score (1-5) and a constructive suggestion for improvement if the score is below 4.
+
+# CURRENT PHASE GOAL
+
+"{phase_goal}"
+
+# PLAN BEING EXECUTED
+
+{plan}
+
+# DEVELOPER'S WORK
+
+  - **Code:**
+```python
+{safe_code}
+```
+
+  - **Code Execution Status:** {"Success" if dev_result['status'] else "Failed"}
+  - **Execution Error:** {safe_error}
+  - **Validation Result:** {safe_validation}
+
+# INSTRUCTIONS
+
+  - If the code failed to execute, the score must be low (1 or 2). Your suggestion should focus on fixing the error.
+  - If the phase is an early one like "Explore Data" or "Prepare Data", DO NOT penalize the developer for not creating the final output file specified in the contract. The validation check for that file might fail, which is acceptable at this stage. Focus on whether the code successfully achieved the phase's specific goal.
+  - If the code executed and passed relevant validations for this phase, evaluate the approach. Is it a good way to achieve the phase goal? Score 3-5.
+  - A score of 5 requires a truly excellent and efficient implementation.
+
+# RESPONSE FORMAT
+
+Provide ONLY a JSON object: {{"score": <1_to_5>, "suggestion": "Your suggestion here."}}
+"""
+
+
+def get_summarizer_prompt(state: AutoKaggleState, phase_memory: PhaseMemory) -> str:
+    attempt_summary = ""
+    for attempt in phase_memory.attempts:
+        attempt_summary += f"\\n### Attempt {attempt.attempt_number + 1} (Score: {attempt.review_score})\\n- Suggestion: {attempt.review_suggestion}\\n"
+
+    return f"""
+# TASK
+
+You are a technical writer. Summarize the work done in the completed phase into a concise report.
+
+# OVERALL TASK CONTRACT
+
+{state.contract.model_dump_json(indent=2)}
+
+# CURRENT PHASE GOAL
+
+"{phase_memory.phase_goal}"
+
+# ATTEMPT HISTORY FOR THIS PHASE
+
+{attempt_summary}
+
+# FINAL SUCCESSFUL CODE
+
+```python
+{phase_memory.attempts[-1].code if phase_memory.attempts else 'No code available'}
+```
+
+# INSTRUCTIONS
+
+Synthesize all information into a report covering:
+
+1.  The main objective of this phase.
+2.  The final approach taken to achieve it.
+3.  Key findings or results from the code execution.
+4.  How this phase's outcome contributes to the overall project goal.
+
+# RESPONSE FORMAT
+
+Provide the summary as a comprehensive report in Markdown.
+"""

dsat/prompts/automind_prompt.py

@@ -0,0 +1,29 @@
+from typing import Dict
+from dsat.prompts.common import create_draft_prompt
+
+def create_stepwise_code_prompt(goal: str, plan: str, history: str, current_step: str, io_instructions: str) -> str:
+    """Creates a prompt for generating code for a single step in a complex plan."""
+    return (
+        f"You are executing a complex data science plan step-by-step.\n\n"
+        f"# OVERALL GOAL\n{goal}\n\n"
+        f"# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)\n{io_instructions}\n\n"
+        f"# OVERALL PLAN\n{plan}\n\n"
+        f"# PREVIOUSLY EXECUTED STEPS (CODE & OUTPUT)\n{history}\n\n"
+        f"# CURRENT STEP TO IMPLEMENT\n{current_step}\n\n"
+        "Your task is to write the Python code ONLY for the CURRENT STEP. The code will be executed in a Jupyter-like environment, so you can assume variables from previous steps are in memory. Ensure your code adheres to the I/O requirements."
+    )
+
+
+def create_stepwise_debug_prompt(goal: str, plan: str, history: str, current_step: str, failed_code: str, error_history: str, io_instructions: str) -> str:
+    """Creates a prompt for debugging a failed step in a stepwise execution."""
+    return (
+        f"You are debugging a complex data science plan being executed step-by-step.\n\n"
+        f"# OVERALL GOAL\n{goal}\n\n"
+        f"# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)\n{io_instructions}\n\n"
+        f"# OVERALL PLAN\n{plan}\n\n"
+        f"# PREVIOUSLY EXECUTED STEPS (CODE & OUTPUT)\n{history}\n\n"
+        f"# FAILED STEP INSTRUCTION\n{current_step}\n\n"
+        f"# MOST RECENT FAILED CODE\n```python\n{failed_code}\n```\n\n"
+        f"# HISTORY OF FAILED ATTEMPTS FOR THIS STEP\n{error_history}\n\n"
+        "Your task is to analyze the full history of errors for this step and provide the corrected Python code ONLY for the FAILED STEP. Assume variables from previous steps are still in memory. Ensure your corrected code adheres to the I/O requirements."
+    )

dsat/prompts/common.py

@@ -0,0 +1,51 @@
+from typing import Dict, List, Optional
+
+def _dict_to_str(d: Dict, indent=0) -> str:
+    """Helper to format dictionaries into a readable string for prompts."""
+    lines = []
+    for k, v in d.items():
+        prefix = ' ' * (indent * 2)
+        if isinstance(v, dict):
+            lines.append(f"{prefix}{k}:")
+            lines.append(_dict_to_str(v, indent + 1))
+        elif isinstance(v, list):
+            lines.append(f"{prefix}{k}:")
+            for item in v:
+                lines.append(' ' * ((indent + 1) * 2) + f"- {item}")
+        else:
+            lines.append(f"{prefix}{k}: {v}")
+    return "\n".join(lines)
+
+def _get_common_guidelines() -> Dict:
+    """Returns a dictionary of common instructions for all prompts."""
+    return {
+        "Response Format": (
+            "Your response MUST start with a brief natural language plan (3-5 sentences), "
+            "followed by a single, complete Python code block wrapped in ```python ... ```. "
+            "Do not include any other text or headings."
+        ),
+        "Implementation Guidelines": [
+            "The code must be a self-contained, single-file Python script.",
+            "If the task involves modeling or optimization, print key metrics (e.g., validation scores) to standard output. Otherwise, ensure the output clearly presents the findings or results.",
+            "Follow the CRITICAL I/O REQUIREMENTS provided in the task description precisely for all file operations.",
+            "Do not use interactive elements like `input()` or `matplotlib.pyplot.show()`."
+        ]
+    }
+
+def create_draft_prompt(task_context: Dict, memory_summary: str, retrieved_knowledge: Optional[str] = None) -> str:
+    """Creates the system prompt for generating an initial solution draft."""
+    prompt_dict = {
+        "Role": "You are an expert Data Scientist and AI Engineer.",
+        "Task Goal and Data Overview": task_context.get("goal_and_data", "N/A"),
+        "CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)": task_context.get("io_instructions", "N/A"),
+        "Memory of Past Attempts": memory_summary,
+        "Retrieved Knowledge": retrieved_knowledge or "No relevant knowledge was retrieved for this task.",
+        "Instructions": {
+            "Goal": "Propose a simple but effective plan and implement it in Python" + (
+                ", incorporating insights from the retrieved knowledge if applicable." if retrieved_knowledge else "."
+            ),
+            "Design Guideline": "Your first solution should be straightforward and robust. Focus on correctly addressing the core requirements based on the data report AND the CRITICAL I/O REQUIREMENTS.",
+            **_get_common_guidelines()
+        }
+    }
+    return _dict_to_str(prompt_dict)

dsat/prompts/data_interpreter_prompt.py

@@ -0,0 +1,82 @@
+# System message for the Planner
+PLAN_SYSTEM_MESSAGE = """
+You are a master planner AI. Break down a complex user request into a sequence of simple, actionable steps for a data scientist.
+Your plan MUST conclude with a final step that generates the required output file as specified in the user request's I/O requirements.
+Output a JSON list of tasks, where each task has "task_id", "instruction", and "dependent_task_ids".
+Provide ONLY the JSON list in a single code block.
+"""
+
+PLAN_PROMPT = """
+# User Request
+{user_request}
+
+# Your Plan (JSON format)
+"""
+
+GENERATE_CODE_PROMPT = """
+# Overall Goal and Data Report
+{user_requirement}
+
+# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)
+{io_instructions}
+
+# Plan Status
+{plan_status}
+
+# Current Task
+{current_task}
+
+# History (Previous Code and Outputs)
+{history}
+
+# Instruction
+Write Python code for the **Current Task**. Ensure the code strictly follows the CRITICAL I/O REQUIREMENTS. Generate visualizations if required.
+Provide ONLY the Python code in a single code block.
+"""
+
+REFLECT_AND_DEBUG_PROMPT = """
+# Overall Goal and Data Report
+{user_requirement}
+
+# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)
+{io_instructions}
+
+# History (Previous Code and Outputs)
+{history}
+
+# Current Task
+{current_task}
+
+# Failed Code
+```python
+{failed_code}
+```
+
+# Error Output
+```
+{error_output}
+```
+
+# Instruction
+Your previous code failed. Analyze the error in the context of the execution history (previous steps) and rewrite the full, corrected Python code for the **Current Task**. Ensure the corrected code strictly follows the CRITICAL I/O REQUIREMENTS.
+Provide ONLY the corrected Python code in a single code block.
+"""
+
+FINALIZE_OUTPUT_PROMPT = """
+# Overall Goal and Data Report
+{user_requirement}
+
+# Execution History
+The following tasks have been successfully executed, and their results and variables are available in the current notebook session:
+{history}
+
+# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)
+{io_instructions}
+
+# Final Instruction
+Your final and most important task is to generate the required output file.
+Based on all the previous steps and the CRITICAL I/O REQUIREMENTS, write the Python code that creates the final output file named **'{output_filename}'** in the correct format.
+
+The file MUST be saved in the current working directory.
+Provide ONLY the Python code for this final step in a single code block.
+"""

dsat/prompts/dsagent_prompt.py

@@ -0,0 +1,88 @@
+PLAN_PROMPT_TEMPLATE = """
+You are a helpful AI expert assistant, responsible for decision making on the action plans.
+
+# Task Objective and Data Report
+{research_problem}
+
+# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)
+{io_instructions}
+
+# Current Progress Log
+{running_log}
+
+# Relevant Past Experience Case
+{case}
+
+Based on all this information, provide a short, precise but detailed instruction summary on the action plan for the next step. Ensure the plan considers the CRITICAL I/O REQUIREMENTS.
+"""
+
+PROGRAMMER_PROMPT_TEMPLATE = """
+You are a helpful AI-oriented programming expert.
+
+# Overall Task Objective and Data Report
+{research_problem}
+
+# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)
+{io_instructions}
+
+# Current Progress Log (history of actions)
+{running_log}
+
+Given this python script:
+```python
+{code}
+```
+
+Now please edit this script according to the following instructions:
+
+```instruction
+{plan}
+```
+
+Provide the **full** code after the edit, ensuring it aligns with the overall goal, the CRITICAL I/O REQUIREMENTS, and lessons learned from the progress log.
+"""
+
+DEBUGGER_PROMPT_TEMPLATE = """
+You are a helpful AI-oriented programming expert.
+
+# Overall Task Objective and Data Report
+{research_problem}
+
+# CRITICAL I/O REQUIREMENTS (MUST BE FOLLOWED)
+{io_instructions}
+
+# Current Progress Log (history of actions)
+{running_log}
+
+The instruction for modification was:
+
+```instruction
+{plan}
+```
+
+This is the current python code:
+
+```python
+{code}
+```
+
+However, there are some bugs in this version. Here is the execution log:
+
+```log
+{error_log}
+```
+
+Please revise the script to fix these bugs and provide the **full** corrected code, ensuring it aligns with the overall goal, the CRITICAL I/O REQUIREMENTS, and lessons learned from the progress log.
+"""
+
+LOGGER_PROMPT_TEMPLATE = """
+Given the instructions, execution log, and code difference of the last action:
+[Instructions]: {plan}
+[Execution Log]: {execution_log}
+[Code Difference]: {diff}
+[Progress Log]: {running_log}
+
+Summarize the progress of the last step and append it to the progress log in this format:
+[Action Summary]: Summarize what action was taken in the last step.
+[Action Result]: Summarize the outcome of the action and whether it successfully achieved the objective defined in the [Instructions].
+"""