<task>
[Mandatory: A detailed, unambiguous description of the desired code's purpose, functionality, and expected behavior. Be specific about inputs, outputs, and any core logic.]
</task>

<constraints>
[Mandatory: A bulleted list of all technical, environmental, and stylistic limitations. This includes programming language, framework versions, required libraries, performance targets, security considerations, and code style guidelines.]
- Language/Framework/Version: e.g., Python 3.10, Flask 2.3, React 18.2, Node.js 20.x
- Dependencies: e.g., `requests`, `numpy`, `express`, `pytest`
- Output Format: e.g., single `main.py` file, multiple `.js` files in a `src/` directory, JSON configuration.
- Performance: e.g., O(n) complexity for data processing, response time < 100ms.
- Security: e.g., prevent SQL injection, sanitize all user inputs, use environment variables for secrets.
- Style/Linter: e.g., adhere to PEP 8, use Prettier with default settings, include JSDoc comments.
- No external libraries beyond: [list allowed exceptions]
- Do not use: [list forbidden constructs or libraries]
</constraints>

<verification_criteria>
[Mandatory: A clear, objective list of how the generated code will be tested and validated. This could include unit test requirements, integration tests, or specific API responses.]
- Unit Tests: e.g., must include `pytest` tests covering 100% of new functions.
- Acceptance Tests: e.g., `curl -X GET http://localhost:5000/health` must return `HTTP 200 OK` and body `{ "status": "healthy" }`.
- Linting: e.g., `flake8` or `ESLint` must pass without warnings or errors.
- Functionality: e.g., all specified endpoints must be implemented and return correct data structures.
</verification_criteria>

<example_input_output>
[Optional: Provide concrete examples of inputs and their corresponding expected outputs, or a desired code snippet structure. This is especially useful for complex logic or API definitions.]
- Input: `POST /data` with `{"name": "test", "value": 123}`
- Expected Output: `HTTP 201 Created` with body `{"id": "unique-uuid", "name": "test", "value": 123}`
- Desired Structure: A Flask application with `app.py` and a `tests/test_app.py` directory.
</example_input_output>

<user_context>
[Optional: Any specific context about the existing project, prior conversation, or environmental setup that Claude needs to be aware of but isn't a direct constraint.]
- Existing codebase uses a custom logging utility, `my_logger.py`.
- This code will run in a Docker container on Ubuntu 22.04.
</user_context>

import os
from anthropic import Anthropic

# Ensure your ANTHROPIC_API_KEY is set as an environment variable
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

def generate_code_with_claude(task_description, constraints, verification, example=None, context=None):
    prompt_parts = [
        f"<task>\n{task_description}\n</task>",
        f"<constraints>\n{constraints}\n</constraints>",
        f"<verification_criteria>\n{verification}\n</verification_criteria>"
    ]
    if example:
        prompt_parts.append(f"<example_input_output>\n{example}\n</example_input_output>")
    if context:
        prompt_parts.append(f"<user_context>\n{context}\n</user_context>")

    full_prompt = "\n\n".join(prompt_parts)

    print("Sending prompt to Claude...")
    message = client.messages.create(
        model="claude-3-opus-20240229", # Or "claude-3-sonnet-20240229" for lower cost/speed
        max_tokens=4000, # Adjust based on expected output length
        messages=[
            {"role": "user", "content": full_prompt}
        ]
    )
    return message.content[0].text

# Example Usage:
task = """
Create a Python Flask application that provides two endpoints:
1. `/health` (GET): Returns a JSON response `{"status": "healthy"}` with a 200 OK status.
2. `/data` (POST): Accepts a JSON payload `{"item": "string", "quantity": "integer"}`.
   It should store this data in an in-memory list, assign a unique UUID to each entry,
   and return the stored entry including its UUID with a 201 Created status.
"""
constraints = """
- Language/Framework/Version: Python 3.10, Flask 2.3.x
- Dependencies: `Flask`, `uuid`
- Output Format: Single `app.py` file, no separate test files for now.
- Security: No direct database access, use in-memory list for simplicity.
"""
verification = """
- `/health` endpoint must return `{"status": "healthy"}` and HTTP 200.
- `/data` endpoint must accept JSON, store it, and return the stored data with a UUID and HTTP 201.
- Code must be executable directly via `python app.py`.
"""

generated_code_response = generate_code_with_claude(task, constraints, verification)
print("\n--- Claude's Generated Code ---\n")
print(generated_code_response)

import os
import json
from anthropic import Anthropic

class ClaudeCodeAgent:
    def __init__(self, api_key, model="claude-3-opus-20240229"):
        self.client = Anthropic(api_key=api_key)
        self.model = model
        self.history = [] # Stores full conversation history for context

    def send_message(self, user_message, system_prompt=None, max_tokens=4000):
        messages = []
        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})
        
        # Append existing history to maintain context
        messages.extend(self.history)
        messages.append({"role": "user", "content": user_message})

        try:
            response = self.client.messages.create(
                model=self.model,
                max_tokens=max_tokens,
                messages=messages
            )
            response_text = response.content[0].text
            
            # Update history for next turn
            self.history.append({"role": "user", "content": user_message})
            self.history.append({"role": "assistant", "content": response_text})
            
            return response_text
        except Exception as e:
            print(f"Error communicating with Claude: {e}")
            return None

    def reset_history(self):
        self.history = []

# Initialize the agent
anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
if not anthropic_api_key:
    raise ValueError("ANTHROPIC_API_KEY environment variable not set.")
agent = ClaudeCodeAgent(anthropic_api_key)

# System prompts for different agent roles
PLANNER_PROMPT = """You are a senior software architect. Your role is to break down a complex coding task into a series of smaller, sequential, and actionable steps. Each step should be clear, concise, and independently implementable. Output only a numbered list of steps. Do not generate code or explanations, just the steps."""

CODER_PROMPT = """You are a highly skilled software developer. Your task is to implement the given coding step. Incorporate it into the provided existing code (if any). Ensure the code is correct, follows best practices, and addresses the step directly. Include any necessary imports or dependencies. If the step is to add unit tests, provide the tests.
Existing code:

Coding step to implement: {step_description}
"""

CRITIC_PROMPT = """You are a meticulous code reviewer. Your role is to analyze the provided code against a specific coding step and give constructive feedback. Identify any errors, missing functionality, style violations, or potential improvements. Be specific and actionable. If the code is perfect, state 'LGTM' (Looks Good To Me).
Coding step: {step_description}
Code to review:

"""

def run_agentic_workflow(initial_task, max_iterations=5):
    agent.reset_history() # Start with a clean slate for the workflow

    print(f"--- Initial Task: {initial_task} ---")

    # 1. Planner Agent: Break down the task
    print("\n[PLANNER] Decomposing task...")
    plan = agent.send_message(initial_task, system_prompt=PLANNER_PROMPT)
    if not plan: return "Failed to generate plan."
    print(f"Plan:\n{plan}")
    steps = [s.strip() for s in plan.split('\n') if s.strip() and s[0].isdigit()]

    if not steps:
        return "Planner failed to generate any steps."

    current_code = ""
    for i, step in enumerate(steps):
        print(f"\n--- Executing Step {i+1}/{len(steps)}: {step} ---")
        iteration_count = 0
        while iteration_count < max_iterations:
            # 2. Coder Agent: Implement the current step
            print(f"[CODER] Implementing step '{step}' (Iteration {iteration_count + 1})...")
            coder_user_message = CODER_PROMPT.format(existing_code=current_code, step_description=step)
            generated_code = agent.send_message(coder_user_message, system_prompt=None) # Coder prompt is user_message
            if not generated_code:
                print("[CODER] Failed to generate code.")
                break # Move to next step or fail

            print(f"[CODER] Generated code snippet:\n{generated_code[:500]}...") # Show first 500 chars

            # 3. Critic Agent: Review the generated code
            print(f"[CRITIC] Reviewing code for step '{step}'...")
            critic_user_message = CRITIC_PROMPT.format(step_description=step, code_to_review=generated_code)
            feedback = agent.send_message(critic_user_message, system_prompt=None) # Critic prompt is user_message
            if not feedback:
                print("[CRITIC] Failed to get feedback.")
                break # Move to next step or fail

            print(f"[CRITIC] Feedback:\n{feedback}")

            if "LGTM" in feedback or "Looks Good To Me" in feedback:
                print(f"[CRITIC] Code for step '{step}' approved. Integrating.")
                current_code = generated_code # Update the current_code with the approved code
                break # Move to next step
            else:
                print(f"[CODER] Refinement needed. Incorporating feedback for next iteration.")
                # The next Coder prompt will implicitly use the updated history with the critic's feedback.
                # The Coder prompt above (coder_user_message) needs to be updated to explicitly include the feedback.
                # For simplicity here, we rely on the continuous history.
                # A more robust system would explicitly pass feedback back to the coder.
                coder_user_message_with_feedback = f"{CODER_PROMPT.format(existing_code=current_code, step_description=step)}\n\nCRITIC FEEDBACK:\n{feedback}\n\nPlease revise the code based on this feedback."
                # We need to explicitly instruct the agent to use the feedback.
                # A new message to the agent, potentially resetting its immediate history for this specific sub-task if needed.
                # For this example, we'll keep the history continuous and assume Claude can pick up on the feedback.
                # A cleaner approach might involve a dedicated `refine_code` function or tool.
                current_code = generated_code # For demonstration, just take it and hope next iteration improves
            
            iteration_count += 1
        
        if iteration_count == max_iterations:
            print(f"Warning: Max iterations reached for step '{step}'. Moving to next step with potentially unrefined code.")

    print("\n--- Agentic Workflow Completed ---")
    return current_code

# Example Usage of the agentic workflow
complex_task = """
Develop a Python CLI tool using `argparse` that can:
1. Accept a `--name` argument (string, required)
2. Accept a `--count` argument (integer, optional, default to 1)
3. Print a greeting message: "Hello, [name]! You requested [count] times."
4. Include basic unit tests for the greeting function.
"""

final_code = run_agentic_workflow(complex_task, max_iterations=3)
print("\nFinal Generated Code:\n")
print(final_code)

# Pseudocode for RAG integration with a hypothetical vector store
import os
import glob
from typing import List, Dict

# Placeholder for an actual embedding model and vector store
# In a real scenario, you'd use libraries like `sentence-transformers`, `openai`, `chromadb`, etc.

def get_code_chunks(directory=".") -> List[str]:
    """Simulates splitting a codebase into manageable chunks."""
    code_chunks = []
    # Find all Python files
    for filepath in glob.glob(os.path.join(directory, '**/*.py'), recursive=True):
        with open(filepath, 'r') as f:
            content = f.read()
            # Simple chunking: each function or class as a chunk
            # In real RAG, you'd use AST parsing or more sophisticated chunking
            chunks = content.split('\ndef ') # Crude split for demonstration
            for chunk in chunks:
                if chunk.strip():
                    code_chunks.append(f"File: {filepath}\n```python\n{chunk}\n```")
    return code_chunks

def create_embeddings(text_chunks: List[str]) -> List[List[float]]:
    """Simulates creating embeddings for text chunks."""
    # This would involve calling an actual embedding model API or local model
    print(f"Simulating embedding creation for {len(text_chunks)} chunks...")
    # Return dummy embeddings for demonstration
    return [[i * 0.1 for i in range(10)] for i in range(len(text_chunks))]

class VectorStore:
    def __init__(self, chunks, embeddings):
        self.chunks = chunks
        self.embeddings = embeddings
        # In a real scenario, this would be a proper vector database
        # For demo, a simple list-based "store"

    def search(self, query_embedding: List[float], top_k=3) -> List[str]:
        """Simulates searching for top_k most similar chunks."""
        # Dummy similarity search
        print(f"Simulating vector store search for query...")
        # In reality, calculate cosine similarity between query_embedding and self.embeddings
        # and return top_k chunks.
        return self.chunks[:top_k] # Just return first few for demo

# Setup RAG components (run once or on code changes)
# codebase_chunks = get_code_chunks('./my_project_repo') # Assume './my_project_repo' exists
# codebase_embeddings = create_embeddings(codebase_chunks)
# vector_store = VectorStore(codebase_chunks, codebase_embeddings)

# Function to retrieve context for Claude
def retrieve_relevant_code_context(query_task: str, vector_store: VectorStore, top_k=3) -> str:
    # In a real system, generate embedding for query_task
    # query_embedding = create_embedding([query_task])[0]
    # relevant_chunks = vector_store.search(query_embedding, top_k)
    
    # For this guide, we'll use a placeholder for relevant chunks
    # Assume a function `get_code_chunks` and `vector_store` are set up.
    # For a practical demo, let's just return some hardcoded relevant code.
    relevant_chunks = [
        "File: utils.py\n```python\ndef calculate_checksum(data):\n    return sum(bytearray(data.encode())) % 256\n```",
        "File: config.py\n```python\nAPI_VERSION = 'v1'\nDEBUG_MODE = True\n```"
    ]
    
    if not relevant_chunks:
        return ""
    
    return "\n\n".join(relevant_chunks)

# Example of integrating RAG into a prompt
def generate_code_with_rag(task_description, constraints, verification, vector_store_instance, example=None, context=None):
    relevant_code = retrieve_relevant_code_context(task_description, vector_store_instance, top_k=5)
    
    prompt_parts = [
        f"<task>\n{task_description}\n</task>",
        f"<constraints>\n{constraints}\n</constraints>",
        f"<verification_criteria>\n{verification}\n</verification_criteria>"
    ]
    if relevant_code:
        prompt_parts.append(f"<relevant_code>\n{relevant_code}\n</relevant_code>")
    if example:
        prompt_parts.append(f"<example_input_output>\n{example}\n</example_input_output>")
    if context:
        prompt_parts.append(f"<user_context>\n{context}\n</user_context>")

    full_prompt = "\n\n".join(prompt_parts)

    print("Sending RAG-augmented prompt to Claude...")
    message = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=4000,
        messages=[
            {"role": "user", "content": full_prompt}
        ]
    )
    return message.content[0].text

# To run this, you'd need a local project and a vector store setup.
# For simplicity, let's assume `vector_store_instance` is initialized with some dummy data.
dummy_chunks = [
    "def process_user_data(user_id, data): return f'Processed {data} for {user_id}'",
    "class UserDB: def save(user): pass"
]
dummy_embeddings = create_embeddings(dummy_chunks)
dummy_vector_store = VectorStore(dummy_chunks, dummy_embeddings)

# Example Usage with RAG (conceptually)
rag_task = """
Implement a new function `handle_user_request(request_data)` that leverages existing `process_user_data` function.
The function should validate `request_data` for 'user_id' and 'payload' fields before calling `process_user_data`.
"""
rag_constraints = """
- Language: Python 3.10
- Dependencies: Standard library only.
"""
rag_verification = """
- Function `handle_user_request` exists.
- Calls `process_user_data` with correct arguments.
- Handles missing 'user_id' or 'payload' gracefully (e.g., raise ValueError).
"""

# generated_rag_code = generate_code_with_rag(rag_task, rag_constraints, rag_verification, dummy_vector_store)
# print("\n--- Claude's RAG-Augmented Code ---\n")
# print(generated_rag_code)

# Extending the ClaudeCodeAgent
from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT

class ClaudeCodeAgentWithSummary(ClaudeCodeAgent):
    def __init__(self, api_key, model="claude-3-opus-20240229", max_history_tokens=50000):
        super().__init__(api_key, model)
        self.max_history_tokens = max_history_tokens
        self.current_history_tokens = 0 # Track tokens in history

    def _count_tokens(self, text):
        # Anthropic's client has a token counter, but for simplicity, approximate
        return len(text.split()) # Word count as a rough proxy for tokens

    def _summarize_old_history(self):
        # Find a point in history to summarize
        summary_point = -1
        temp_tokens = 0
        for i in reversed(range(len(self.history))):
            message = self.history[i]
            # Approximate token count for message content
            content_tokens = self._count_tokens(message.get("content", ""))
            if temp_tokens + content_tokens > self.max_history_tokens / 2: # Summarize older half
                summary_point = i
                break
            temp_tokens += content_tokens

        if summary_point > 0:
            old_messages_to_summarize = self.history[:summary_point]
            self.history = self.history[summary_point:] # Keep newer messages

            old_conversation_text = "\n".join([
                f"{msg['role']}: {msg['content']}" for msg in old_messages_to_summarize
            ])

            print("[SUMMARY AGENT] Summarizing old conversation history...")
            summary_prompt = f"{HUMAN_PROMPT} Please summarize the following conversation history concisely, capturing all key decisions, code snippets, and outstanding tasks. Focus on outcomes relevant to code development.\n\n{old_conversation_text}\n\n{AI_PROMPT}Summary:"
            
            # Use a fresh agent or a dedicated summarizer model to avoid polluting current history
            summarizer_agent = ClaudeCodeAgent(self.client.api_key, model="claude-3-haiku-20240307") # Cheaper model for summary
            summary_response = summarizer_agent.send_message(summary_prompt, max_tokens=1000)

            if summary_response:
                self.history.insert(0, {"role": "system", "content": f"Previous conversation summary: {summary_response}"})
                print(f"[SUMMARY AGENT] History summarized. New history length: {len(self.history)} messages.")
                self.current_history_tokens = self._count_tokens(summary_response) + sum(self._count_tokens(m.get("content", "")) for m in self.history[1:])
            else:
                print("[SUMMARY AGENT] Failed to summarize history.")

    def send_message_with_summary(self, user_message, system_prompt=None, max_tokens=4000):
        # Check if history needs summarization before sending new message
        # Roughly estimate new message tokens and add to current history tokens
        if self.current_history_tokens + self._count_tokens(user_message) > self.max_history_tokens:
            self._summarize_old_history()
        
        response = self.send_message(user_message, system_prompt, max_tokens)
        if response:
            self.current_history_tokens = sum(self._count_tokens(m.get("content", "")) for m in self.history)
        return response

# Example Usage (conceptually, would replace `agent.send_message` in the agentic loop)
# agent_with_summary = ClaudeCodeAgentWithSummary(anthropic_api_key, max_history_tokens=10000)
# agent_with_summary.send_message_with_summary("Long task description...")

# On macOS/Linux
> mkdir claude_dev_project
> cd claude_dev_project
> python3 -m venv venv
> source venv/bin/activate
> pip install anthropic # Install the Anthropic Python client
> git init . # Initialize a Git repository
> touch README.md .gitignore # Create basic files
> echo "venv/" > .gitignore
> git add .gitignore README.md
> git commit -m "Initial project setup with venv and git"

# On Windows (PowerShell)
> mkdir claude_dev_project
> cd claude_dev_project
> python -m venv venv
> .\venv\Scripts\activate
> pip install anthropic
> git init .
> New-Item -ItemType File -Name "README.md"
> New-Item -ItemType File -Name ".gitignore"
> Add-Content -Path ".gitignore" -Value "venv/"
> git add .gitignore README.md
> git commit -m "Initial project setup with venv and git"

import os
import subprocess

# Ensure the agent has access to these tools
# This is a simplified example; in a real system, you'd use Anthropic's Tools API
# or a framework like LangChain/CrewAI that handles tool calling.

def read_file(filepath: str) -> Dict[str, str]:
    """Reads the content of a file from the current directory."""
    if not os.path.exists(filepath):
        return {"status": "error", "message": f"File not found: {filepath}"}
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()
        return {"status": "success", "content": content}
    except Exception as e:
        return {"status": "error", "message": f"Error reading file {filepath}: {str(e)}"}

def write_file(filepath: str, content: str) -> Dict[str, str]:
    """Writes content to a file in the current directory. Creates or overwrites."""
    try:
        os.makedirs(os.path.dirname(filepath), exist_ok=True) # Ensure directory exists
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        return {"status": "success", "message": f"File '{filepath}' written successfully."}
    except Exception as e:
        return {"status": "error", "message": f"Error writing file {filepath}: {str(e)}"}

def list_directory_contents(path: str = '.') -> Dict[str, str]:
    """Lists files and directories in the specified path."""
    if not os.path.isdir(path):
        return {"status": "error", "message": f"Path is not a directory: {path}"}
    try:
        contents = os.listdir(path)
        return {"status": "success", "contents": "\n".join(contents)}
    except Exception as e:
        return {"status": "error", "message": f"Error listing directory {path}: {str(e)}"}

def run_shell_command(command: str) -> Dict[str, str]:
    """Executes a shell command and returns its stdout/stderr."""
    # > ⚠️ WARNING: This tool grants significant power to the AI. Use with extreme caution
    # > and only in a sandboxed, trusted environment. Always review commands before execution.
    try:
        result = subprocess.run(command, shell=True, capture_output=True, text=True, check=True)
        return {"status": "success", "stdout": result.stdout, "stderr": result.stderr}
    except subprocess.CalledProcessError as e:
        return {"status": "error", "message": f"Command failed: {e.cmd}\nStdout: {e.stdout}\nStderr: {e.stderr}"}
    except Exception as e:
        return {"status": "error", "message": f"Error running command: {str(e)}"}

# You would then expose these tools to your Claude agent.
# Example for Anthropic's Tools API (conceptual, as the exact syntax changes)
# This example uses a simplified "tool calling" where the agent's prompt guides it to output
# a specific format that your script then parses and executes.
# A more advanced setup would use Anthropic's actual tool definitions.

# Dummy tool registry for this example
TOOL_REGISTRY = {
    "read_file": read_file,
    "write_file": write_file,
    "list_directory_contents": list_directory_contents,
    "run_shell_command": run_shell_command
}

def execute_tool_call(tool_name: str, args: Dict) -> Dict:
    """Executes a tool call based on parsed AI output."""
    if tool_name in TOOL_REGISTRY:
        return TOOL_REGISTRY[tool_name](**args)
    return {"status": "error", "message": f"Tool '{tool_name}' not found."}

# Example of an agent's prompt to encourage tool use
TOOL_USE_PROMPT = """You are an AI assistant capable of interacting with the local file system and running shell commands.
When you need to perform an action, output a JSON object in the format:
```json
{
  "tool_name": "name_of_the_tool",
  "args": {
    "arg1": "value1",
    "arg2": "value2"
  }
}

**Verify**: Manually test each tool function from your Python interpreter to ensure it performs as expected and handles errors gracefully.
```python
# In your Python interpreter (with venv activated)
# > python
# >>> from your_script_name import read_file, write_file, list_directory_contents, run_shell_command
# >>> write_file("test.txt", "Hello, Claude!")
# {'status': 'success', 'message': "File 'test.txt' written successfully."}
# >>> read_file("test.txt")
# {'status': 'success', 'content': 'Hello, Claude!'}
# >>> list_directory_contents()
# {'status': 'success', 'contents': 'test.txt\nvenv\nREADME.md\n.gitignore'}
# >>> run_shell_command("ls -l") # Or `dir` on Windows
# {'status': 'success', 'stdout': 'total 8\n-rw-r--r-- 1 user group 14 Mar 15 10:30 test.txt\n...', 'stderr': ''}

> ✅ All file system and shell command tools function correctly, providing a robust interface for Claude's interaction.

import json
import time # For simulated delays

# Assuming ClaudeCodeAgent is defined as before, and tool functions are available

def run_tool_augmented_workflow(initial_task, max_tool_calls_per_turn=3, max_turns=10):
    agent.reset_history()
    print(f"--- Starting Tool-Augmented Workflow for: {initial_task} ---")

    current_turn = 0
    while current_turn < max_turns:
        print(f"\n[TURN {current_turn + 1}]")
        user_prompt_for_claude = TOOL_USE_PROMPT.format(task_description=initial_task)
        if current_turn > 0: # Append previous tool outputs to the prompt for subsequent turns
            # This is a simplification. In a real system, tool outputs are added to history.
            # For this example, we'll assume the agent's history naturally includes this.
            pass

        claude_response = agent.send_message(user_prompt_for_claude, system_prompt="You are an AI assistant that uses tools to complete tasks. Your goal is to achieve the user's task by using the available tools.")
        if not claude_response:
            print("Claude failed to respond.")
            break

        print(f"[Claude] Response:\n{claude_response}")

        # Attempt to parse Claude's response for a tool call
        try:
            # Claude might output prose *and* a tool call. Look for the JSON.
            tool_call_json_start = claude_response.find("```json")
            tool_call_json_end = claude_response.find("```", tool_call_json_start + 1)
            
            tool_output_messages = []

            if tool_call_json_start != -1 and tool_call_json_end != -1:
                tool_call_str = claude_response[tool_call_json_start + 7 : tool_call_json_end].strip()
                tool_call = json.loads(tool_call_str)
                
                tool_name = tool_call.get("tool_name")
                tool_args = tool_call.get("args", {})

                print(f"[SYSTEM] Executing tool: {tool_name} with args {tool_args}")
                tool_result = execute_tool_call(tool_name, tool_args)
                print(f"[SYSTEM] Tool result: {tool_result}")
                tool_output_messages.append({"role": "user", "content": f"<tool_output name=\"{tool_name}\">\n{json.dumps(tool_result)}\n</tool_output>"})
                
                # Add tool output to agent's history for Claude to use in next turn
                agent.history.extend(tool_output_messages)
            else:
                print("[SYSTEM] No tool call detected. Assuming final answer or planning step.")
                # If Claude doesn't call a tool, it might be providing a final answer or asking for clarification.
                # In a real system, you'd check for specific "final answer" tags.
                if "final answer" in claude_response.lower() or "task complete" in claude_response.lower():
                    print(f"Workflow completed: {claude_response}")
                    break
                
        except json.JSONDecodeError:
            print("[SYSTEM] Claude's response was not a valid tool call JSON. Continuing...")
        except Exception as e:
            print(f"[SYSTEM] Error processing tool call: {e}. Continuing...")
        
        time.sleep(1) # Simulate processing time
        current_turn += 1

    print("\n--- Tool-Augmented Workflow Finished ---")
    return agent.history # Return full history for review

# Example Task:
task_to_perform = """
Create a Python script named `hello.py` that prints "Hello from Claude Code!".
Then, verify its creation by listing the directory contents and running the script.
"""

# Run the workflow
final_workflow_history = run_tool_augmented_workflow(task_to_perform)
# You can then parse final_workflow_history to see the sequence of actions and results.