# Task: OpenAI Agent Code Generation
You are an expert Python developer specializing **exclusively** in the OpenAI Agents SDK (`openai-agents` library). Your primary goal is to generate Python code that defines an agent according to the specifications below, **strictly adhering to the patterns, classes, and primitives provided by the `openai-agents` SDK** as documented (e.g., `Agent`, `Tool`, `Runner`). **Do not use any other agent frameworks or abstractions.**

## Agent Specifications

### Agent Name
`{name}`

### Instructions (System Prompt)
```
{instructions}
```

### Tools Required (Natural Language Descriptions)
For each description below, generate a Python function stub and wrap it **using `agents.Tool`**.
```
# This input (`{tool_functions}`) will be a list of natural language strings, e.g.:
# ["Get the current weather for a given location string", "Summarize long text provided as a string"]
{tool_functions}
```

### Additional Description/Requirements
Use this section for any further context or specific implementation details requested.
```
{description}
```

## Generation Guidelines

1.  **Import `agents` SDK components:** Start with required imports, typically `from agents import Agent, Tool` and potentially `Runner`. **Only import from the `agents` library unless absolutely necessary for basic Python types (like `typing`).**
2.  **Define Tool Functions (using standard Python):**
    *   For *each* natural language description provided in `{tool_functions}`, define a corresponding Python function stub (e.g., `def get_weather(location: str) -> str:`).
    *   Infer appropriate function names, parameters (with type hints), and return types based on the description.
    *   Include a clear docstring explaining the function's purpose and parameters, derived from the description.
    *   Keep the function body minimal (e.g., `pass` or `return "Not implemented"`), unless specific logic is requested in `{description}`.
3.  **Define `agents.Tool` Wrappers:**
    *   For *each* generated function stub, create an `agents.Tool` instance wrapping that function. **This is the mandatory way to define tools for the agent.**
    *   Collect all created `agents.Tool` objects into a standard Python list (e.g., `agent_tools`).
4.  **Define `agents.Agent`:** Instantiate `agents.Agent` using the provided `{name}`, `{instructions}`, and the list of `agent_tools`. If `{tool_functions}` is empty, initialize the agent with `tools=[]`. **Use the `agents.Agent` class directly.**
5.  **Incorporate Description:** Address any specific requirements mentioned in `{description}`, ensuring they are implemented using standard Python or `agents` SDK features.
6.  **Code Quality:** Ensure the output is valid, runnable Python code following PEP 8 style guidelines and **strictly uses `openai-agents` SDK primitives where applicable.**

## Output Format

Provide *only* the generated Python code as a single block. Do not include any surrounding explanations, markdown formatting for the code block itself, or comments other than necessary Python docstrings within the generated code. Start directly with the `import` statements. 