from openai import OpenAI

client = OpenAI(api_key="your-api-key")

conversation = [
    {"role": "system", "content": "You are a helpful assistant for Bilal's automation agency. Answer questions about Make.com, n8n, GoHighLevel, and AI voice agents."},
]

def chat(user_message: str) -> str:
    conversation.append({"role": "user", "content": user_message})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=conversation,
    )
    
    assistant_message = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": assistant_message})
    
    return assistant_message

# Usage
print(chat("What is Make.com good for?"))
print(chat("How does it compare to Zapier?"))

You are an AI assistant for Riverside Dental, a family dental practice in Austin, Texas.

Your job is to help website visitors with:
- Questions about our services (cleanings, fillings, cosmetic dentistry, orthodontics)
- Appointment booking (collect name, phone, preferred date/time, service needed)
- Insurance questions (we accept Delta Dental, Cigna, Aetna, and United Healthcare)
- General dental FAQs

Our hours are Monday-Friday 8am-6pm and Saturday 9am-2pm.
Our address is 1234 Main Street, Austin TX 78701.
Our phone number is (512) 555-0100.

If someone asks about a specific tooth pain or dental emergency, provide basic first aid guidance and strongly encourage them to call us immediately or visit an emergency dentist.

Do not provide diagnoses. Do not discuss competitor practices. Do not discuss pricing without noting that costs vary by insurance and treatment plan.

Keep responses concise. If the visitor wants to book an appointment, collect their information and confirm you will pass it to our team.

MAX_HISTORY = 20  # Keep last 10 exchanges (20 messages)

def trim_conversation(conversation: list) -> list:
    system_messages = [m for m in conversation if m["role"] == "system"]
    non_system = [m for m in conversation if m["role"] != "system"]
    return system_messages + non_system[-MAX_HISTORY:]

import tiktoken

def count_tokens(messages: list, model: str = "gpt-4o-mini") -> int:
    encoding = tiktoken.encoding_for_model(model)
    return sum(len(encoding.encode(m["content"])) for m in messages)

def chat_streaming(user_message: str):
    conversation.append({"role": "user", "content": user_message})
    
    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=conversation,
        stream=True,
    )
    
    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content:
            token = chunk.choices[0].delta.content
            full_response += token
            print(token, end="", flush=True)  # Or send to your frontend
    
    conversation.append({"role": "assistant", "content": full_response})
    return full_response

tools = [
    {
        "type": "function",
        "function": {
            "name": "check_appointment_availability",
            "description": "Check available appointment slots for a given date",
            "parameters": {
                "type": "object",
                "properties": {
                    "date": {
                        "type": "string",
                        "description": "The date to check availability for, in YYYY-MM-DD format"
                    },
                    "service_type": {
                        "type": "string",
                        "description": "The type of appointment requested"
                    }
                },
                "required": ["date"]
            }
        }
    }
]

def handle_tool_call(tool_name: str, tool_args: dict) -> str:
    if tool_name == "check_appointment_availability":
        # Your actual availability check logic here
        date = tool_args.get("date")
        return f"Available slots on {date}: 9:00am, 11:00am, 2:00pm, 4:00pm"
    return "Tool not found"

def chat_with_tools(user_message: str) -> str:
    conversation.append({"role": "user", "content": user_message})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=conversation,
        tools=tools,
    )
    
    message = response.choices[0].message
    
    # Check if the model wants to call a tool
    if message.tool_calls:
        conversation.append(message)  # Add the tool call message
        
        for tool_call in message.tool_calls:
            import json
            result = handle_tool_call(
                tool_call.function.name,
                json.loads(tool_call.function.arguments)
            )
            conversation.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })
        
        # Get the final response with tool results included
        final_response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=conversation,
        )
        assistant_content = final_response.choices[0].message.content
        conversation.append({"role": "assistant", "content": assistant_content})
        return assistant_content
    
    conversation.append({"role": "assistant", "content": message.content})
    return message.content

from fastapi import FastAPI
from pydantic import BaseModel
from fastapi.responses import StreamingResponse
import json

app = FastAPI()

class ChatRequest(BaseModel):
    message: str
    session_id: str

sessions = {}  # In production, use Redis

@app.post("/chat")
async def chat_endpoint(request: ChatRequest):
    if request.session_id not in sessions:
        sessions[request.session_id] = [
            {"role": "system", "content": "Your system prompt here"}
        ]
    
    conversation = sessions[request.session_id]
    conversation.append({"role": "user", "content": request.message})
    
    async def generate():
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=conversation,
            stream=True,
        )
        full_response = ""
        for chunk in stream:
            if chunk.choices[0].delta.content:
                token = chunk.choices[0].delta.content
                full_response += token
                yield f"data: {json.dumps({'token': token})}\n\n"
        conversation.append({"role": "assistant", "content": full_response})
        yield "data: [DONE]\n\n"
    
    return StreamingResponse(generate(), media_type="text/event-stream")