Skip to content

feat(coderd/x/chatd): deliver steer messages before each model call - #30074

Merged
ethanndickson merged 2 commits into
ethanndickson/chat-steer-lanefrom
ethanndickson/chat-steer-next-step
Nov 9, 2026
Merged

ethanndickson merged 2 commits into
ethanndickson/chat-steer-lanefrom
ethanndickson/chat-steer-next-step

Conversation

@ethanndickson

@ethanndickson ethanndickson commented Sep 29, 2026 •

Copy link
Copy Markdown
Member

This is where the steer lane gets delivered mid-turn. Before each assistant model call, the generation task now runs DeliverSteerMessages. If there are steer messages queued, they go into history and the task returns without calling the model, and the history change starts a new generation task that sends them to the model. It never cancels anything, it just waits for the in-flight call and that step's tool calls to finish. Queue messages still wait for turn end, and compaction calls don't deliver steer messages, as they don't answer the user.

A delivered steer message is a new prompt, so tracing treats it like any other newer prompt: a new chat_turn span starts at it, and the span before it ends as abandoned.

chatd.SendMessage now accepts steer, but the HTTP handler and message_agent still only pass queue or interrupt, so the API doesn't change in this PR. #31174 makes steer the API default. Outside of tests, nothing creates steer messages until #31155 stores interrupt sends in the steer lane, so this PR doesn't change behaviour for users on its own.

I've split the earlier version of this PR up, so some of the review comments are now addressed elsewhere in the stack. #31153 moves queue delivery into one helper, #31154 adds the two lanes, #31155 stores interrupt sends in the steer lane, and #31156 makes "Send now" steer, which also fixes two presses being delivered in reverse order.

This supersedes #29784.

Since the first review, a steer message delivered before a model call also records queue_wait, like the other delivery points.

Part of CODAGT-1140

@linear-code

linear-code Bot commented Sep 29, 2026

Copy link
Copy Markdown

CODAGT-1140

@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from 9d96495 to 44c9c96 Compare September 29, 2026 05:27
@ethanndickson

Copy link
Copy Markdown
Member Author

@codex review

@chatgpt-codex-connector

chatgpt-codex-connector Bot commented Sep 29, 2026 •

Copy link
Copy Markdown

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-11-04T10:36:02.817048Z 86b4891 Manual request
ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 44c9c96240

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread coderd/x/chatd/chatstate/transitions.go Resolved
@ethanndickson

Copy link
Copy Markdown
Member Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. 👍

Reviewed commit: aff946c049

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

@ethanndickson
ethanndickson marked this pull request as ready for review September 29, 2026 06:41

@mafredri mafredri left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Went through this with CODAGT-1191 and #29215 (queued-message editing) in mind. Delivering at the step boundary as a transition is the hook 1191 needs, and steer on message_agent later fits its parent-to-child story. One bug and one question, otherwise no concerns from the 1191 side.

Bug: promote sends the wrong message when a steer row exists. PromoteQueuedMessage from R1 or I1 moves the target to the head and sets interrupting. FinishInterruption then calls nextPromotedRows, which sends only the steer rows, so the target stays queued. Repro with a quick chatstate test: queue Q1 Q2 S1 in I1, promote Q2, then FinishInterruption. S1 goes into history and Q2 stays at the head. This is reachable today because an interrupt message is stored as a steer row. The matrix has no Promote case with a steer row.

I read steer rows as bypassing the queue: they aren't queued messages and can't be edited. Is that your model too? If so, could promote from R1 or I1 turn the target into a steer row? Then FinishInterruption only ever sends steer rows, and "send now" means what it says.

Question: should steer rows appear in the queue endpoints? List, promote and delete return them as ordinary queued messages today. If they bypass the queue, I think those endpoints should skip or reject them. With that framing, should they count toward the queue cap? I saw aff946c enforces it for E1 steer sends after Codex's comment. #29215 adds editing, and there steer rows would need to be rejected and left out of the pause computation. Whichever of our PRs lands second picks that up.

Didn't run the suite; read the non-test diff and the matrix cases.

🤖 This review was automatically generated with Coder Agents.

@ethanndickson

Copy link
Copy Markdown
Member Author

@mafredri bug is fixed, was already fixed but I forgot to push, sorry! 😮‍💨

I think steer messages still belong in the queue, there's no guarantee the next opportunity to send the message is soon, i.e. one long tool call in the foreground. Pretty much every other harness shows messages sent to steer as 'queued' to send, in some way.

should they count toward the queue cap?

I think they should yeah

In all honesty I don't fully understand the need to edit a queued message, I would always just rescind it (so it doesn't automatically send when I want to change it), and then just resend it. I'm not totally sold that editing a message with this whole pause computation thing is particularly valuable UX.
In any case, I probably would not allow editing of queued steer messages. I don't think editing a different non-steer message in the queue should pause the sending of a steer message.

@ethanndickson

Copy link
Copy Markdown
Member Author

@codex review

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 5ebf0c6ee1

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread coderd/x/chatd/chatd.go Resolved
Comment thread coderd/x/chatd/chatstate/transitions.go Resolved
Comment thread coderd/x/chatd/chatstate/transitions.go Resolved
Comment thread coderd/x/chatd/chatstate/transitions.go Resolved
Comment thread coderd/x/chatd/generation.go Resolved
Comment thread coderd/x/chatd/ARCHITECTURE.md Resolved
Comment thread coderd/database/queries/chats.sql Resolved
ThomasK33 added a commit that referenced this pull request Oct 2, 2026
… guard (#30096)

Adds the backend-only seam that lets a later `Publish` operation admit
an automation message inside chatd's existing create-chat and
send-message transactions, and the guard that drops stale automation
input when the queue promotes it. Only Go test callbacks use the seam in
this PR, so ordinary chat behavior does not change.

Closes CODAGT-1208
Part of CODAGT-1135

> Stack: PR 2, on top of #30085 (schema, RBAC resource, and audit
entries). No migration changes; this PR adds and extends sqlc queries
only.

ARCHITECTURE.md prose was drafted by an agent at the user's request; the
user will review it.

## Changes

- **Admission seam.** `chatstate.AdmitFunc` is a nil-default `AdmitInTx`
field on `chatd.CreateOptions`, `chatd.SendMessageOptions`,
`chatstate.CreateChatInput`, and `chatstate.SendMessageInput`.
`CreateChat` runs it after inserting the chat and before the initial
history, and requires exactly one initial user message. `SendMessage`
runs it on the locked chat before any write. The callback returns an
`AutomationProvenance` (automation ID, input ID, queue generation),
which is validated and stamped on the message. A callback error rolls
back the whole transaction, so no chat, message, or queue row survives.
`Server.CreateChat` and `Server.SendMessage` keep their signatures.
- **Provenance.** `chatstate.Message.Automation` is written to queued
rows (`automation_id`, `input_id`, `queue_generation`) and history rows
(`automation_id`, `input_id`). `InsertChatMessages` and
`InsertChatQueuedMessageWithCreator` gain the matching parameters, and
`messageFromQueuedRow` copies them on promotion.
- **Promotion guard.** `chatstate.LockAutomations` is the only way to
lock automation rows: it locks them `FOR UPDATE` in ascending ID order,
running as chatd. The chatd subject gains read on `chat_automation`. A
queued automation row passes only if its automation exists, is enabled,
and has the row's `queue_generation`. Two helpers apply the check:
- `nextPromotableQueueHead` serves `sendMessageE1`, `FinishTurn`, and
`FinishInterruption`. A head without an automation costs no extra query.
Otherwise it locks every automation in the queue up front, deletes
failing heads until one passes, and leaves rows behind that head alone.
If the queue empties, `FinishTurn` and `FinishInterruption` land in
`waiting`, as from `R0` and `I0`.
- `guardQueuedRows` serves explicit `PromoteQueuedMessage`. A failing
row is deleted and the transition returns `Rejected` without an error,
so the delete commits. `Server.PromoteQueued` then returns
`ErrQueuedMessageNotFound` (HTTP 404) without reordering, substituting a
message, or changing status.
- The steer paths (`DeliverSteerMessages` and the steer batches from
#30073/#30074) add one `guardQueuedRows` call each, whichever PR lands
second.
- **Deadlocks.** `database.IsDeadlockError` is new. `ChatMachine.Update`
reruns the transaction, at most 3 attempts with a fresh publish buffer
each, only when an attempt that took automation locks hit a deadlock
abort. Attempts without automation locks, and nested Updates, never
retry. The `SendMessage` and `PromoteQueued` closures reset their
results so a rerun is safe.
- **Transition matrix.** Adds the outputs the guard can produce, such as
`R1 -> FinishTurn -> W` and `E1 -> SendMessage -> R0`.
- **`ARCHITECTURE.md`.** Describes the admission seam, provenance, the
queue promotion guard, the lock order, and the deadlock retry, and adds
the guard's outcomes to the state diagram.

## Validation

- Go tests on real PostgreSQL cover the ticket's checks:
  - A callback error leaves no chat, message, or queue row.
- A guard rejection deletes only the rejected heads, on every promotion
path and for each failure reason (missing, disabled, disabled with the
same generation, generation mismatch).
- Explicit promotion of a failing row returns not found, and the delete
is committed.
  - Provenance round-trips through queue and history.
  - `LockAutomations` works through dbauthz.
- `Update` retries only when an attempt that took automation locks hits
a deadlock.
- A concurrency test of acceptance, promotion, and disable across mixed
automation IDs sees zero deadlock aborts.
- Mutation checks confirmed that the guard, retry, and permission tests
fail when their behavior is removed.
- Remote dogfood UAT passed on a real dev instance: sending, queueing,
head and explicit promotion, interrupting, and deleting queued messages
all behaved as before.

---
_Generated with [`xum`](https://github.com/coder/xum) • Model:
`anthropic:claude-opus-5-5` • Thinking: `high`_
@ethanndickson
ethanndickson marked this pull request as draft October 7, 2026 12:05
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from 5ebf0c6 to c4a4c4e Compare October 20, 2026 03:00
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from c4a4c4e to c3f1ce0 Compare October 20, 2026 05:43
@ethanndickson ethanndickson changed the title feat(coderd/x/chatd): deliver steer messages at the next step boundary feat(coderd): deliver steer messages at the next step boundary Oct 20, 2026
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from c3f1ce0 to 2df5167 Compare October 20, 2026 11:59
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from 2e76b86 to 084b81f Compare October 22, 2026 03:54
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from ac5501f to eb65390 Compare October 26, 2026 04:19
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch 2 times, most recently from 4736f3b to c05a12b Compare October 30, 2026 02:18
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from c05a12b to 486ead5 Compare November 2, 2026 06:50
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from 486ead5 to 3cab3d7 Compare November 3, 2026 05:56
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from 3cab3d7 to 86b4891 Compare November 4, 2026 08:55
@ethanndickson

Copy link
Copy Markdown
Member Author

Coming back to this one since the stack has changed a lot. The bug is gone: Send now moves the target to the end of the steer lane (a37d94574d in #31156), which is the option you suggested, so the interruption end delivers it. steer messages are their own lane now (#31154). The queue endpoints list them first, in delivery order, and you can remove them. A steer send to a busy chat counts toward the queue cap.

🤖

@ethanndickson

Copy link
Copy Markdown
Member Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. Swish!

Reviewed commit: 86b489178f

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Before each assistant model call, the generation task applies
DeliverSteerMessages. If steer messages are queued, it moves them into
history and returns without the call. The history change starts a new
generation task, which sends them to the model. Queue messages wait
until the turn ends. Compaction calls do not deliver steer messages.

chatd.SendMessage accepts the steer busy behavior.
@ethanndickson
ethanndickson force-pushed the ethanndickson/chat-steer-next-step branch from 9a10fde to baf0487 Compare November 6, 2026 06:03
@ethanndickson
ethanndickson merged commit ace278e into main Nov 9, 2026
37 of 62 checks passed
@ethanndickson
ethanndickson deleted the ethanndickson/chat-steer-next-step branch November 9, 2026 04:55
ethanndickson added a commit that referenced this pull request Nov 9, 2026
As suggested on #30074, steer messages are now their own lane, rather
than queue rows that jump ahead with a lower position. chatstate uses a
queued message's `busy_behavior` as its lane, and the steer lane always
goes first. `GetChatQueuedMessages` lists the steer lane first, so the
queue is shown in the order it'll actually be delivered.

At turn end, when an interruption finishes, and on a send to an errored
chat, the whole steer lane goes in. If there aren't any steer messages,
the queue head goes in like it does today. So with a queue of `Q1 S1 Q2
S2`, turn end delivers `S1 S2`, and `Q1` waits for the next turn end.

chatstate accepts `steer` here, but nothing sends it yet, so users won't
see a change. Until later in the stack, a few things still ignore the
steer lane:

- An interrupt send goes to the head of the queue lane, so it waits
behind any steer messages. #31155 moves it to the end of the steer lane.
- "Send now" on a running or interrupting chat only moves the message to
the head of its own lane, so when the interruption finishes, the steer
lane goes in instead of it.
- "Send now" on an errored chat, or one waiting on tool results, puts
the message into history straight away, ahead of any queued steer
messages.

#31156 fixes both "Send now" cases by making it steer. None of these can
happen yet, as there are no steer messages to get in the way.

I've added a "Queued message lanes" section to the chatd architecture
doc. Most of the diff is new cases in the transition matrix tests.

Since the first review, lane rule 3 in the architecture doc also says
that delivery stops at a message under edit, and which model and
reasoning effort a batch of delivered messages uses.

Part of CODAGT-1140
ethanndickson added a commit that referenced this pull request Nov 9, 2026
Whilst a steer message is under edit, every steer message now waits, not
just the one under edit and the ones behind it.

Say Next step holds A, B and C, and you edit B. Before this, A went to
the agent at the next model call whilst B and C waited. Now nothing goes
out until the edit ends, then A, B and C go in together. If the turn
ends whilst a steer message is under edit, the chat pauses, the same as
it already does for a queue message. `GetChatQueuedMessageHead` now
returns a steer message under edit first, so the paused check still
finds it when it isn't the first row.

Queue messages are unchanged: editing one holds it and the messages
behind it.

On the site, every other row shows "Waiting" whilst a steer message is
under edit, and Enter on an empty composer won't send the first held
message whilst it's waiting on an edit. The docs are updated to match.

The first version of this PR refused edits on steer messages instead,
following [Mathias's review of
#30074](#30074 (review)).
Mathias has since suggested holding the whole steer lane, so the agent
never starts working on part of what you sent.

Part of CODAGT-1140
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants