Who holds the list?

The REPL's loop body starts with messages = []. You type "My name is Ada.", and then "What is my name?". What does the second line get back?

import harness, lab


def repl(lines, *, one_list):
    """The lines typed at a chat REPL. Each line is one whole run of your agent."""
    model = lab.ScriptedModel([lab.forgetful()])
    kept = []                                    # made once, outside the loop
    for typed in lines:
        messages = kept if one_list else []      # ... or made again for every line
        print(f"you> {typed}")
        answer = harness.FinalTextRenderer()
        print("bot> ", end="")
        for event in harness.run_agent(model, harness.SYSTEM, messages, [], typed):
            answer.render(event)
        answer.finish()
    shapes = ", ".join(f"{lab.shape(c.messages)!r}" for c in model.calls)
    print(f"     the {len(model.calls)} requests carried: {shapes}")


TYPED = ["My name is Ada.", "What is my name?"]

print("### the REPL as written: messages=[] on every line")
repl(TYPED, one_list=False)
print()
print("### one line changed: the list is made once, outside the loop")
repl(TYPED, one_list=True)

### the REPL as written: messages=[] on every line
you> My name is Ada.
bot> Noted.
you> What is my name?
bot> I don't know your name.
     the 2 requests carried: 'U', 'U'

### one line changed: the list is made once, outside the loop
you> My name is Ada.
bot> Noted.
you> What is my name?
bot> Your name is Ada.
     the 2 requests carried: 'U', 'U A U'

A user is watching the agent write three files. After the first one they change their mind and type "Actually, put them in src/." What should the second Send do? Pick, and give your reason in one line.

import harness, lab

FILES = ["a.py", "b.py", "c.py"]


def writer(request):
    """Writes whichever of a.py, b.py and c.py the transcript shows no write call
    for. Once all three are there it answers the user's last line."""
    asked = [block["arguments"].get("path")
             for message in request.messages if message["role"] == "assistant"
             for block in message["content"] if block.get("type") == "toolCall"]
    todo = [name for name in FILES if name not in asked]
    if todo:
        return lab.reply(lab.text(f"Writing {todo[0]}."),
                         lab.call("write", {"path": todo[0],
                                            "content": "print('hi')\n"}))
    if "src/" in request.user_text:
        return lab.say("All three are already at the top level. Shall I move "
                       "them into src/?")
    return lab.say("Done: a.py, b.py and c.py.")


ws = lab.Workspace()
model = lab.ScriptedModel([lab.forever(writer)])
tools = [harness.make_write_tool(ws)]
messages = []


def run(typed):
    for event in harness.run_agent(model, harness.SYSTEM, messages, tools, typed):
        if event["type"] == "tool_execution_end":
            call = event["call"]
            print(f"bot>   {call['name']}({call['arguments']['path']})")
            if call["arguments"]["path"] == "a.py":
                print("you>   Actually, put them in src/."
                      "        <- typed here, and held")
        elif event["type"] == "turn_end":
            answer = event["message"]
            if not harness.tool_calls(answer):
                print(f"bot> {harness.text_of(answer)}")


print("you> Write a.py, b.py and c.py.")
run("Write a.py, b.py and c.py.")
print("     [the run is over, so the held line goes in now, as a job of its own]")
print("you> Actually, put them in src/.")
run("Actually, put them in src/.")
print()
print("files on disk:", ", ".join(ws.listdir(".")))
print("model calls:  ", len(model.calls))
print("record:       ", lab.shape(messages))

you> Write a.py, b.py and c.py.
bot>   write(a.py)
you>   Actually, put them in src/.        <- typed here, and held
bot>   write(b.py)
bot>   write(c.py)
bot> Done: a.py, b.py and c.py.
     [the run is over, so the held line goes in now, as a job of its own]
you> Actually, put them in src/.
bot> All three are already at the top level. Shall I move them into src/?

files on disk: a.py, b.py, c.py
model calls:   5
record:        U A[c1] R(c1) A[c2] R(c2) A[c3] R(c3) A U A

Two lines, run against each version in turn: g1 = start("first"), then g2 = start("second"). Neither has been iterated. Which line raises?

busy = False


def guard_inside(name):
    """The check and the flag live in the generator's own body."""
    global busy
    if busy:
        raise RuntimeError("already running")
    busy = True
    try:
        yield f"{name}: event 1"
        yield f"{name}: event 2"
    finally:
        busy = False


def guard_outside(name):
    """The check and the flag live in a plain def; the body is a second function."""
    global busy
    if busy:
        raise RuntimeError("already running")
    busy = True
    return _body(name)


def _body(name):
    global busy
    try:
        yield f"{name}: event 1"
        yield f"{name}: event 2"
    finally:
        busy = False


def double_click(start, label):
    """Press Send twice before anything is drawn, then iterate what came back."""
    global busy
    busy, runs = False, []
    print(label)
    for number, prompt in ((1, "first"), (2, "second")):
        line = f"g{number} = start({prompt!r})"
        try:
            runs.append(start(prompt))
            print(f"  {line:<24} ok")
        except RuntimeError as error:
            print(f"  {line:<24} RuntimeError: {error}")
    print(f"  runs now in flight: {len(runs)}")
    for number, run in enumerate(runs, 1):
        line = f"next(g{number})"
        try:
            print(f"  {line:<24} {next(run)!r}")
        except RuntimeError as error:
            print(f"  {line:<24} RuntimeError: {error}")
    for run in runs:
        run.close()


double_click(guard_inside, "### the guard inside the generator body")
print()
double_click(guard_outside,
             "### the guard in a plain def that returns the generator")

### the guard inside the generator body
  g1 = start('first')      ok
  g2 = start('second')     ok
  runs now in flight: 2
  next(g1)                 'first: event 1'
  next(g2)                 RuntimeError: already running

### the guard in a plain def that returns the generator
  g1 = start('first')      ok
  g2 = start('second')     RuntimeError: already running
  runs now in flight: 1
  next(g1)                 'first: event 1'

UI code calls h.messages.pop() to take back the line the user just typed, and then h.messages.append(...) to show a "Thinking..." placeholder. Three candidates for what messages hands out. Which one should you write?

import lab


class Holder:
    """Three objects, each holding the same three messages in a private list.
    They differ in one line: what the `messages` property hands out."""

    def __init__(self, messages):
        self._messages = list(messages)


class Live(Holder):
    """the list itself"""

    @property
    def messages(self):
        return self._messages


class Copy(Holder):
    """a fresh list each time"""

    @property
    def messages(self):
        return list(self._messages)


class Snapshot(Holder):
    """a tuple"""

    @property
    def messages(self):
        return tuple(self._messages)


START = [lab.user("My name is Ada."), lab.say("Noted."),
         lab.user("What is my name?")]
EDITS = [("pop()", lambda seq: seq.pop()),
         ('append(assistant "Thinking...")',
          lambda seq: seq.append(lab.say("Thinking...")))]


def a_well_meaning_screen(holder):
    """UI code: take back the line the user just sent, then show a placeholder."""
    for what, edit in EDITS:
        try:
            edit(holder.messages)
            told = "no complaint"
        except AttributeError:
            told = "AttributeError"
        print(f"  h.messages.{what:<32} {told:<14} transcript: "
              f"{lab.shape(holder._messages)!r}")


for kind in (Live, Copy, Snapshot):
    print(f"### messages hands out {kind.__doc__ or ''}".rstrip())
    a_well_meaning_screen(kind(START))

### messages hands out the list itself
  h.messages.pop()                            no complaint   transcript: 'U A'
  h.messages.append(assistant "Thinking...")  no complaint   transcript: 'U A A'
### messages hands out a fresh list each time
  h.messages.pop()                            no complaint   transcript: 'U A U'
  h.messages.append(assistant "Thinking...")  no complaint   transcript: 'U A U'
### messages hands out a tuple
  h.messages.pop()                            AttributeError transcript: 'U A U'
  h.messages.append(assistant "Thinking...")  AttributeError transcript: 'U A U'

Tab A sends "My name is Ada." Tab B, a second later and before A's answer has come back, sends "What is my name?" What does each tab see? Pick, and give your reason in one line.

import harness, lab

model = lab.ScriptedModel([lab.forgetful()])
served = harness.Harness(model, harness.SYSTEM, [])      # one harness, on the server


def answer(tab, run):
    for event in run:
        if event["type"] == "turn_end":
            print(f"tab {tab} <- {harness.text_of(event['message'])}")


print("tab A -> My name is Ada.")
first = served.prompt("My name is Ada.")                 # tab A's request handler

print("tab B -> What is my name?")
try:
    second = served.prompt("What is my name?")   # tab B's, while A's run is alive
except RuntimeError as error:
    second = None
    print(f"tab B <- 500 {error}")

answer("A", first)
print("tab B -> What is my name?   (the visitor presses Send again)")
answer("B", served.prompt("What is my name?"))

print()
print(lab.show(served.messages))
print("one transcript:", lab.shape(served.messages),
      "- and tab A never saw the last two lines")

tab A -> My name is Ada.
tab B -> What is my name?
tab B <- 500 already running
tab A <- Noted.
tab B -> What is my name?   (the visitor presses Send again)
tab B <- Your name is Ada.

user -> "My name is Ada."
assistant -> "Noted."
user -> "What is my name?"
assistant -> "Your name is Ada."
one transcript: U A U A - and tab A never saw the last two lines