OpenAI Responses API previous_response_id & Conversations State Errors

from openai import OpenAI, NotFoundError

client = OpenAI()


def chat_turn(user_msg: str, prev_id: str | None) -> tuple[str, str]:
    """Return (assistant_text, new_response_id). Handles expired chain gracefully."""
    try:
        resp = client.responses.create(
            model="gpt-5.4",
            input=user_msg,
            previous_response_id=prev_id,      # None on first call
            store=True,                        # explicit (default) — required for chaining
            metadata={"user_id": "user-42", "purpose": "onboarding_chat"},
        )
        return resp.output_text, resp.id

    except NotFoundError as e:
        # prev_id expired, deleted, or belongs to another project
        # Fall back: start a fresh chain
        if prev_id is not None:
            resp = client.responses.create(
                model="gpt-5.4",
                input=user_msg,
                store=True,
                metadata={"user_id": "user-42", "resumed_after_expiry": True},
            )
            return resp.output_text, resp.id
        raise


# Turn 1 — no previous
text_1, id_1 = chat_turn("Hi, I need help setting up my account.", None)

# Turn 2 — chain from turn 1
text_2, id_2 = chat_turn("What info do you need from me?", id_1)

# Turn 3 — chain from turn 2
text_3, id_3 = chat_turn("Great, my email is sana@example.com.", id_2)


# ✅ Persist the LAST response ID in your DB, keyed by session
# When the user returns, load id_3 and continue from there
# On 404, the fallback above starts fresh — user sees a slight
# context reset but the chat continues instead of erroring out


# ✅ To prevent expiry for a specific chain, refresh the head periodically
# Reading a stored response resets its retention (behavior may vary; verify)
_ = client.responses.retrieve(id_3)          # touches the resource


# ✅ Force delete when you no longer need the chain (retention hygiene)
client.responses.delete(id_1)                # only need to keep the tail; deleting mid-chain
                                             # invalidates future references to id_2 too

from openai import OpenAI

client = OpenAI()


# ✅ One conversation per user session — create at signup or first chat
def get_or_create_conversation_for_user(user_id: str, chat_id: str) -> str:
    """Return an existing conversation_id or create a new one."""
    # In production, look this up in your DB first
    existing = your_db.get_conversation_id(user_id=user_id, chat_id=chat_id)
    if existing:
        return existing

    conv = client.conversations.create(
        metadata={
            "user_id": user_id,
            "chat_id": chat_id,
            "created_via": "web_app",
        },
    )
    your_db.save_conversation_id(user_id=user_id, chat_id=chat_id, conv_id=conv.id)
    return conv.id


# ✅ Every turn uses the same conversation_id for this user
def user_turn(user_id: str, chat_id: str, msg: str) -> str:
    conv_id = get_or_create_conversation_for_user(user_id, chat_id)
    resp = client.responses.create(
        model="gpt-5.4",
        input=msg,
        conversation=conv_id,                # ← state resumes from here
        instructions="You are the personal assistant for this user.",
    )
    return resp.output_text


# ✅ Inspect what's in a conversation (audit, debugging)
def dump_conversation(conv_id: str, limit: int = 100):
    items = client.conversations.items.list(conversation_id=conv_id, limit=limit)
    for item in items.data:
        print(item.type, item.id, getattr(item, "created_at", ""))


# ✅ Add items manually (import history from another system)
client.conversations.items.create(
    conversation_id="conv_abc",
    items=[
        {"type": "message", "role": "user",      "content": "Hi from imported history"},
        {"type": "message", "role": "assistant", "content": "Welcome back."},
    ],
)


# ✅ Delete a conversation entirely (GDPR/right-to-be-forgotten)
client.conversations.delete("conv_abc")


# ❌ ANTI-PATTERN — shared conversation for multiple users
# GLOBAL_CONV = client.conversations.create().id   # DO NOT DO THIS
# @api.post("/chat")
# def chat(msg: str, user_id: str):
#     return client.responses.create(
#         model="gpt-5.4", input=msg,
#         conversation=GLOBAL_CONV,                 # every user sees every other user's history
#     )


# ✅ FastAPI pattern
from fastapi import FastAPI
api = FastAPI()

@api.post("/chat/{user_id}/{chat_id}")
async def chat(user_id: str, chat_id: str, message: str):
    return {"reply": user_turn(user_id, chat_id, message)}

from openai import OpenAI

client = OpenAI()


# ✅ Client-managed history — no server-side persistence
class Session:
    def __init__(self, system: str):
        self.instructions = system
        self.history: list[dict] = []           # [{"role": "user"|"assistant", "content": "..."}]

    def send(self, user_msg: str, model: str = "gpt-5.4") -> str:
        self.history.append({"role": "user", "content": user_msg})

        # Trim if history is getting long (compliance-friendly cap)
        trimmed = self._trim(self.history)

        resp = client.responses.create(
            model=model,
            instructions=self.instructions,
            input=trimmed,
            store=False,                        # no server-side storage
            max_output_tokens=800,
        )
        reply = resp.output_text
        self.history.append({"role": "assistant", "content": reply})
        return reply

    @staticmethod
    def _trim(hist: list[dict], max_chars: int = 60_000) -> list[dict]:
        """Trim from oldest to keep total under max_chars. Keep the last turn intact."""
        total = sum(len(m["content"]) for m in hist)
        if total <= max_chars:
            return hist
        # Drop oldest pairs until under limit; always keep the last user message
        kept = list(hist)
        while sum(len(m["content"]) for m in kept) > max_chars and len(kept) > 2:
            kept = kept[2:]                     # drop oldest user+assistant pair
        return kept


# Usage
sess = Session(system="You are a HIPAA-compliant patient-intake bot. No PHI leaves this session.")
print(sess.send("I have a headache."))
print(sess.send("It started this morning."))
print(sess.send("What should I do?"))
# sess.history is the source of truth; nothing is stored server-side


# ✅ Persist ONLY on your side (encrypted DB, audit-logged, etc.)
def save_session_to_db(user_id: str, sess: Session):
    encrypted = encrypt(json.dumps(sess.history))
    db.set(f"session:{user_id}", encrypted)


def restore_session_from_db(user_id: str, system: str) -> Session:
    raw = db.get(f"session:{user_id}")
    sess = Session(system=system)
    if raw:
        sess.history = json.loads(decrypt(raw))
    return sess