Simple Bot using OpenAI API

"""
A minimal customer feedback classifier using the OpenAI Responses API.

Features:
- Reads an API key from environment variables
- Classifies feedback as Positive/Negative
- If Negative, generates a brief preliminary support response
- Produces structured JSON output for reliability

Usage:
  python bot.py "The app keeps crashing when I open settings"
"""

from __future__ import annotations

import json
import os
import sys
from dataclasses import dataclass
from typing import Any, Dict

from openai import OpenAI


@dataclass(frozen=True)
class Result:
    sentiment: str
    confidence: float
    summary: str
    suggested_reply: str | None

    def to_dict(self) -> Dict[str, Any]:
        return {
            "sentiment": self.sentiment,
            "confidence": self.confidence,
            "summary": self.summary,
            "suggested_reply": self.suggested_reply,
        }


def _get_api_key() -> str:
    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        raise RuntimeError(
            "OPENAI_API_KEY is not set. "
            "Set it as an environment variable and retry."
        )
    return api_key


def classify_feedback(client: OpenAI, text: str) -> Result:
    """Classify input feedback and optionally propose a preliminary reply."""

    system_instructions = (
        "You are a customer support triage assistant.\n"

        "Task:\n"
        "1) Classify the user's feedback as Positive or Negative.\n"
        "2) Provide a 1-sentence summary of the feedback.\n"
        "3) Provide a confidence score from 0.0 to 1.0.\n"
        "4) If Negative, produce a short suggested support reply with steps.\n\n"
        
        "Output MUST be valid JSON with exactly these keys:\n"
        "{\n"
        '  \"sentiment\": \"Positive\" | \"Negative\",\n'
        '  \"confidence\": number,\n'
        '  \"summary\": string,\n'
        '  \"suggested_reply\": string | null\n'
        "}\n"
        
        "Do not output any extra keys or surrounding text."
    )

    user_message = f"Customer feedback:\n{text}"

    response = client.responses.create(
        model="gpt-5-nano",
        input=[
            {"role": "system", "content": system_instructions},
            {"role": "user", "content": user_message},
        ],
    )

    output_text = response.output_text

    try:
        data = json.loads(output_text)
    except json.JSONDecodeError as e:
        raise RuntimeError(
            "Model returned non-JSON output. "
            "Try tightening the instruction or adding retry logic."
        ) from e

    sentiment = str(data.get("sentiment", "")).strip()
    confidence = float(data.get("confidence", 0.0))
    summary = str(data.get("summary", "")).strip()
    suggested_reply = data.get("suggested_reply", None)
    if suggested_reply is not None:
        suggested_reply = str(suggested_reply).strip() or None

    if sentiment not in {"Positive", "Negative"}:
        raise RuntimeError(f"Unexpected sentiment value: {sentiment!r}")

    confidence = max(0.0, min(1.0, confidence))

    return Result(
        sentiment=sentiment,
        confidence=confidence,
        summary=summary,
        suggested_reply=suggested_reply,
    )


def main() -> int:
    if len(sys.argv) < 2:
        print('Usage: python bot.py "your feedback text here"')
        return 2

    feedback = " ".join(sys.argv[1:]).strip()
    if not feedback:
        print("Error: empty feedback text.")
        return 2

    client = OpenAI(api_key=_get_api_key())

    result = classify_feedback(client, feedback)
    print(json.dumps(result.to_dict(), indent=2, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())