from praisonaiagents import Agent

def run_local_agent():
    agent = Agent(
        name="SimpleAgent",
        instructions="You are a helpful assistant that answers questions concisely.",
        llm="gpt-4o-mini"  # Using the specified model
    )
    
    while True:
        user_input = input("Ask a question (type 'exit' to quit): ")
        if user_input.lower() == 'exit':
            break
        
        response = agent.start(user_input)
        print("\nAgent response:")
        print(response)
        print("\n" + "-"*50 + "\n")

if __name__ == "__main__":
    run_local_agent()

from flask import Flask, request, jsonify
from praisonaiagents import Agent
import os

app = Flask(__name__)

# Create agent once at startup
support_agent = Agent(
    name="SupportAgent",
    instructions="You are a customer support agent that helps users with product questions.",
    llm="gpt-4o-mini"  # Using the specified model
)

@app.route('/api/support', methods=['POST'])
def get_support():
    data = request.json
    user_query = data.get('query', '')
    
    if not user_query:
        return jsonify({"error": "No query provided"}), 400
    
    try:
        response = support_agent.start(user_query)
        return jsonify({"response": response})
    except Exception as e:
        return jsonify({"error": str(e)}), 500

if __name__ == "__main__":
    app.run(debug=True, port=5000)

# Example AWS Lambda function
import json
from praisonaiagents import Agent

# Initialize agent outside the handler for reuse across invocations
agent = Agent(
    name="ServerlessAgent",
    instructions="You provide concise, helpful responses to user questions.",
    llm="gpt-4o-mini"  # Using the specified model
)

def lambda_handler(event, context):
    try:
        # Get the user query from the event
        body = json.loads(event.get('body', '{}'))
        user_query = body.get('query', '')
        
        if not user_query:
            return {
                'statusCode': 400,
                'body': json.dumps({'error': 'No query provided'})
            }
        
        # Process with the agent
        response = agent.start(user_query)
        
        return {
            'statusCode': 200,
            'body': json.dumps({'response': response})
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }

import os
from dotenv import load_dotenv
from praisonaiagents import Agent

# Load environment variables from .env file
load_dotenv()

# Access API key from environment variable
api_key = os.getenv("OPENAI_API_KEY")

# Create agent with API key
agent = Agent(
    name="SecureAgent",
    instructions="You are a helpful assistant.",
    llm="gpt-4o-mini",  # Using the specified model
    api_key=api_key  # Pass API key securely
)

import os
from praisonaiagents import Agent

def create_chat_interface():
    # Initialize agent
    agent = Agent(
        name="ChatAgent",
        instructions="""
        You are a conversational assistant that maintains context throughout the conversation.
        Respond in a helpful, concise manner.
        """,
        llm="gpt-4o-mini"  # Using the specified model
    )
    
    print("Chat with AI Assistant (type 'exit' to quit)")
    print("-" * 50)
    
    # Start conversation
    conversation_active = True
    first_message = True
    
    while conversation_active:
        # Get user input
        user_message = input("You: ")
        
        # Check if user wants to exit
        if user_message.lower() == 'exit':
            print("Goodbye!")
            conversation_active = False
            continue
        
        # Get agent response
        try:
            if first_message:
                response = agent.start(user_message)
                first_message = False
            else:
                response = agent.continue(user_message)
            
            print("\nAssistant:", response)
            print("\n" + "-" * 50)
        except Exception as e:
            print(f"Error: {str(e)}")
    
if __name__ == "__main__":
    create_chat_interface()

def test_agent_functionality():
    """Test basic agent functionality with various inputs"""
    agent = Agent(
        name="TestAgent",
        instructions="You are a helpful assistant for testing.",
        llm="gpt-4o-mini"  # Using the specified model
    )
    
    test_cases = [
        "What is artificial intelligence?",
        "How do I reset my password?",
        "Tell me about machine learning"
    ]
    
    for test_case in test_cases:
        print(f"\nTesting: {test_case}")
        response = agent.start(test_case)
        print(f"Response: {response[:100]}...")  # Print first 100 chars
        
        # Add assertions or validation logic here
        assert len(response) > 0, "Response should not be empty"

"""
# Customer Support Agent API

This API provides access to an AI customer support agent
that can answer questions about our products.

## Authentication

Include your API key in the request header:

## Endpoints

POST /api/support
- Request body: {"query": "Your question here"}
- Response: {"response": "Agent's answer"}

## Example

```python
import requests

response = requests.post(
    "https://api.example.com/api/support",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"query": "How do I reset my password?"}
)

print(response.json())

### 3. Version Control

Implement version control for your agents to track changes:

```python
class VersionedAgent:
    def __init__(self, name, version, instructions):
        self.name = name
        self.version = version
        self.agent = Agent(
            name=f"{name}_v{version}",
            instructions=instructions,
            llm="gpt-4o-mini"  # Using the specified model
        )
    
    def get_response(self, query):
        response = self.agent.start(query)
        return {
            "agent_name": self.name,
            "version": self.version,
            "response": response,
            "timestamp": datetime.now().isoformat()
        }