bce9fd266a
* feat(backend): multi-question support for ask_user_question_kandev
Reshape the MCP tool from a single prompt+options pair to a questions[]
array (1-4 entries, single-choice each, custom text fallback). The
clarification HTTP handler gates the response until every question has an
answer, fans out one chat message per question (sharing pending_id, with
question_index/question_total in metadata), and returns a JSON map keyed
by question id back to the agent. The orchestrator resume prompt now
formats multi-line Q1/A1, Q2/A2 summaries when the bundle has more than
one question. Mock-agent gets a clarification-multi scenario and
ask_user_question_test.go covers the new schema + map response. No
back-compat shim — local-first tool, single-PR breaking change.
* feat(web): refresh clarification overlay with multi-question + modern UI
Each per-question chat message gets its own card with a "Question N of M"
progress chip, a ✓ Answered badge once committed, and shadcn-aligned
option buttons with kbd hints. A new useClarificationGroup hook coordinates
the per-question commits (decision A) and posts every answer in a single
batch once the user finishes the bundle; X rejects the whole group. The
single-question case keeps the 1-9 / Esc keyboard shortcuts. Playwright
e2e adds 6 multi-question scenarios (rendering, full happy path, partial
state, mixed option/custom, skip-rejects-bundle, sibling-state) on top of
the existing single-question regression suite.
* fix(web): clarification carousel UX with stepper navigation + race fix
Replaces the vertically stacked card layout with a horizontal stepper:
numbered circle dots up top show step state (active/answered/pending),
the single active question card sits in the middle, and Back / Next /
Submit buttons sit at the bottom. Picking an option auto-advances to the
next step (single-question case auto-submits, no explicit Submit button).
The stepper steps are clickable so users can revise prior answers.
Keyboard shortcuts: 1-9 for option pick, ArrowLeft/Right for navigation,
Esc for skip.
Also fixes a race that surfaced as a 400 BadRequest on the
/api/v1/clarification/:id/respond endpoint when the user clicked an
option before all N messages of a multi-question bundle had streamed in:
findPendingClarificationGroup now gates on metadata.question_total and
returns an empty array until the full bundle has arrived.
Playwright suite expanded from 6 to 12 multi-question scenarios:
stepper rendering, auto-advance, Back, stepper jump, Submit gating,
happy path, mixed custom-text, revise-via-jump, skip-from-mid-step,
number-key shortcuts, Esc skip, first-step Back disabled.
* fix(clarification): address CodeRabbit/Greptile/Claude review comments
Backend:
- Single source of truth for question validation: rename/export
NormalizeAndValidateQuestions and call it from both the HTTP and the
WebSocket-side MCP handlers, so duplicate question ids and bad option
counts can't slip through either path.
- httpRespond now validates that every answer references a real question
id from the bundle and that no id is answered twice (regression tests
added).
- questionsFromMessages reorders by metadata.question_index so the
reconstructed bundle preserves the original question order.
- adapters.CreateClarificationRequestMessages rolls back already-created
messages when a later write in the bundle fails.
- extractQuestionAnswers always returns a JSON map (even on rejection,
with an envelope { rejected, reject_reason }) and simplifyAnswer
preserves both selected_option and custom_text when both are present.
- MCP tool description: rewrite the response example to match the actual
output shape; add minItems / maxItems to the questions and options
arrays in the JSON Schema.
- Test helper: drop the local contains() shim, use strings.Contains.
Frontend:
- useMemo([props]) was a no-op (props is always a fresh ref); split into
[message, messages] so it actually memoizes.
- Drop the dead "expired" SubmitState branch — the backend never returns
410 from this endpoint.
- Remove the asymmetric option-list dimming: the agent now receives both
selected_option and custom_text together, so a half-grey state was
misleading.
- New tests: pending-clarification.test.ts covers
findPendingClarificationGroup including the question_total gate, and
use-clarification-group.test.ts covers the hook's record/submit/skip
flows and the override-merge path used by the single-question case.
* fix(web): treat clarification 409 as success so duplicate submit doesn't stick the overlay
* fix(clarification): unblock agent on persistence failure + nil-guard rejected branch
- Add Store.CancelRequest(pendingID) and call it from both the WebSocket
MCP handler and the HTTP create-request handler when message creation
fails. Without it, the agent's WaitForResponse parked for the full
2-hour MCP timeout while no clarification cards ever reached the user.
Both handlers now return an explicit error response on failure.
- applyAnswersToMessages now guards h.repo == nil in the rejected branch
(parity with sibling expectedQuestionIDs).
- extractQuestionAnswers stubs for unanswered questions in a rejected
bundle now carry { answered: false, rejected: true } so agents reading
per-question payloads see the rejection without inspecting the
envelope.
- Hook test: added 409-as-ok regression coverage for both submit and
skip paths so the previous fix can't drift.
- Store test: covers CancelRequest unblocking a parked WaitForResponse.
* fix: drop unused e2e helper + use channel sync in CancelRequest test
* refactor(web): drop dead 'message' prop from clarification overlay
Both call sites pass 'messages' (the bundle group), so the legacy
single-message prop was unused. Tightening the prop type also lets the
useMemo depend on a single value.
* fix(web): ignore modifier-keyed events in clarification carousel shortcuts
Bare 1..9 / ArrowLeft / ArrowRight / Esc still drive the carousel, but
Cmd/Ctrl+1..9 (browser tab switch) and Alt+ArrowLeft (browser back) now
pass through as the user expects.
336 lines
11 KiB
TypeScript
336 lines
11 KiB
TypeScript
import { useMemo } from "react";
|
|
import type { Message, ClarificationRequestMetadata, MessageType } from "@/lib/types/http";
|
|
import type { ToolCallMetadata } from "@/components/task/chat/types";
|
|
import {
|
|
findPendingClarification,
|
|
findPendingClarificationGroup,
|
|
} from "@/lib/utils/pending-clarification";
|
|
|
|
const ACTIVITY_MESSAGE_TYPES: Set<MessageType> = new Set([
|
|
"thinking",
|
|
"tool_call",
|
|
"tool_edit",
|
|
"tool_read",
|
|
"tool_execute",
|
|
"tool_search",
|
|
]);
|
|
|
|
const VISIBLE_MESSAGE_TYPES: Set<string> = new Set([
|
|
"message",
|
|
"content",
|
|
"tool_call",
|
|
"tool_read",
|
|
"tool_edit",
|
|
"tool_execute",
|
|
"tool_search",
|
|
"progress",
|
|
"status",
|
|
"error",
|
|
"thinking",
|
|
"todo",
|
|
"script_execution",
|
|
"agent_plan",
|
|
]);
|
|
|
|
function isVisibleMessageType(type: MessageType | undefined): boolean {
|
|
return !type || VISIBLE_MESSAGE_TYPES.has(type);
|
|
}
|
|
|
|
function isPermissionVisible(message: Message, toolCallIds: Set<string>): boolean {
|
|
const metadata = message.metadata as { tool_call_id?: string; status?: string } | undefined;
|
|
const toolCallId = metadata?.tool_call_id;
|
|
if (toolCallId && toolCallIds.has(toolCallId)) return false;
|
|
const status = metadata?.status;
|
|
if (status === "approved" || status === "denied" || status === "cancelled") return false;
|
|
return true;
|
|
}
|
|
|
|
export type TurnGroup = {
|
|
type: "turn_group";
|
|
id: string;
|
|
turnId: string | null;
|
|
messages: Message[];
|
|
};
|
|
|
|
export type PrepareProgressItem = {
|
|
type: "prepare_progress";
|
|
id: string;
|
|
sessionId: string;
|
|
};
|
|
|
|
export type RenderItem = { type: "message"; message: Message } | TurnGroup | PrepareProgressItem;
|
|
|
|
function buildToolCallIds(messages: Message[]): Set<string> {
|
|
const set = new Set<string>();
|
|
for (const message of messages) {
|
|
if (message.type === "tool_call") {
|
|
const toolCallId = (message.metadata as { tool_call_id?: string } | undefined)?.tool_call_id;
|
|
if (toolCallId) set.add(toolCallId);
|
|
}
|
|
}
|
|
return set;
|
|
}
|
|
|
|
function buildPermissionsByToolCallId(messages: Message[]): Map<string, Message> {
|
|
const map = new Map<string, Message>();
|
|
for (const message of messages) {
|
|
if (message.type === "permission_request") {
|
|
const toolCallId = (message.metadata as { tool_call_id?: string } | undefined)?.tool_call_id;
|
|
if (toolCallId) map.set(toolCallId, message);
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
function buildChildrenByParentToolCallId(messages: Message[]): Map<string, Message[]> {
|
|
const map = new Map<string, Message[]>();
|
|
for (const message of messages) {
|
|
const metadata = message.metadata as ToolCallMetadata | undefined;
|
|
const parentId = metadata?.parent_tool_call_id;
|
|
if (parentId) {
|
|
const children = map.get(parentId) || [];
|
|
children.push(message);
|
|
map.set(parentId, children);
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
function buildSubagentChildIds(childrenByParentToolCallId: Map<string, Message[]>): Set<string> {
|
|
const set = new Set<string>();
|
|
for (const children of childrenByParentToolCallId.values()) {
|
|
for (const child of children) set.add(child.id);
|
|
}
|
|
return set;
|
|
}
|
|
|
|
function isRecoveryMessage(message: Message): boolean {
|
|
const meta = message.metadata as Record<string, unknown> | undefined;
|
|
return meta?.recovery_actions === true;
|
|
}
|
|
|
|
/** Hide recovery messages that have been superseded by later conversation activity
|
|
* (user/agent messages prove the session recovered) or by a newer recovery message. */
|
|
function deduplicateRecoveryMessages(messages: Message[]): Message[] {
|
|
let lastRecoveryIdx = -1;
|
|
for (let i = messages.length - 1; i >= 0; i--) {
|
|
if (isRecoveryMessage(messages[i])) {
|
|
lastRecoveryIdx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (lastRecoveryIdx === -1) return messages;
|
|
|
|
const hasLaterActivity = messages
|
|
.slice(lastRecoveryIdx + 1)
|
|
.some((m) => m.type === "message" || m.type === "content");
|
|
|
|
return messages.filter((msg, i) => {
|
|
if (!isRecoveryMessage(msg)) return true;
|
|
if (hasLaterActivity) return false;
|
|
return i === lastRecoveryIdx;
|
|
});
|
|
}
|
|
|
|
export function isAgentBootResumeMessage(message: Message): boolean {
|
|
if (message.type !== "script_execution") return false;
|
|
const meta = message.metadata as { script_type?: string; is_resuming?: boolean } | undefined;
|
|
return meta?.script_type === "agent_boot" && meta?.is_resuming === true;
|
|
}
|
|
|
|
/** A resumed session may produce many "Resumed agent …" boot messages over its
|
|
* lifetime (every backend restart emits one). They all convey the same info;
|
|
* keep only the most recent and drop the rest — unconditionally, even if user
|
|
* messages occurred between them (unlike `deduplicateRecoveryMessages`). The
|
|
* underlying DB rows are untouched; this only affects the rendered chat. */
|
|
export function deduplicateAgentBootResumes(messages: Message[]): Message[] {
|
|
let lastResumeIdx = -1;
|
|
for (let i = messages.length - 1; i >= 0; i--) {
|
|
if (isAgentBootResumeMessage(messages[i])) {
|
|
lastResumeIdx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (lastResumeIdx === -1) return messages;
|
|
return messages.filter((msg, i) => !isAgentBootResumeMessage(msg) || i === lastResumeIdx);
|
|
}
|
|
|
|
function filterVisibleMessages(
|
|
messages: Message[],
|
|
toolCallIds: Set<string>,
|
|
subagentChildIds: Set<string>,
|
|
): Message[] {
|
|
const filtered = messages.filter((message) => {
|
|
if (subagentChildIds.has(message.id)) return false;
|
|
if (message.type === "clarification_request") {
|
|
const metadata = message.metadata as ClarificationRequestMetadata | undefined;
|
|
return !(!metadata?.status || metadata.status === "pending");
|
|
}
|
|
if (
|
|
message.type === "status" &&
|
|
(message.content === "New session started" || message.content === "Session resumed")
|
|
)
|
|
return false;
|
|
if (isVisibleMessageType(message.type)) return true;
|
|
if (message.type === "permission_request") return isPermissionVisible(message, toolCallIds);
|
|
return false;
|
|
});
|
|
|
|
return deduplicateAgentBootResumes(deduplicateRecoveryMessages(filtered));
|
|
}
|
|
|
|
function groupActivityMessages(allMessages: Message[]): RenderItem[] {
|
|
const items: RenderItem[] = [];
|
|
let currentGroup: Message[] = [];
|
|
let currentTurnId: string | null = null;
|
|
|
|
const flushGroup = () => {
|
|
if (currentGroup.length >= 2) {
|
|
items.push({
|
|
type: "turn_group",
|
|
id: `turn-group-${currentGroup[0].id}`,
|
|
turnId: currentGroup[0].turn_id ?? null,
|
|
messages: currentGroup,
|
|
});
|
|
} else if (currentGroup.length === 1) {
|
|
items.push({ type: "message", message: currentGroup[0] });
|
|
}
|
|
currentGroup = [];
|
|
currentTurnId = null;
|
|
};
|
|
|
|
for (const message of allMessages) {
|
|
const isActivity = message.type && ACTIVITY_MESSAGE_TYPES.has(message.type);
|
|
const messageTurnId = message.turn_id ?? null;
|
|
if (isActivity && messageTurnId) {
|
|
if (currentGroup.length > 0 && currentTurnId === messageTurnId) {
|
|
currentGroup.push(message);
|
|
} else {
|
|
flushGroup();
|
|
currentGroup = [message];
|
|
currentTurnId = messageTurnId;
|
|
}
|
|
} else {
|
|
flushGroup();
|
|
items.push({ type: "message", message });
|
|
}
|
|
}
|
|
flushGroup();
|
|
return items;
|
|
}
|
|
|
|
function injectPrepareProgressItem(
|
|
items: RenderItem[],
|
|
resolvedSessionId: string | null,
|
|
): RenderItem[] {
|
|
if (!resolvedSessionId) return items;
|
|
const prepareItem: PrepareProgressItem = {
|
|
type: "prepare_progress",
|
|
id: `prepare-progress-${resolvedSessionId}`,
|
|
sessionId: resolvedSessionId,
|
|
};
|
|
if (items.length === 0) return [prepareItem];
|
|
return [items[0], prepareItem, ...items.slice(1)];
|
|
}
|
|
|
|
export function useProcessedMessages(
|
|
messages: Message[],
|
|
taskId: string | null,
|
|
resolvedSessionId: string | null,
|
|
taskDescription: string | null,
|
|
) {
|
|
const toolCallIds = useMemo(() => buildToolCallIds(messages), [messages]);
|
|
const permissionsByToolCallId = useMemo(() => buildPermissionsByToolCallId(messages), [messages]);
|
|
const childrenByParentToolCallId = useMemo(
|
|
() => buildChildrenByParentToolCallId(messages),
|
|
[messages],
|
|
);
|
|
const subagentChildIds = useMemo(
|
|
() => buildSubagentChildIds(childrenByParentToolCallId),
|
|
[childrenByParentToolCallId],
|
|
);
|
|
const pendingClarification = useMemo(() => findPendingClarification(messages), [messages]);
|
|
const pendingClarificationGroup = useMemo(
|
|
() => findPendingClarificationGroup(messages),
|
|
[messages],
|
|
);
|
|
|
|
const visibleMessages = useMemo(
|
|
() => filterVisibleMessages(messages, toolCallIds, subagentChildIds),
|
|
[messages, toolCallIds, subagentChildIds],
|
|
);
|
|
|
|
const taskDescriptionMessage: Message | null = useMemo(() => {
|
|
return taskDescription && visibleMessages.length === 0
|
|
? {
|
|
id: "task-description",
|
|
task_id: taskId ?? "",
|
|
session_id: resolvedSessionId ?? "",
|
|
author_type: "user",
|
|
content: taskDescription,
|
|
type: "message",
|
|
created_at: "",
|
|
}
|
|
: null;
|
|
}, [taskDescription, visibleMessages.length, taskId, resolvedSessionId]);
|
|
|
|
const allMessages = useMemo(() => {
|
|
return taskDescriptionMessage ? [taskDescriptionMessage, ...visibleMessages] : visibleMessages;
|
|
}, [taskDescriptionMessage, visibleMessages]);
|
|
|
|
const todoItems = useMemo(() => {
|
|
const latestTodos = [...visibleMessages]
|
|
.reverse()
|
|
.find(
|
|
(message) => message.type === "todo" || (message.metadata as { todos?: unknown })?.todos,
|
|
);
|
|
return (
|
|
(
|
|
latestTodos?.metadata as
|
|
| { todos?: Array<{ text: string; done?: boolean } | string> }
|
|
| undefined
|
|
)?.todos
|
|
?.map((item) => (typeof item === "string" ? { text: item, done: false } : item))
|
|
.filter((item) => item.text) ?? []
|
|
);
|
|
}, [visibleMessages]);
|
|
|
|
const agentMessageCount = useMemo(() => {
|
|
return visibleMessages.filter((c) => c.author_type !== "user").length;
|
|
}, [visibleMessages]);
|
|
|
|
// Separate footer action messages (e.g. missing branch guidance with archive/delete
|
|
// buttons) from regular messages so they render after the env prep error status.
|
|
const { regularMessages, footerActionMessages } = useMemo(() => {
|
|
const regular: Message[] = [];
|
|
const footer: Message[] = [];
|
|
for (const msg of allMessages) {
|
|
const meta = msg.metadata as Record<string, unknown> | undefined;
|
|
if (Array.isArray(meta?.actions) && !meta?.recovery_actions) {
|
|
footer.push(msg);
|
|
} else {
|
|
regular.push(msg);
|
|
}
|
|
}
|
|
return { regularMessages: regular, footerActionMessages: footer };
|
|
}, [allMessages]);
|
|
|
|
const groupedItems = useMemo<RenderItem[]>(() => {
|
|
return injectPrepareProgressItem(groupActivityMessages(regularMessages), resolvedSessionId);
|
|
}, [regularMessages, resolvedSessionId]);
|
|
|
|
return {
|
|
visibleMessages,
|
|
allMessages,
|
|
groupedItems,
|
|
footerActionMessages,
|
|
toolCallIds,
|
|
permissionsByToolCallId,
|
|
childrenByParentToolCallId,
|
|
todoItems,
|
|
agentMessageCount,
|
|
pendingClarification,
|
|
pendingClarificationGroup,
|
|
};
|
|
}
|