mirror of
https://github.com/outbackdingo/optimclaw.git
synced 2026-08-26 15:40:18 +00:00
feat(agent): queue and merge messages during active turns (#1412)
* feat(agent): queue and merge messages during active turns
Replace the hard rejection ("Turn in progress") when messages arrive
during an active turn with a bounded queue (max 10) that auto-drains
after the turn completes.
Queued messages are merged with newlines into a single turn so the LLM
receives full context from rapid consecutive inputs instead of producing
fragmented responses from partial context.
Key changes:
- Thread.pending_messages (VecDeque) with queue_message/drain_pending_messages
- Drain loop in agent_loop.rs merges all queued messages per iteration
- interrupt() and /clear both clear the pending queue
- MAX_PENDING_MESSAGES constant with cap enforced inside queue_message()
- Drain loop continues on soft errors, stops on NeedApproval/Interrupted
- Drain loop logs respond() failures instead of silently swallowing them
Fixes #259 — debounces rapid inbound messages during processing
Fixes #826 — drain loop is bounded by MAX_PENDING_MESSAGES cap
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: address PR review — drain loop busy-loop guard and stale state re-check
- Add Ok(SubmissionResult::Ok) to drain loop break conditions to prevent
a tight busy-loop if process_user_input returns a queued-ack (e.g. from
a corrupted/hydrated session stuck in Processing state)
- Re-check thread.state under the mutable lock in the Processing arm to
guard against the turn completing between the snapshot read and the
queue operation
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: clear attachments on drain-loop queued message processing
Queued messages are text-only (queued as strings during Processing
state). The drain loop was reusing the original IncomingMessage
reference which carried the first message's attachments, causing
augment_with_attachments to incorrectly re-apply them to unrelated
queued text. Clone the message with cleared attachments for drain-loop
turns.
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: address PR review round 2 — stale state fallthrough and thread-not-found guard
- Processing arm: when re-checked state is no longer Processing, fall
through to normal processing instead of dropping user input
- Processing arm: return error when thread not found instead of false
"queued" ack
- Document intermediate drain-loop responses as best-effort for one-shot
channels (HttpChannel)
- Add regression tests for both edge cases
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: address PR review feedback for message queue drain loop
[skip-regression-check] — test modifications present but hook has
SIGPIPE/pipefail false negative when awk exits early on match
- Replace wildcard match in drain loop with explicit `while let
Ok(Response)` guard — stops on Error variant too, preventing
confusing interleaved output after soft errors (review issue #1)
- Reject queueing messages with attachments during Processing state
instead of silently dropping them (review issue #2)
- Document response routing limitation: all drain-loop responses
route via original message identity (review issue #3)
- Document why SubmissionResult::Ok is correct for queued ack and
how it interacts with drain loop break condition (review issue #4)
- Rewrite two dead regression tests to assert actual behavior:
thread-gone returns error, state-changed does not queue (review #5)
- Document MAX_PENDING_MESSAGES=10 as acceptable for personal
assistant use case (review issue #6)
- Fix misleading one-shot channel comment — HttpChannel consumes
sender on first call, subsequent calls are dropped (review issue #8)
- Simplify drain loop intermediate response since while-let guard
guarantees Response variant
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: add missing extension_manager field in webhook EngineContext
The fire_webhook method's EngineContext initializer was missing the
extension_manager field added in staging, causing CI compilation failure.
[skip-regression-check]
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: gate TestRig::session_manager() behind libsql feature flag
The field is #[cfg(feature = "libsql")] so the accessor must match.
All callers are already inside #[cfg(feature = "libsql")] blocks.
[skip-regression-check]
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: re-queue drained messages on drain loop failure
If process_user_input fails after drain_pending_messages() removed
all queued content, that user input was permanently lost. Now the
merged content is re-queued at the front of pending_messages on any
non-Response result so it will be processed on the next successful
turn.
Adds Thread::requeue_drained() helper and unit test.
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix: remove unreachable!() from drain loop, add lock-drop comments
- Extract content binding in `while let` pattern instead of using a
separate match with unreachable!() — satisfies the no-panic-in-
production convention (zmanian review item #1)
- Add comment clarifying session lock is dropped at Processing arm
boundary before fall-through (zmanian review item #5)
- Document bounded cap overshoot on requeue_drained (review item #2)
[skip-regression-check]
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
* fix(security): validate queued messages and touch updated_at on queue ops
- Run safety validation, policy checks, and secret scanning on
messages before queueing during Processing state. Previously,
content with leaked secrets could be stored in pending_messages
and serialized without hitting the inbound scanner.
- Touch updated_at in queue_message(), drain_pending_messages(),
and requeue_drained() so thread timestamps reflect queue activity.
[skip-regression-check] — safety validation requires full Agent;
updated_at is a data-level fix on existing tested methods
Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
---------
Co-authored-by: Claude Opus 4.6 (1M context) <[email protected]>
This commit is contained in:
Illia Polosukhin
co-authored by
Claude Opus 4.6
Claude Opus 4.6
parent
89394ebd29
commit
ccdea40e9d
+86
-2
@@ -1153,8 +1153,92 @@ impl Agent {
|
||||
// Process based on submission type
|
||||
let result = match submission {
|
||||
Submission::UserInput { content } => {
|
||||
self.process_user_input(message, session, thread_id, &content)
|
||||
.await
|
||||
let mut result = self
|
||||
.process_user_input(message, session.clone(), thread_id, &content)
|
||||
.await;
|
||||
|
||||
// Drain any messages queued during processing.
|
||||
// Messages are merged (newline-separated) so the LLM receives
|
||||
// full context from rapid consecutive inputs instead of
|
||||
// processing each as a separate turn with partial context (#259).
|
||||
//
|
||||
// Only `Response` continues the drain — the user got a normal
|
||||
// reply and there may be more queued messages to process.
|
||||
//
|
||||
// Everything else stops the loop:
|
||||
// - `NeedApproval`: thread is blocked on user approval
|
||||
// - `Interrupted`: turn was cancelled
|
||||
// - `Ok`: control-command acknowledgment (including the "queued"
|
||||
// ack returned when a message arrives during Processing)
|
||||
// - `Error`: soft error — draining more messages after an error
|
||||
// would produce confusing interleaved output
|
||||
// - `Err(_)`: hard error
|
||||
while let Ok(SubmissionResult::Response { content: outgoing }) = &result {
|
||||
let merged = {
|
||||
let mut sess = session.lock().await;
|
||||
sess.threads
|
||||
.get_mut(&thread_id)
|
||||
.and_then(|t| t.drain_pending_messages())
|
||||
};
|
||||
let Some(next_content) = merged else {
|
||||
break;
|
||||
};
|
||||
|
||||
tracing::debug!(
|
||||
thread_id = %thread_id,
|
||||
merged_len = next_content.len(),
|
||||
"Drain loop: processing merged queued messages"
|
||||
);
|
||||
|
||||
// Send the completed turn's response before starting the next.
|
||||
//
|
||||
// Known limitations:
|
||||
// - One-shot channels (HttpChannel) consume the response
|
||||
// sender on the first respond() call keyed by msg.id.
|
||||
// Subsequent calls (including the outer handler's final
|
||||
// respond) are silently dropped. For one-shot channels
|
||||
// only this intermediate response is delivered.
|
||||
// - All drain-loop responses are routed via the original
|
||||
// `message`, so channels that key routing on message
|
||||
// identity will attribute every response to the first
|
||||
// message. This is acceptable for the current
|
||||
// single-user-per-thread model.
|
||||
if let Err(e) = self
|
||||
.channels
|
||||
.respond(message, OutgoingResponse::text(outgoing.clone()))
|
||||
.await
|
||||
{
|
||||
tracing::warn!(
|
||||
thread_id = %thread_id,
|
||||
"Failed to send intermediate drain-loop response: {e}"
|
||||
);
|
||||
}
|
||||
|
||||
// Process merged queued messages as a single turn.
|
||||
// Use a message clone with cleared attachments so
|
||||
// augment_with_attachments doesn't re-apply the original
|
||||
// message's attachments to unrelated queued text.
|
||||
let mut queued_msg = message.clone();
|
||||
queued_msg.attachments.clear();
|
||||
result = self
|
||||
.process_user_input(&queued_msg, session.clone(), thread_id, &next_content)
|
||||
.await;
|
||||
|
||||
// If processing failed, re-queue the drained content so it
|
||||
// isn't lost. It will be picked up on the next successful turn.
|
||||
if !matches!(&result, Ok(SubmissionResult::Response { .. })) {
|
||||
let mut sess = session.lock().await;
|
||||
if let Some(thread) = sess.threads.get_mut(&thread_id) {
|
||||
thread.requeue_drained(next_content);
|
||||
tracing::debug!(
|
||||
thread_id = %thread_id,
|
||||
"Re-queued drained content after non-Response result"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
Submission::SystemCommand { command, args } => {
|
||||
tracing::debug!(
|
||||
|
||||
Reference in New Issue
Block a user