두 번째 걸음: 문 규칙 하나

"""step2_doors.py: two doorways (a CLI and a tiny HTTP endpoint), one conversation.

New turns always hang off the newest row, one turn at a time per conversation,
and a client-minted request id makes a resend return the first answer.
Stdlib only, macOS/Linux (fcntl). Run:  python3 step2_doors.py race
Or two terminals:  python3 step2_doors.py serve   and   python3 step2_doors.py send hi
"""
import fcntl, json, sys, threading, time, urllib.request, uuid
from contextlib import contextmanager
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

DATA = Path("doors-data")
LOCKED = True                       # the race below runs once without it


def call_model(system, messages):
    """STUB: your one model call goes here. The fake is slow on purpose,
    so two doorways arriving together really do overlap."""
    time.sleep(0.3)
    return f"(fake) I saw {len(messages)} message(s)"


def load(conv):
    p = DATA / f"{conv}.jsonl"
    return [json.loads(l) for l in p.read_text().splitlines() if l] if p.exists() else []


def append(conv, row):
    with (DATA / f"{conv}.jsonl").open("a") as f:
        f.write(json.dumps(row) + "\n")


@contextmanager
def conversation_lock(conv):
    """One turn at a time per conversation, across threads AND processes."""
    if not LOCKED:
        yield
        return
    with (DATA / f"{conv}.lock").open("w") as f:
        fcntl.flock(f, fcntl.LOCK_EX)           # blocks until the turn ahead is saved
        try:
            yield
        finally:
            fcntl.flock(f, fcntl.LOCK_UN)


def send(conv, text, request_id, door):
    """Every doorway calls this. The client never chooses the parent."""
    DATA.mkdir(exist_ok=True)
    with conversation_lock(conv):
        rows = load(conv)
        for r in rows:                  # a resend: answer from the record, run nothing
            if r.get("request_id") == request_id:
                reply = next((x for x in rows if x["parent"] == r["id"]   # its answer, not
                              and x["role"] == "assistant"), None)        # a later question
                return {"state": "already_accepted", "reply": reply and reply["content"]}
        parent = rows[-1]["id"] if rows else None          # the newest row, from any door
        user = {"id": uuid.uuid4().hex[:8], "parent": parent, "role": "user",
                "content": text, "door": door, "request_id": request_id}
        append(conv, user)
        replay = [{"role": r["role"], "content": r["content"]} for r in rows + [user]]
        reply = call_model("You are Pip.", replay)
        append(conv, {"id": uuid.uuid4().hex[:8], "parent": user["id"], "role": "assistant",
                      "content": reply, "replayed": len(replay)})
        return {"state": "done", "reply": reply}


class Door(BaseHTTPRequestHandler):
    def do_POST(self):
        body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
        data = json.dumps(send(body["conversation_id"], body["text"],
                               body["request_id"], "http")).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(data)

    def log_message(self, *args):
        pass


def post(port, conv, text, request_id):
    body = json.dumps({"conversation_id": conv, "text": text, "request_id": request_id})
    req = urllib.request.Request(f"http://127.0.0.1:{port}/chat", data=body.encode())
    return json.loads(urllib.request.urlopen(req).read())


def race(locked):
    global LOCKED
    LOCKED, conv = locked, f"race-{locked}"
    (DATA / f"{conv}.jsonl").unlink(missing_ok=True)
    server = ThreadingHTTPServer(("127.0.0.1", 0), Door)
    threading.Thread(target=server.serve_forever, daemon=True).start()
    port = server.server_address[1]
    web = threading.Thread(target=post, args=(port, conv, "sent from the browser", "web-1"))
    web.start()                                                 # door 1: HTTP
    time.sleep(0.05)
    send(conv, "sent from the terminal", "cli-1", "cli")        # door 2: CLI, a moment later
    web.join()
    rows = load(conv)
    text = {r["id"]: r["content"] for r in rows}
    print(f"LOCKED={locked}")
    for r in rows:
        print(f"  {r['role']:9} {r['content']!r:30} after: {text.get(r['parent'], '(start)')!r}")
    parents = [r["parent"] for r in rows]
    forks = len(parents) - len(set(parents))
    blind = sum(1 for i, r in enumerate(rows) if r["role"] == "assistant" and r["replayed"] < i)
    print(f"  forks: {forks}   replies that missed an earlier message: {blind}")
    again = post(port, conv, "sent from the browser", "web-1")  # the same request, resent
    print(f"  resend web-1 -> {again['state']}, rows still {len(load(conv))}")
    server.shutdown()


if __name__ == "__main__":
    DATA.mkdir(exist_ok=True)
    cmd = sys.argv[1] if len(sys.argv) > 1 else "race"
    if cmd == "race":
        race(False)
        race(True)
    elif cmd == "serve":   # curl -d '{"conversation_id":"default","text":"hi","request_id":"r1"}' 127.0.0.1:8765
        ThreadingHTTPServer(("127.0.0.1", 8765), Door).serve_forever()
    elif cmd == "send":
        print(send("default", " ".join(sys.argv[2:]), "cli-" + uuid.uuid4().hex[:8], "cli")["reply"])

$ python3 step2_doors.py race
LOCKED=False
  user      'sent from the browser'        after: '(start)'
  user      'sent from the terminal'       after: 'sent from the browser'
  assistant '(fake) I saw 1 message(s)'    after: 'sent from the browser'
  assistant '(fake) I saw 2 message(s)'    after: 'sent from the terminal'
  forks: 1   replies that missed an earlier message: 2
  resend web-1 -> already_accepted, rows still 4
LOCKED=True
  user      'sent from the browser'        after: '(start)'
  assistant '(fake) I saw 1 message(s)'    after: 'sent from the browser'
  user      'sent from the terminal'       after: '(fake) I saw 1 message(s)'
  assistant '(fake) I saw 3 message(s)'    after: 'sent from the terminal'
  forks: 0   replies that missed an earlier message: 0
  resend web-1 -> already_accepted, rows still 4