One round for a chat, as many as it takes for an agent

Two different jobs were sharing one number. A plain conversation asking a
question is one round of looking things up and then an answer; the rounds after
that were a small model that had decided searching was the answer searching
until the context ran out, at a full request each. MAX_ROUNDS is 1 now. Several
tools can still be called within that round, which is the thing worth telling
the model.

The trade is real and worth naming: a plain chat can no longer search and then
read one of the results, because reading is a second round. That is what an
agent chat is for.

An agent chat is sized by Limits instead, where steps is now a runaway backstop
and not a working budget. It was 40 and it was reached -- a step count low
enough to be the thing that ends a reply is a count that ends it halfway. What
bounds one now is the wall clock and a new completion-token ceiling, with zero
meaning no ceiling, the same convention index_chars already uses.

That ceiling would have been decorative. generation.completion_tokens is only
populated when the endpoint sends a usage block, and llama.cpp, Ollama and
friends never do; the fallback estimate is computed once, in _run's finally,
long after the loop that needs it. So _written takes the larger of reported and
estimated, and there is a test that runs the whole thing against a stream
reporting no usage at all. A limit that works on OpenAI and silently does
nothing everywhere else is the worst kind: one that looks configured.

core.rounds could not stay one fragment. "You get at most N rounds" is not the
same sentence with a different number in it -- a model told it has a budget
rations it and stops early to report progress, which is exactly the behaviour
that strands a long piece of work. So it splits: core.rounds keeps the
one-round case and gates on a new round_budget variable that _agent_values
blanks, and core.keep_working says the other thing to an agent chat.

A queued message during a one-round reply is now never taken mid-reply -- there
is no work under way to steer -- and falls through to _drain, which gives it a
reply of its own. No code change went with that; it falls out of the guard, and
there is a test so that "it happens to work" and "it is meant to work" stop
looking the same.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/test_generation_tools.py

@@ -163,10 +163,59 @@ async def test_a_model_that_only_ever_calls_tools_is_stopped(db, user_id, monkey
     generation = generation_service.Generation(chat_id=chat_id, message_id=message_id)
     await generation_service._run(generation)
 
-    assert len(payloads) == tools_service.MAX_ROUNDS + 1
+    # One round that may call tools, then one that has to answer with words.
+    # Spelled out rather than derived from the constant: a test that reads
+    # MAX_ROUNDS passes whatever MAX_ROUNDS becomes, which is exactly the
+    # assertion nobody wanted.
+    assert tools_service.MAX_ROUNDS == 1
+    assert len(payloads) == 2
     # Recorded rather than silently dropped: an answer that stops here has to
     # be explicable.
     assert generation.tool_events[-1]["status"] == "error"
+    assert "one round" in generation.tool_events[-1]["error"]
+
+
+async def test_a_prompt_queued_during_a_one_round_reply_waits_for_its_own(
+    db, user_id, monkeypatch
+):
+    """`_inject` only takes a prompt in while there is a round left to answer in,
+    and with one round there never is -- so a queued message is not swallowed
+    into a reply that then has no chance to address it. It waits for `_drain`,
+    which always gives it a reply of its own.
+
+    No code change went with this; it falls out of the guard. The test is here
+    because "it happens to work" and "it is meant to work" look the same until
+    somebody changes the guard.
+    """
+    from lembas.db.models import Message
+    from lembas.services import chat as chat_service
+
+    settings_store.update(db, {"enabled": True}, key=settings_store.SEARCH)
+    chat_id, message_id = _chat_with_tools(db, user_id)
+    chat = db.get(Chat, chat_id)
+    queued = chat_service.create_message(db, chat, "user", "actually, do it the other way",
+                                         queued=True)
+    queued_id = queued.id
+
+    monkeypatch.setattr("lembas.services.search.run", _empty_search)
+    monkeypatch.setattr(
+        generation_service,
+        "stream_chat",
+        _stub_stream(
+            [[_tool_call_chunk("web_search", '{"query": "x"}')], [_text_chunk("Done.")]],
+            [],
+        ),
+    )
+    monkeypatch.setattr("lembas.services.chat.generate_title", _never_called_title)
+
+    generation = generation_service.Generation(chat_id=chat_id, message_id=message_id)
+    await generation_service._run(generation)
+
+    # The row, not the payload: it was handed to a fresh reply by `_drain`,
+    # which is what clears `queued`.
+    db.expire_all()
+    assert db.get(Message, queued_id).queued is False
+    assert generation.drained is True
 
 
 async def test_tool_activity_is_stored_with_the_message(db, user_id, monkeypatch):