Think: expose immutable per-turn messenger/thread context on beforeTurn ctx (concurrent turns race on _activeMessengerContext) #1894

Summary

beforeTurn(ctx) exposes no immutable, per-turn identity for which messenger thread/session the turn belongs to. The only way to recover it from inside beforeTurn is getMessengerContext(), which reads the mutable _activeMessengerContext field — and that field is set outside the TurnQueue, so it races under concurrent turns on one DO. This makes per-thread turn logic (e.g. scoping the model-visible transcript to the triggering thread) impossible to implement correctly from the public hook. Related to (but distinct from) the closed #1349 — that was the this.session / useAgentChat cache-key layer; this is the beforeTurn/ctx layer.

Mechanics (from @cloudflare/think@0.11.1 + agents@0.17.1)

1. getMessengerContext() returns the mutable field, else the last message's metadata:

   getMessengerContext() {
     if (this._activeMessengerContext) return this._activeMessengerContext;
     return this.messages.at(-1)?.metadata?.messenger;
   }

2. chatWithMessengerContext sets that field before await this.chat(...) and restores it only in finally — i.e. outside the turn queue:

   this._activeMessengerContext = context;
   try { await this.chat(...); } finally { this._activeMessengerContext = previous; }

3. TurnQueue.enqueue runs the turn body only after await previousTurn, and the user-message append happens inside that serialized body.
4. The ctx passed to beforeTurn is { system, messages, tools, model, continuation, body } — the messages are already assembled model messages (no per-message messenger metadata), and there is no thread/session id.

The race

Same DO handles two near-simultaneous events for threads A then B (DOs interleave at await points):

• Event A: _activeMessengerContext = A; await chat(...) (enqueues turn A).
• Event B interleaves during A's awaits: _activeMessengerContext = B (overwrite); enqueues turn B behind A.
• Turn A's body runs; its beforeTurn reads getMessengerContext() → B. Turn A now operates with thread B's context.

Anchoring on this.messages instead (newest tagged user message) is race-free for fresh turns, because appends are serialized by the queue — but continuation turns (_scheduleAutoContinuation → _admitTurn({ continuation: true })) re-enter the queue as separate turns, so a cross-thread message can interleave between a tool-call turn and its continuation and poison the anchor. There is no fully-correct fix available from beforeTurn today.

Ask

Thread an immutable per-turn messenger/thread identity through the turn and surface it on the beforeTurn ctx (e.g. ctx.messenger / ctx.threadId), captured at admission time so it flows with the unit of work through TurnQueue rather than being read from a shared mutable field. (Alternatively/additionally, stamp the resolved thread on every appended message, not just the user trigger.) That would let per-thread turn logic be written correctly without reading _activeMessengerContext or inferring position in a shared history.