Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

Keep composer interactive and preserve superseded in-flight turns (#858)

Govinda Vashishthad4bf49ccdbda
diff --git a/.changeset/ask-user-mcp-ui-polish.md b/.changeset/ask-user-mcp-ui-polish.md
new file mode 100644
index 000000000..d283c215a
--- /dev/null
+++ b/.changeset/ask-user-mcp-ui-polish.md
@@ -0,0 +1,5 @@
+---
+'@truefoundry/trueforge-ui': patch
+---
+
+Polish MCP auth and Ask User pause chrome: lettered A/B/C options with Continue, outlined Connect, and screenshot-matching stack above the composer.
diff --git a/.changeset/clear-running-on-failed-supersede.md b/.changeset/clear-running-on-failed-supersede.md
new file mode 100644
index 000000000..e62b8401b
--- /dev/null
+++ b/.changeset/clear-running-on-failed-supersede.md
@@ -0,0 +1,5 @@
+---
+'@truefoundry/trueforge-assistant-ui-runtime': patch
+---
+
+Clear `isRunning` and aborted stream controllers when a superseding send fails prior to starting `runStream`, and ensure `cancel()` clears `isRunning` after draining the in-flight run.
diff --git a/.changeset/composer-pause-stack.md b/.changeset/composer-pause-stack.md
new file mode 100644
index 000000000..e228c68e2
--- /dev/null
+++ b/.changeset/composer-pause-stack.md
@@ -0,0 +1,6 @@
+---
+'@truefoundry/trueforge-ui': patch
+'@truefoundry/trueforge-assistant-ui-runtime': patch
+---
+
+Keep the composer interactive during running and paused turns: Cancel only when empty, Send supersedes the prior client stream without cancelSession (preserving superseded in-flight turns in the transcript), and stacked pause chrome is abandoned after a later user message. Hosts that override ComposerSendButton and still branch only on isRunning should update to use hasContent.
diff --git a/packages/assistant-ui-runtime/src/collectPending.ts b/packages/assistant-ui-runtime/src/collectPending.ts
index eef9475b1..a67a83631 100644
--- a/packages/assistant-ui-runtime/src/collectPending.ts
+++ b/packages/assistant-ui-runtime/src/collectPending.ts
@@ -3,6 +3,7 @@ import type { McpAuthRequiredEvent } from './server/index.js';
import { ROOT_THREAD_ID } from './constants.js';
import { isMcpServerAuthInfoList, isUnknownRecord } from './messageCustomMetadata.js';
+import { findCurrentPausedAssistantMessage } from './requiredActionInputs.js';
import { getToolApprovalThreadId, hasPendingToolApproval } from './toolApproval.js';
import {
getToolResponseThreadId,
@@ -55,97 +56,90 @@ function walkToolCallParts(
export function collectPendingApprovals(messages: readonly ThreadMessage[]): PendingApproval[] {
const pending: PendingApproval[] = [];
-
- for (const message of messages) {
- if (message.role !== 'assistant') {
- continue;
- }
- const rootThreadId = getToolApprovalThreadId(message) ?? ROOT_THREAD_ID;
- walkToolCallParts(
- message.content,
- (part, threadId) => {
- const approval = part.approval;
- if (approval == null || !hasPendingToolApproval(approval)) {
- return;
- }
- pending.push({
- approvalId: approval.id,
- threadId,
- toolName: part.toolName,
- args: { ...part.args },
- argsText: part.argsText,
- });
- },
- rootThreadId,
- );
+ const paused = findCurrentPausedAssistantMessage(messages);
+ if (paused == null) {
+ return pending;
}
+ const rootThreadId = getToolApprovalThreadId(paused) ?? ROOT_THREAD_ID;
+ walkToolCallParts(
+ paused.content,
+ (part, threadId) => {
+ const approval = part.approval;
+ if (approval == null || !hasPendingToolApproval(approval)) {
+ return;
+ }
+ pending.push({
+ approvalId: approval.id,
+ threadId,
+ toolName: part.toolName,
+ args: { ...part.args },
+ argsText: part.argsText,
+ });
+ },
+ rootThreadId,
+ );
+
return pending;
}
export function collectPendingToolResponses(messages: readonly ThreadMessage[]): PendingToolResponse[] {
const pending: PendingToolResponse[] = [];
-
- for (const message of messages) {
- if (message.role !== 'assistant') {
- continue;
- }
- const rootThreadId = getToolResponseThreadId(message) ?? ROOT_THREAD_ID;
- walkToolCallParts(
- message.content,
- (part, threadId) => {
- if (!hasPendingToolResponse(part)) {
- return;
- }
- const payload: AskUserQuestionInterruptPayload | undefined = isUnknownRecord(part.interrupt?.payload)
- ? {
- ...(typeof part.interrupt.payload['question'] === 'string'
- ? { question: part.interrupt.payload['question'] }
- : {}),
- ...(Array.isArray(part.interrupt.payload['options']) &&
- part.interrupt.payload['options'].every(option => typeof option === 'string')
- ? { options: part.interrupt.payload['options'] }
- : {}),
- }
- : undefined;
- pending.push({
- toolCallId: part.toolCallId,
- threadId,
- toolName: part.toolName,
- args: { ...part.args },
- argsText: part.argsText,
- ...(payload?.question != null ? { question: payload.question } : {}),
- ...(payload?.options != null ? { options: payload.options } : {}),
- });
- },
- rootThreadId,
- );
+ const paused = findCurrentPausedAssistantMessage(messages);
+ if (paused == null) {
+ return pending;
}
+ const rootThreadId = getToolResponseThreadId(paused) ?? ROOT_THREAD_ID;
+ walkToolCallParts(
+ paused.content,
+ (part, threadId) => {
+ if (!hasPendingToolResponse(part)) {
+ return;
+ }
+ const payload: AskUserQuestionInterruptPayload | undefined = isUnknownRecord(part.interrupt?.payload)
+ ? {
+ ...(typeof part.interrupt.payload['question'] === 'string'
+ ? { question: part.interrupt.payload['question'] }
+ : {}),
+ ...(Array.isArray(part.interrupt.payload['options']) &&
+ part.interrupt.payload['options'].every(option => typeof option === 'string')
+ ? { options: part.interrupt.payload['options'] }
+ : {}),
+ }
+ : undefined;
+ pending.push({
+ toolCallId: part.toolCallId,
+ threadId,
+ toolName: part.toolName,
+ args: { ...part.args },
+ argsText: part.argsText,
+ ...(payload?.question != null ? { question: payload.question } : {}),
+ ...(payload?.options != null ? { options: payload.options } : {}),
+ });
+ },
+ rootThreadId,
+ );
+
return pending;
}
export function derivePendingMcpAuth(
messages: readonly ThreadMessage[],
): { mcpServers: McpAuthRequiredEvent['mcpServers'] } | null {
- for (const message of messages.toReversed()) {
- if (message.role !== 'assistant') {
- continue;
- }
- if (message.status.type !== 'requires-action') {
- continue;
- }
- const custom = message.metadata.custom;
- if (custom['pendingMcpAuth'] !== true) {
- continue;
- }
- const servers = custom['mcpServers'];
- if (!isMcpServerAuthInfoList(servers)) {
- return { mcpServers: [] };
- }
- return { mcpServers: servers };
+ const paused = findCurrentPausedAssistantMessage(messages);
+ if (paused == null) {
+ return null;
+ }
+ const custom = paused.metadata.custom;
+ if (custom['pendingMcpAuth'] !== true) {
+ return null;
+ }
+ const servers = custom['mcpServers'];
+ if (!isMcpServerAuthInfoList(servers)) {
+ return { mcpServers: [] };
}
- return null;
+ return { mcpServers: servers };
}
/**
diff --git a/packages/assistant-ui-runtime/src/convertTurnMessages.ts b/packages/assistant-ui-runtime/src/convertTurnMessages.ts
index 6901efdb4..21738996c 100644
--- a/packages/assistant-ui-runtime/src/convertTurnMessages.ts
+++ b/packages/assistant-ui-runtime/src/convertTurnMessages.ts
@@ -48,6 +48,7 @@ import {
applyApprovalDecisionsToContent,
collectApprovalDecisionsFromTurnInput,
collectSubsequentApprovalDecisions,
+ hasPendingToolApproval,
messageHasPendingApprovals,
TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY,
toolApprovalMessageCustom,
@@ -58,6 +59,7 @@ import {
applyUserToolResponsesToFold,
collectSubsequentToolResponses,
collectToolResponsesFromTurnInput,
+ hasPendingToolResponse,
messageHasPendingResponses,
TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY,
toolResponseMessageCustom,
@@ -1055,6 +1057,95 @@ function applyRequiredActionsOverlayToMessages(
});
}
+type ThreadAssistantMessagePart = Extract<ThreadMessage, { role: 'assistant' }>['content'][number];
+type AssistantToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-call' }>;
+
+function stripInteractivePendingFromContent(
+ content: readonly ThreadAssistantMessagePart[],
+): ThreadAssistantMessagePart[] {
+ return content.map(part => {
+ if (part.type !== 'tool-call') {
+ return part;
+ }
+
+ let next: AssistantToolCallPart = part;
+ if (hasPendingToolResponse(part)) {
+ const { interrupt, ...rest } = part;
+ void interrupt;
+ next = rest;
+ }
+ const approval = next.approval;
+ if (approval != null && hasPendingToolApproval(approval)) {
+ next = {
+ ...next,
+ approval: {
+ ...approval,
+ approved: false,
+ reason: 'Superseded by a later message',
+ },
+ };
+ }
+ if (next.messages != null) {
+ const nested = next.messages.map(message => {
+ if (message.role !== 'assistant' || message.status.type !== 'requires-action') {
+ return message;
+ }
+ return stripInteractivePendingFromAssistant(message);
+ });
+ next = { ...next, messages: nested };
+ }
+ return next;
+ });
+}
+
+function stripInteractivePendingFromAssistant(
+ message: Extract<ThreadMessage, { role: 'assistant' }>,
+): Extract<ThreadMessage, { role: 'assistant' }> {
+ const content = stripInteractivePendingFromContent(message.content);
+ const custom = Object.fromEntries(
+ Object.entries(message.metadata.custom).filter(
+ ([key]) =>
+ key !== 'pendingMcpAuth' &&
+ key !== 'mcpServers' &&
+ key !== TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY &&
+ key !== TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY,
+ ),
+ );
+ return {
+ ...message,
+ content,
+ status: { type: 'incomplete', reason: 'cancelled' },
+ metadata: {
+ ...message.metadata,
+ custom,
+ },
+ };
+}
+
+/** Clear interactive pause chrome on assistants that a later user message abandoned. */
+function abandonSupersededPausedMessages(messages: readonly ThreadMessage[]): ThreadMessage[] {
+ let lastUserIndex = -1;
+ for (let i = messages.length - 1; i >= 0; i--) {
+ if (messages[i]?.role === 'user') {
+ lastUserIndex = i;
+ break;
+ }
+ }
+ if (lastUserIndex < 0) {
+ return [...messages];
+ }
+
+ return messages.map((message, index) => {
+ if (index >= lastUserIndex) {
+ return message;
+ }
+ if (message.role !== 'assistant' || message.status.type !== 'requires-action') {
+ return message;
+ }
+ return stripInteractivePendingFromAssistant(message);
+ });
+}
+
function projectHistoryTurns(snapshot: SessionSnapshot, options?: ProjectSessionMessagesOptions): ThreadMessage[] {
const messages: ThreadMessage[] = [];
let lastAssistantIndex: number | undefined;
@@ -1213,7 +1304,7 @@ export function projectSessionMessages(
}
}
- return applyRequiredActionsOverlayToMessages(messages, snapshot.requiredActions);
+ return abandonSupersededPausedMessages(applyRequiredActionsOverlayToMessages(messages, snapshot.requiredActions));
}
const DEFAULT_LIST_EVENTS_CONCURRENCY = 5;
diff --git a/packages/assistant-ui-runtime/src/index.ts b/packages/assistant-ui-runtime/src/index.ts
index 669506f2b..2e50938c4 100644
--- a/packages/assistant-ui-runtime/src/index.ts
+++ b/packages/assistant-ui-runtime/src/index.ts
@@ -49,7 +49,7 @@ export type {
} from './messageCustomMetadata.js';
export {
collectRequiredActionInputs,
- findPausedAssistantMessage,
+ findCurrentPausedAssistantMessage,
messageHasPendingRequiredActions,
} from './requiredActionInputs.js';
export { getSession } from './sessions.js';
diff --git a/packages/assistant-ui-runtime/src/requiredActionInputs.ts b/packages/assistant-ui-runtime/src/requiredActionInputs.ts
index 13dd69ce2..320de5daa 100644
--- a/packages/assistant-ui-runtime/src/requiredActionInputs.ts
+++ b/packages/assistant-ui-runtime/src/requiredActionInputs.ts
@@ -25,14 +25,29 @@ export function isRequiredActionInput(item: TurnInputItem): item is RequiredActi
return item.type === 'user.tool_approval' || item.type === 'user.tool_response';
}
-export function findPausedAssistantMessage(
+/**
+ * Most recent assistant that is still awaiting action, ignoring a trailing
+ * non-paused assistant (optimistic/running bubble). Returns undefined when a
+ * later user message has abandoned the pause.
+ */
+export function findCurrentPausedAssistantMessage(
messages: readonly ThreadMessage[],
): Extract<ThreadMessage, { role: 'assistant' }> | undefined {
for (let i = messages.length - 1; i >= 0; i--) {
const candidate = messages[i];
- if (candidate?.role === 'assistant' && candidate.status.type === 'requires-action') {
+ if (candidate == null) {
+ continue;
+ }
+ if (candidate.role === 'user') {
+ return undefined;
+ }
+ if (candidate.role !== 'assistant') {
+ continue;
+ }
+ if (candidate.status.type === 'requires-action') {
return candidate;
}
+ // Skip a trailing non-paused assistant (streaming/complete bubble).
}
return undefined;
}
diff --git a/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts b/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts
index 587bae9af..b5b2bbaf3 100644
--- a/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts
+++ b/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts
@@ -7,6 +7,7 @@ import type {
ToolResponseRequiredEvent,
Turn,
TurnInputItem,
+ TurnStateCancelled,
TurnStateDone,
} from './server/index.js';
import type { AgentChatServer } from './server/types.js';
@@ -25,12 +26,14 @@ import {
type UserMessageContent,
} from './convertTurnMessages.js';
import { extractTurnUserText } from './extractTurnUserText.js';
+import { ingestTurnEvent } from './foldPeerThreads.js';
import { loadSessionSnapshot } from './loadSessionSnapshot.js';
import { MCP_AUTH_RESUME_RUN_CUSTOM_KEY } from './mcpAuth.js';
import { isMcpServerAuthInfoList } from './messageCustomMetadata.js';
+import type { AssistantContentPart } from './modelMessageContent.js';
import {
collectRequiredActionInputs,
- findPausedAssistantMessage,
+ findCurrentPausedAssistantMessage,
messageHasPendingRequiredActions,
type RequiredActionInput,
} from './requiredActionInputs.js';
@@ -99,6 +102,142 @@ function buildCompletedTurnState(
};
}
+function buildCancelledTurnState(completedAt: string): TurnStateCancelled {
+ return {
+ status: 'cancelled',
+ reason: 'Superseded by a later message',
+ completedAt,
+ };
+}
+
+/**
+ * Custom stream adapters may yield projected content without fold events.
+ * Materialize that content so a cancelled commit still projects after
+ * `activeStream` is cleared for the next user turn.
+ */
+function materializeAbandonedStreamRootIds(options: {
+ fold: SessionSnapshot['fold'];
+ turnId: string;
+ content: readonly AssistantContentPart[];
+ existingRootIds: readonly string[];
+}): string[] {
+ if (options.existingRootIds.length > 0) {
+ return [...options.existingRootIds];
+ }
+ if (options.content.length === 0) {
+ return [];
+ }
+
+ const text = options.content
+ .filter((part): part is Extract<AssistantContentPart, { type: 'text' }> => part.type === 'text')
+ .map(part => part.text)
+ .join('');
+ const toolCalls = options.content
+ .filter((part): part is Extract<AssistantContentPart, { type: 'tool-call' }> => part.type === 'tool-call')
+ .map(part => ({
+ id: part.toolCallId,
+ type: 'function' as const,
+ function: {
+ name: part.toolName,
+ arguments: part.argsText,
+ },
+ }));
+ const modelId = `client-abandoned-${options.turnId}`;
+ ingestTurnEvent(options.fold, {
+ type: 'model.message',
+ id: modelId,
+ threadId: ROOT_THREAD_ID,
+ createdAt: new Date().toISOString(),
+ content: text.length > 0 ? text : null,
+ ...(toolCalls.length > 0 ? { toolCalls } : {}),
+ });
+ return [modelId];
+}
+
+/**
+ * Force-commits an in-flight client turn (optimistic user and/or incomplete
+ * stream) as cancelled so a superseding user send keeps that half-baked chat
+ * in history. Does not call cancelSession — the backend supersedes on its own.
+ */
+function abandonInFlightClientTurn(snapshot: SessionSnapshot): SessionSnapshot {
+ const active = snapshot.activeStream;
+ const hasIncompleteStream = active != null && active.streamComplete !== true;
+ const hasPendingUser = snapshot.pendingUser != null;
+
+ if (!hasIncompleteStream && !hasPendingUser) {
+ return snapshot;
+ }
+
+ const completedAt = new Date().toISOString();
+ const cancelledState = buildCancelledTurnState(completedAt);
+
+ if (active != null && active.streamComplete !== true) {
+ const activeSandboxIdValue = active.update.metadata?.custom?.['sandboxId'];
+ const activeSandboxId = typeof activeSandboxIdValue === 'string' ? activeSandboxIdValue : undefined;
+ const baseline = snapshot.groupRootBaseline ?? computeGroupRootBaseline(snapshot.turns);
+ const rootModelMessageIds = materializeAbandonedStreamRootIds({
+ fold: snapshot.fold,
+ turnId: active.turnId,
+ content: active.update.content,
+ existingRootIds: rootModelMessageIdsSinceBaseline(snapshot.fold, baseline),
+ });
+
+ const lastTurn = snapshot.turns.at(-1);
+ if (lastTurn?.id === active.turnId) {
+ return replaceSessionSnapshot(snapshot, {
+ turns: snapshot.turns.map(turn =>
+ turn.id === active.turnId
+ ? {
+ ...turn,
+ state: cancelledState,
+ rootModelMessageIds,
+ ...(activeSandboxId != null ? { sandboxId: activeSandboxId } : {}),
+ }
+ : turn,
+ ),
+ pendingUser: undefined,
+ activeStream: undefined,
+ });
+ }
+
+ const record: SessionTurnRecord = {
+ id: active.turnId,
+ createdAt: snapshot.pendingUser?.createdAt.toISOString() ?? completedAt,
+ state: cancelledState,
+ input: snapshot.pendingUser ? [buildUserTurnInput(snapshot.pendingUser.content)] : [],
+ ...(snapshot.pendingUser ? { userText: userMessageContentToText(snapshot.pendingUser.content) } : {}),
+ rootModelMessageIds,
+ ...(activeSandboxId != null ? { sandboxId: activeSandboxId } : {}),
+ };
+
+ return replaceSessionSnapshot(snapshot, {
+ turns: [...snapshot.turns, record],
+ pendingUser: undefined,
+ activeStream: undefined,
+ });
+ }
+
+ const pending = snapshot.pendingUser;
+ if (pending == null) {
+ return snapshot;
+ }
+
+ const record: SessionTurnRecord = {
+ id: pending.turnId,
+ createdAt: pending.createdAt.toISOString(),
+ state: cancelledState,
+ input: [buildUserTurnInput(pending.content)],
+ userText: userMessageContentToText(pending.content),
+ rootModelMessageIds: [],
+ };
+
+ return replaceSessionSnapshot(snapshot, {
+ turns: [...snapshot.turns, record],
+ pendingUser: undefined,
+ activeStream: undefined,
+ });
+}
+
/**
* Reconstructs the pending required actions a paused in-flight update carried,
* so the pause survives `commitActiveStream`'s synthetic "done" state.
@@ -108,7 +247,7 @@ function buildCompletedTurnState(
* status from `turn.state.requiredActions` (see `findApprovalRequiredInTurn` /
* `findResponseRequiredInTurn` / `findMcpAuthRequired`). If we returned an empty
* list here, the committed turn would look "complete", the projected message
- * would lose its `requires-action` status, and `findPausedAssistantMessage`
+ * would lose its `requires-action` status, and `findCurrentPausedAssistantMessage`
* (used by `trySendCollectedRequiredActions`) would never see it — so answering
* a tool approval or an `ask_user_question` would never send the resume turn.
*
@@ -472,6 +611,7 @@ export function useTrueForgeAgentMessages({
.finally(() => {
if (activeRunRef.current === run) {
activeRunRef.current = null;
+ setIsRunning(false);
}
});
return run;
@@ -612,6 +752,14 @@ export function useTrueForgeAgentMessages({
let runStreamStarted = false;
let pendingUserTurnId: string | undefined;
+ // Invalidate the prior client stream before any await so a buffered RAF
+ // cannot restore stale activeStream after the optimistic user message.
+ // Continuations keep today's runStream abort; they must not race a user send.
+ const sendGeneration = 'userMessage' in options ? ++streamGenerationRef.current : streamGenerationRef.current;
+ if ('userMessage' in options) {
+ abortControllerRef.current?.abort();
+ }
+
try {
let activeSessionId = sessionId;
if (activeSessionId == null) {
@@ -628,6 +776,9 @@ export function useTrueForgeAgentMessages({
resolveConversationSessionIdRef.current,
);
const turnHeaders = await getTurnHeadersRef.current?.();
+ if (sendGeneration !== streamGenerationRef.current) {
+ return;
+ }
const streamHeaders = turnHeaders != null ? { headers: turnHeaders } : {};
const isContinuation = 'inputs' in options || ('resumeMcpAuth' in options && options.resumeMcpAuth);
const continuationTurnId = snapshotRef.current.activeStream?.turnId;
@@ -694,9 +845,12 @@ export function useTrueForgeAgentMessages({
if (branchBase != null && 'userMessage' in options) {
// Atomic apply: never merge pendingUser onto a stale React `prev`
// that still holds pre-branch turns (edit would show old + new).
- const rootBucket = branchBase.fold.threads.get(ROOT_THREAD_ID);
+ // Commit any completed stream, then abandon incomplete in-flight chat
+ // into history before the new optimistic user message.
+ const abandoned = abandonInFlightClientTurn(commitActiveStream(branchBase));
+ const rootBucket = abandoned.fold.threads.get(ROOT_THREAD_ID);
groupRootBaseline = [...(rootBucket?.modelMessageIds ?? [])];
- const nextSnapshot = replaceSessionSnapshot(branchBase, {
+ const nextSnapshot = replaceSessionSnapshot(abandoned, {
pendingUser: {
turnId,
content: options.userMessage,
@@ -704,36 +858,43 @@ export function useTrueForgeAgentMessages({
},
activeStream: undefined,
groupRootBaseline,
+ requiredActions: {
+ approvals: new Map(),
+ toolResponses: new Map(),
+ },
});
snapshotRef.current = nextSnapshot;
setSnapshot(nextSnapshot);
pendingUserWasSet = true;
pendingUserTurnId = turnId;
+ } else if ('userMessage' in options) {
+ // Sync from snapshotRef so groupRootBaseline is set before runStream
+ // (setState updaters after await are not guaranteed to flush first).
+ const abandoned = abandonInFlightClientTurn(commitActiveStream(snapshotRef.current));
+ const rootBucket = abandoned.fold.threads.get(ROOT_THREAD_ID);
+ groupRootBaseline = [...(rootBucket?.modelMessageIds ?? [])];
+ const next = replaceSessionSnapshot(abandoned, {
+ pendingUser: {
+ turnId,
+ content: options.userMessage,
+ createdAt: new Date(),
+ },
+ activeStream: undefined,
+ groupRootBaseline,
+ // Drop staged pause answers so they cannot resume behind this turn.
+ requiredActions: {
+ approvals: new Map(),
+ toolResponses: new Map(),
+ },
+ });
+ snapshotRef.current = next;
+ setSnapshot(next);
+ pendingUserWasSet = true;
+ pendingUserTurnId = turnId;
} else {
setSnapshot(prev => commitActiveStream(prev, 'inputs' in options ? options.inputs : undefined));
-
- if ('userMessage' in options) {
- const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
- groupRootBaseline = [...(rootBucket?.modelMessageIds ?? [])];
- setSnapshot(prev => {
- const next = replaceSessionSnapshot(prev, {
- pendingUser: {
- turnId,
- content: options.userMessage,
- createdAt: new Date(),
- },
- activeStream: undefined,
- groupRootBaseline,
- });
- snapshotRef.current = next;
- return next;
- });
- pendingUserWasSet = true;
- pendingUserTurnId = turnId;
- } else {
- groupRootBaseline =
- snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
- }
+ groupRootBaseline =
+ snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
}
runStreamStarted = true;
@@ -783,6 +944,9 @@ export function useTrueForgeAgentMessages({
isContinuation,
);
} catch (error) {
+ if (!runStreamStarted && sendGeneration !== streamGenerationRef.current) {
+ return;
+ }
if ('userMessage' in options && !gatewayTurnAccepted.current) {
const branchRollbackSnapshot = options.branchRollbackSnapshot;
const canRestoreBranch =
@@ -807,6 +971,15 @@ export function useTrueForgeAgentMessages({
options.onPreTurnFailure?.();
}
if (!runStreamStarted) {
+ if ('userMessage' in options) {
+ const abandoned = abandonInFlightClientTurn(commitActiveStream(snapshotRef.current));
+ snapshotRef.current = abandoned;
+ setSnapshot(abandoned);
+ }
+ if (abortControllerRef.current?.signal.aborted) {
+ abortControllerRef.current = null;
+ }
+ setIsRunning(false);
onErrorRef.current?.(error);
}
throw error;
@@ -836,12 +1009,8 @@ export function useTrueForgeAgentMessages({
// reconcile is needed here — the cancelled turn is terminal and local
// state reconciles against the event log on the next session load.
await activeRunRef.current?.catch(() => undefined);
- // Nothing drained when the load could not attach a stream, so clear the
- // running flag here or the composer stays blocked until a reload.
- if (resumeUnavailableRef.current) {
- markResumeUnavailable(false);
- setIsRunning(false);
- }
+ markResumeUnavailable(false);
+ setIsRunning(false);
}, [server, sessionId, markResumeUnavailable]);
const isRunningRef = useRef(isRunning);
@@ -853,7 +1022,7 @@ export function useTrueForgeAgentMessages({
return;
}
const projected = projectSessionMessages(nextSnapshot, projectOptions);
- const paused = findPausedAssistantMessage(projected);
+ const paused = findCurrentPausedAssistantMessage(projected);
if (paused == null || messageHasPendingRequiredActions(paused)) {
return;
}
@@ -1135,4 +1304,4 @@ export function useTrueForgeAgentMessages({
};
}
-export { findPausedAssistantMessage, MCP_AUTH_RESUME_RUN_CUSTOM_KEY };
+export { findCurrentPausedAssistantMessage, MCP_AUTH_RESUME_RUN_CUSTOM_KEY };
diff --git a/packages/assistant-ui-runtime/test/collectPending.test.ts b/packages/assistant-ui-runtime/test/collectPending.test.ts
index 7eea9e64e..a84a92179 100644
--- a/packages/assistant-ui-runtime/test/collectPending.test.ts
+++ b/packages/assistant-ui-runtime/test/collectPending.test.ts
@@ -1,21 +1,35 @@
import type { ThreadMessage } from '@assistant-ui/core';
import { describe, expect, it } from 'vitest';
-import { deriveSandboxId } from '../src/collectPending.js';
+import {
+ collectPendingApprovals,
+ collectPendingToolResponses,
+ derivePendingMcpAuth,
+ deriveSandboxId,
+} from '../src/collectPending.js';
+import { ROOT_THREAD_ID } from '../src/constants.js';
+import { TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY } from '../src/toolResponse.js';
-function assistantMessage(id: string, custom: Record<string, unknown> = {}): ThreadMessage {
+function assistantMessage(
+ id: string,
+ options: {
+ custom?: Record<string, unknown>;
+ status?: Extract<ThreadMessage, { role: 'assistant' }>['status'];
+ content?: Extract<ThreadMessage, { role: 'assistant' }>['content'];
+ } = {},
+): Extract<ThreadMessage, { role: 'assistant' }> {
return {
id,
role: 'assistant' as const,
- content: [],
- status: { type: 'complete' as const, reason: 'stop' as const },
+ content: options.content ?? [],
+ status: options.status ?? { type: 'complete' as const, reason: 'stop' as const },
createdAt: new Date(),
metadata: {
unstable_state: null,
unstable_annotations: [],
unstable_data: [],
steps: [],
- custom,
+ custom: options.custom ?? {},
},
};
}
@@ -40,7 +54,7 @@ describe('deriveSandboxId', () => {
it('returns the sandboxId from the most recent message that has one', () => {
const messages = [
userMessage('u1'),
- assistantMessage('a1', { sandboxId: 'sbx-1' }),
+ assistantMessage('a1', { custom: { sandboxId: 'sbx-1' } }),
userMessage('u2'),
assistantMessage('a2'),
];
@@ -48,12 +62,76 @@ describe('deriveSandboxId', () => {
});
it('prefers a later sandboxId over an earlier one', () => {
- const messages = [assistantMessage('a1', { sandboxId: 'sbx-1' }), assistantMessage('a2', { sandboxId: 'sbx-2' })];
+ const messages = [
+ assistantMessage('a1', { custom: { sandboxId: 'sbx-1' } }),
+ assistantMessage('a2', { custom: { sandboxId: 'sbx-2' } }),
+ ];
expect(deriveSandboxId(messages)).toBe('sbx-2');
});
it('keeps returning the sandboxId from earlier turns even when later assistant messages lack it', () => {
- const messages = [assistantMessage('a1', { sandboxId: 'sbx-1' }), assistantMessage('a2'), assistantMessage('a3')];
+ const messages = [
+ assistantMessage('a1', { custom: { sandboxId: 'sbx-1' } }),
+ assistantMessage('a2'),
+ assistantMessage('a3'),
+ ];
expect(deriveSandboxId(messages)).toBe('sbx-1');
});
});
+
+describe('current pause collection', () => {
+ const pausedAskUser = assistantMessage('paused', {
+ status: { type: 'requires-action', reason: 'tool-calls' },
+ custom: { [TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY]: ROOT_THREAD_ID },
+ content: [
+ {
+ type: 'tool-call',
+ toolCallId: 'question-1',
+ toolName: 'ask_user_question',
+ args: {},
+ argsText: '{}',
+ interrupt: { type: 'human', payload: { question: 'Pick?' } },
+ },
+ ],
+ });
+
+ it('collects pending tool responses from the current pause only', () => {
+ expect(collectPendingToolResponses([pausedAskUser])).toHaveLength(1);
+ });
+
+ it('ignores an abandoned pause after a later user message', () => {
+ const messages = [pausedAskUser, userMessage('u-followup')];
+ expect(collectPendingToolResponses(messages)).toEqual([]);
+ expect(collectPendingApprovals(messages)).toEqual([]);
+ expect(derivePendingMcpAuth(messages)).toBeNull();
+ });
+
+ it('derives MCP auth only from the current pause', () => {
+ const pausedMcp = assistantMessage('mcp', {
+ status: { type: 'requires-action', reason: 'interrupt' },
+ custom: {
+ pendingMcpAuth: true,
+ mcpServers: [{ id: 's1', name: 'GitHub', authUrl: 'https://example.com' }],
+ },
+ });
+ expect(derivePendingMcpAuth([pausedMcp])?.mcpServers).toHaveLength(1);
+ expect(derivePendingMcpAuth([pausedMcp, userMessage('u2')])).toBeNull();
+ });
+
+ it('collects nested approvals from the current paused message', () => {
+ const pausedApproval = assistantMessage('paused-approval', {
+ status: { type: 'requires-action', reason: 'tool-calls' },
+ content: [
+ {
+ type: 'tool-call',
+ toolCallId: 'approval-1',
+ toolName: 'bash',
+ args: {},
+ argsText: '{}',
+ approval: { id: 'approval-1' },
+ },
+ ],
+ });
+ expect(collectPendingApprovals([pausedApproval])).toEqual([expect.objectContaining({ approvalId: 'approval-1' })]);
+ });
+});
diff --git a/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts b/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts
index 98fa4cc84..b7925be9e 100644
--- a/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts
+++ b/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts
@@ -32,7 +32,7 @@ import {
turnStreamUpdateToAssistantMessage,
} from '../src/convertTurnMessages.js';
import { buildRootAssistantContent, ingestTurnEvent, PeerThreadFoldState } from '../src/foldPeerThreads.js';
-import { findPausedAssistantMessage } from '../src/requiredActionInputs.js';
+import { findCurrentPausedAssistantMessage } from '../src/requiredActionInputs.js';
import {
createEmptySessionSnapshot,
replaceSessionSnapshot,
@@ -936,7 +936,7 @@ describe('convertTurnMessages', () => {
toolCallId: 'approval-1',
approval: { id: 'approval-1' },
});
- expect(findPausedAssistantMessage(result.messages)).toBe(assistant);
+ expect(findCurrentPausedAssistantMessage(result.messages)).toBe(assistant);
});
it('downgrades to complete after a later turn submits user.tool_approval', async () => {
@@ -1089,7 +1089,7 @@ describe('convertTurnMessages', () => {
payload: { question: 'Pick one', options: ['A', 'B'] },
},
});
- expect(findPausedAssistantMessage(result.messages)).toBe(assistant);
+ expect(findCurrentPausedAssistantMessage(result.messages)).toBe(assistant);
});
it('downgrades to complete after a later turn submits user.tool_response', async () => {
@@ -1840,7 +1840,7 @@ describe('convertTurnMessages', () => {
toolCallId: 'approval-1',
approval: { id: 'approval-1' },
});
- expect(findPausedAssistantMessage(messages)).toBe(assistant);
+ expect(findCurrentPausedAssistantMessage(messages)).toBe(assistant);
});
it('preserves requires-action when streamComplete and update has ask-user status', async () => {
@@ -1899,7 +1899,7 @@ describe('convertTurnMessages', () => {
payload: { question: 'Pick one', options: ['A', 'B'] },
},
});
- expect(findPausedAssistantMessage(messages)).toBe(assistant);
+ expect(findCurrentPausedAssistantMessage(messages)).toBe(assistant);
});
it('forces complete when streamComplete and update has no explicit status', () => {
@@ -2092,7 +2092,7 @@ describe('convertTurnMessages', () => {
// fabricated `TurnStateDone`. The pause must survive as a
// `tool.response_required` required action, otherwise the projected
// assistant message is not `requires-action` and
- // `findPausedAssistantMessage` (the gate that fires the resume turn)
+ // `findCurrentPausedAssistantMessage` (the gate that fires the resume turn)
// never sees it.
const fold = new PeerThreadFoldState();
const turnId = 'turn-ask';
@@ -2155,7 +2155,7 @@ describe('convertTurnMessages', () => {
});
const messages = projectSessionMessages(snapshot);
- const paused = findPausedAssistantMessage(messages);
+ const paused = findCurrentPausedAssistantMessage(messages);
expect(paused).toBeDefined();
expect(paused?.status).toMatchObject({ type: 'requires-action' });
});
diff --git a/packages/assistant-ui-runtime/test/requiredActionInputs.test.ts b/packages/assistant-ui-runtime/test/requiredActionInputs.test.ts
index bff0ccba0..ce71895e9 100644
--- a/packages/assistant-ui-runtime/test/requiredActionInputs.test.ts
+++ b/packages/assistant-ui-runtime/test/requiredActionInputs.test.ts
@@ -1,10 +1,56 @@
import { describe, expect, it } from 'vitest';
import { ROOT_THREAD_ID } from '../src/constants.js';
-import { collectRequiredActionInputs, messageHasPendingRequiredActions } from '../src/requiredActionInputs.js';
+import {
+ collectRequiredActionInputs,
+ findCurrentPausedAssistantMessage,
+ messageHasPendingRequiredActions,
+} from '../src/requiredActionInputs.js';
import { applyApprovalDecisionsToMessage, collectApprovalInputs } from '../src/toolApproval.js';
import { applyToolResponseToMessage } from '../src/toolResponse.js';
+describe('findCurrentPausedAssistantMessage', () => {
+ const paused = {
+ id: 'paused',
+ role: 'assistant' as const,
+ content: [],
+ status: { type: 'requires-action' as const, reason: 'tool-calls' as const },
+ createdAt: new Date(),
+ metadata: {
+ unstable_state: null,
+ unstable_annotations: [],
+ unstable_data: [],
+ steps: [],
+ custom: {},
+ },
+ };
+
+ it('returns the current requires-action assistant', () => {
+ expect(findCurrentPausedAssistantMessage([paused])).toBe(paused);
+ });
+
+ it('skips a trailing non-paused assistant', () => {
+ const running = {
+ ...paused,
+ id: 'running',
+ status: { type: 'running' as const },
+ };
+ expect(findCurrentPausedAssistantMessage([paused, running])).toBe(paused);
+ });
+
+ it('returns undefined when a later user message abandoned the pause', () => {
+ const user = {
+ id: 'u1',
+ role: 'user' as const,
+ content: [{ type: 'text' as const, text: 'next' }],
+ attachments: [],
+ createdAt: new Date(),
+ metadata: { custom: {} },
+ };
+ expect(findCurrentPausedAssistantMessage([paused, user])).toBeUndefined();
+ });
+});
+
describe('requiredActionInputs', () => {
describe('batched resume invariant', () => {
it('bundles approvals and responses once nothing is pending', () => {
diff --git a/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx b/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx
index 3cf425e3a..f04d9f31f 100644
--- a/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx
+++ b/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx
@@ -902,6 +902,283 @@ describe('useTrueForgeAgentMessages', () => {
});
});
+ it('aborts the prior client stream on a new user send without cancelSession', async () => {
+ let firstSignal: AbortSignal | undefined;
+ let releaseFirstStream: (() => void) | undefined;
+ let releaseSecondStream: (() => void) | undefined;
+ const runningValues: boolean[] = [];
+
+ vi.mocked(streamTurnContent)
+ .mockImplementationOnce(async function* (_server, _sessionId, _fold, _options, signal) {
+ firstSignal = signal;
+ yield { content: [{ type: 'text' as const, text: 'first reply' }] };
+ await new Promise<void>(resolve => {
+ releaseFirstStream = resolve;
+ });
+ })
+ .mockImplementationOnce(async function* () {
+ yield { content: [{ type: 'text' as const, text: 'second reply' }] };
+ await new Promise<void>(resolve => {
+ releaseSecondStream = resolve;
+ });
+ });
+
+ const { result } = renderHook(() => useTrueForgeAgentMessages({ server: mockServer, sessionId: 'session-1' }));
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ const firstSend = result.current.sendTurn({ userMessage: 'first' });
+ await waitFor(() => expect(streamTurnContent).toHaveBeenCalledTimes(1));
+ expect(result.current.isRunning).toBe(true);
+ runningValues.push(result.current.isRunning);
+
+ const secondSend = result.current.sendTurn({ userMessage: 'second' });
+ await waitFor(() => expect(streamTurnContent).toHaveBeenCalledTimes(2));
+ runningValues.push(result.current.isRunning);
+
+ expect(firstSignal?.aborted).toBe(true);
+ expect(mockServer.cancelSession).not.toHaveBeenCalled();
+ expect(runningValues.every(value => value)).toBe(true);
+
+ await act(async () => {
+ releaseFirstStream?.();
+ await firstSend.catch(() => undefined);
+ });
+ expect(result.current.isRunning).toBe(true);
+
+ await act(async () => {
+ releaseSecondStream?.();
+ await secondSend;
+ });
+ });
+
+ it('keeps mid-stream user and assistant content when a later user message supersedes', async () => {
+ let releaseFirstStream: (() => void) | undefined;
+ let releaseSecondStream: (() => void) | undefined;
+ const runningValues: boolean[] = [];
+
+ vi.stubGlobal(
+ 'requestAnimationFrame',
+ vi.fn((callback: FrameRequestCallback) => {
+ callback(performance.now());
+ return 1;
+ }),
+ );
+ vi.stubGlobal('cancelAnimationFrame', vi.fn());
+
+ vi.mocked(streamTurnContent)
+ .mockImplementationOnce(async function* () {
+ yield { content: [{ type: 'text' as const, text: 'first partial' }] };
+ await new Promise<void>(resolve => {
+ releaseFirstStream = resolve;
+ });
+ })
+ .mockImplementationOnce(async function* () {
+ yield { content: [{ type: 'text' as const, text: 'second reply' }] };
+ await new Promise<void>(resolve => {
+ releaseSecondStream = resolve;
+ });
+ });
+
+ const { result } = renderHook(() => useTrueForgeAgentMessages({ server: mockServer, sessionId: 'session-1' }));
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ const firstSend = result.current.sendTurn({ userMessage: 'first' });
+ await waitFor(() =>
+ expect(
+ result.current.messages.some(
+ message =>
+ message.role === 'assistant' &&
+ message.content.some(part => part.type === 'text' && part.text === 'first partial'),
+ ),
+ ).toBe(true),
+ );
+ runningValues.push(result.current.isRunning);
+
+ const secondSend = result.current.sendTurn({ userMessage: 'second' });
+ await waitFor(() => expect(streamTurnContent).toHaveBeenCalledTimes(2));
+ runningValues.push(result.current.isRunning);
+
+ expect(mockServer.cancelSession).not.toHaveBeenCalled();
+ expect(runningValues.every(value => value)).toBe(true);
+
+ const userTexts = result.current.messages
+ .filter(message => message.role === 'user')
+ .map(message =>
+ message.content
+ .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
+ .map(part => part.text)
+ .join(''),
+ );
+ expect(userTexts).toEqual(['first', 'second']);
+
+ const cancelledAssistant = result.current.messages.find(
+ message =>
+ message.role === 'assistant' &&
+ message.content.some(part => part.type === 'text' && part.text === 'first partial'),
+ );
+ expect(cancelledAssistant).toMatchObject({
+ role: 'assistant',
+ status: { type: 'incomplete', reason: 'cancelled' },
+ });
+
+ await act(async () => {
+ releaseFirstStream?.();
+ await firstSend.catch(() => undefined);
+ });
+ expect(result.current.isRunning).toBe(true);
+
+ await act(async () => {
+ releaseSecondStream?.();
+ await secondSend;
+ });
+ });
+
+ it('keeps the first user message when a later send arrives before any assistant token', async () => {
+ let releaseFirstStream: (() => void) | undefined;
+ let releaseSecondStream: (() => void) | undefined;
+
+ vi.mocked(streamTurnContent)
+ .mockImplementationOnce(async function* () {
+ await new Promise<void>(resolve => {
+ releaseFirstStream = resolve;
+ });
+ yield { content: [{ type: 'text' as const, text: 'late first reply' }] };
+ })
+ .mockImplementationOnce(async function* () {
+ yield { content: [{ type: 'text' as const, text: 'second reply' }] };
+ await new Promise<void>(resolve => {
+ releaseSecondStream = resolve;
+ });
+ });
+
+ const { result } = renderHook(() => useTrueForgeAgentMessages({ server: mockServer, sessionId: 'session-1' }));
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ const firstSend = result.current.sendTurn({ userMessage: 'first before tokens' });
+ await waitFor(() => expect(streamTurnContent).toHaveBeenCalledTimes(1));
+ await waitFor(() =>
+ expect(
+ result.current.messages.some(
+ message =>
+ message.role === 'user' &&
+ message.content.some(part => part.type === 'text' && part.text === 'first before tokens'),
+ ),
+ ).toBe(true),
+ );
+
+ const secondSend = result.current.sendTurn({ userMessage: 'second' });
+ await waitFor(() => expect(streamTurnContent).toHaveBeenCalledTimes(2));
+
+ expect(mockServer.cancelSession).not.toHaveBeenCalled();
+ const userTexts = result.current.messages
+ .filter(message => message.role === 'user')
+ .map(message =>
+ message.content
+ .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
+ .map(part => part.text)
+ .join(''),
+ );
+ expect(userTexts).toEqual(['first before tokens', 'second']);
+ expect(result.current.isRunning).toBe(true);
+
+ await act(async () => {
+ releaseFirstStream?.();
+ await firstSend.catch(() => undefined);
+ });
+ expect(result.current.isRunning).toBe(true);
+
+ await act(async () => {
+ releaseSecondStream?.();
+ await secondSend;
+ });
+ });
+
+ it('does not let a slower earlier send overwrite a later turn', async () => {
+ let releaseFirstHeaders: (() => void) | undefined;
+ const getTurnHeaders = vi.fn();
+ getTurnHeaders.mockImplementationOnce(
+ () =>
+ new Promise<Record<string, string> | undefined>(resolve => {
+ releaseFirstHeaders = () => resolve(undefined);
+ }),
+ );
+ getTurnHeaders.mockResolvedValue(undefined);
+
+ let releaseSecondStream: (() => void) | undefined;
+ vi.mocked(streamTurnContent).mockImplementation(async function* () {
+ yield { content: [{ type: 'text' as const, text: 'second reply' }] };
+ await new Promise<void>(resolve => {
+ releaseSecondStream = resolve;
+ });
+ });
+
+ const { result } = renderHook(() =>
+ useTrueForgeAgentMessages({
+ server: mockServer,
+ sessionId: 'session-1',
+ getTurnHeaders,
+ }),
+ );
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ let firstSend: Promise<void> | undefined;
+ await act(async () => {
+ firstSend = result.current.sendTurn({ userMessage: 'first' });
+ });
+ await waitFor(() => expect(getTurnHeaders).toHaveBeenCalledTimes(1));
+ expect(streamTurnContent).not.toHaveBeenCalled();
+
+ let secondSend: Promise<void> | undefined;
+ await act(async () => {
+ secondSend = result.current.sendTurn({ userMessage: 'second' });
+ });
+ await waitFor(() => expect(streamTurnContent).toHaveBeenCalledTimes(1));
+
+ await act(async () => {
+ releaseFirstHeaders?.();
+ await firstSend;
+ });
+
+ expect(streamTurnContent).toHaveBeenCalledTimes(1);
+ const userTexts = result.current.messages
+ .filter(message => message.role === 'user')
+ .map(message =>
+ message.content
+ .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
+ .map(part => part.text)
+ .join(''),
+ );
+ expect(userTexts).toEqual(['second']);
+
+ await act(async () => {
+ releaseSecondStream?.();
+ await secondSend;
+ });
+ });
+
+ it('drops ask-user pause chrome after a superseding user send', async () => {
+ vi.mocked(loadSessionSnapshot).mockResolvedValue(snapshotWithAskUserPendingInFold());
+ vi.mocked(streamTurnContent).mockReturnValue(
+ (async function* () {
+ yield { content: [{ type: 'text' as const, text: 'new reply' }] };
+ })(),
+ );
+
+ const { result } = renderHook(() => useTrueForgeAgentMessages({ server: mockServer, sessionId: 'session-1' }));
+ await waitFor(() => expect(collectPendingToolResponses(result.current.messages)).toHaveLength(1));
+
+ await act(async () => {
+ await result.current.sendTurn({ userMessage: 'ignore the question' });
+ });
+
+ expect(collectPendingToolResponses(result.current.messages)).toHaveLength(0);
+ expect(mockServer.cancelSession).not.toHaveBeenCalled();
+ const paused = result.current.messages.find(message => message.role === 'assistant' && message.id.includes('ask'));
+ if (paused?.role === 'assistant') {
+ expect(paused.status.type).not.toBe('requires-action');
+ }
+ });
+
it('carries a streamed sandboxId through commit so it survives after the stream completes', async () => {
vi.mocked(streamTurnContent).mockReturnValue(
(async function* () {
@@ -1396,6 +1673,126 @@ describe('useTrueForgeAgentMessages', () => {
expect(loadSessionSnapshot).toHaveBeenCalledTimes(1);
});
+ it('clears isRunning when a supersede send fails before runStream starts', async () => {
+ let resolveFirstStream: (() => void) | undefined;
+ vi.stubGlobal(
+ 'requestAnimationFrame',
+ vi.fn((callback: FrameRequestCallback) => {
+ callback(performance.now());
+ return 1;
+ }),
+ );
+ vi.stubGlobal('cancelAnimationFrame', vi.fn());
+ vi.mocked(streamTurnContent).mockReturnValue(
+ (async function* () {
+ yield { content: [{ type: 'text' as const, text: 'partial' }] };
+ await new Promise<void>(resolve => {
+ resolveFirstStream = resolve;
+ });
+ })(),
+ );
+
+ const getTurnHeaders = vi.fn();
+ const { result } = renderHook(() =>
+ useTrueForgeAgentMessages({
+ server: mockServer,
+ sessionId: 'session-1',
+ getTurnHeaders,
+ }),
+ );
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ // First turn starts running
+ let firstTurnPromise: Promise<void> | undefined;
+ await act(async () => {
+ firstTurnPromise = result.current.sendTurn({ userMessage: 'turn 1' });
+ });
+ await waitFor(() =>
+ expect(
+ result.current.messages.some(
+ message =>
+ message.role === 'assistant' &&
+ message.content.some(part => part.type === 'text' && part.text === 'partial'),
+ ),
+ ).toBe(true),
+ );
+
+ // A second send supersedes the first one, but getTurnHeaders rejects
+ getTurnHeaders.mockRejectedValue(new Error('Auth token expired'));
+
+ await act(async () => {
+ await expect(result.current.sendTurn({ userMessage: 'turn 2' })).rejects.toThrow('Auth token expired');
+ });
+
+ // The first stream was aborted by the supersede, and wait for it to complete
+ resolveFirstStream?.();
+ await act(async () => {
+ await firstTurnPromise?.catch(() => undefined);
+ });
+
+ expect(result.current.isRunning).toBe(false);
+ const userTexts = result.current.messages
+ .filter(message => message.role === 'user')
+ .map(message =>
+ message.content
+ .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
+ .map(part => part.text)
+ .join(''),
+ );
+ expect(userTexts).toEqual(['turn 1']);
+ expect(result.current.messages.find(message => message.role === 'assistant')).toMatchObject({
+ role: 'assistant',
+ status: { type: 'incomplete', reason: 'cancelled' },
+ });
+ });
+
+ it('cancel clears isRunning even after a failed supersede', async () => {
+ let resolveFirstStream: (() => void) | undefined;
+ vi.mocked(streamTurnContent).mockReturnValue(
+ (async function* () {
+ yield { content: [{ type: 'text' as const, text: 'partial' }] };
+ await new Promise<void>(resolve => {
+ resolveFirstStream = resolve;
+ });
+ })(),
+ );
+
+ const getTurnHeaders = vi.fn();
+ const { result } = renderHook(() =>
+ useTrueForgeAgentMessages({
+ server: mockServer,
+ sessionId: 'session-1',
+ getTurnHeaders,
+ }),
+ );
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ // First turn starts running
+ let firstTurnPromise: Promise<void> | undefined;
+ await act(async () => {
+ firstTurnPromise = result.current.sendTurn({ userMessage: 'turn 1' });
+ });
+ await waitFor(() => expect(result.current.isRunning).toBe(true));
+
+ // Second turn supersedes and fails
+ getTurnHeaders.mockRejectedValue(new Error('Failed header resolution'));
+ await act(async () => {
+ await expect(result.current.sendTurn({ userMessage: 'turn 2' })).rejects.toThrow('Failed header resolution');
+ });
+
+ // User triggers cancel
+ vi.mocked(mockServer.cancelSession).mockImplementation(async () => {
+ resolveFirstStream?.();
+ });
+
+ await act(async () => {
+ await result.current.cancel();
+ await firstTurnPromise?.catch(() => undefined);
+ });
+
+ expect(result.current.isRunning).toBe(false);
+ });
+
describe('pre-turn failure rollback', () => {
it('reports and restores a user message when initializeSession fails', async () => {
const onError = vi.fn();
diff --git a/packages/trueforge-ui/src/atoms/ComposerSections.tsx b/packages/trueforge-ui/src/atoms/ComposerSections.tsx
index 3daae1a35..d3e937cc3 100644
--- a/packages/trueforge-ui/src/atoms/ComposerSections.tsx
+++ b/packages/trueforge-ui/src/atoms/ComposerSections.tsx
@@ -22,6 +22,8 @@ export type ComposerSendButtonProps = {
disabled: boolean;
canSubmit: boolean;
isRunning: boolean;
+ /** True when the composer has trimmed text or attachments. */
+ hasContent: boolean;
onSubmit: () => void;
onCancel?: () => void;
};
@@ -50,8 +52,10 @@ export function ComposerRightSection(_: ComposerRightSectionProps): ReactNode {
return null;
}
-export function ComposerSendButton({ canSubmit, isRunning, onSubmit, onCancel }: ComposerSendButtonProps) {
- if (isRunning) {
+export function ComposerSendButton({ canSubmit, isRunning, hasContent, onSubmit, onCancel }: ComposerSendButtonProps) {
+ // Cancel only while busy with an empty composer. Content (even when Send is
+ // blocked by a missing model) keeps the Send affordance.
+ if (isRunning && !hasContent) {
return (
<Button.Primary type="button" size="small" disabled={!onCancel} onClick={onCancel} aria-label="Cancel">
<Spinner size={14} />
diff --git a/packages/trueforge-ui/src/atoms/ComposerShell.tsx b/packages/trueforge-ui/src/atoms/ComposerShell.tsx
index d711c7837..cc7e6bf51 100644
--- a/packages/trueforge-ui/src/atoms/ComposerShell.tsx
+++ b/packages/trueforge-ui/src/atoms/ComposerShell.tsx
@@ -11,6 +11,8 @@ export type ComposerShellProps = {
disabled: boolean;
canSubmit: boolean;
isRunning?: boolean;
+ /** True when the composer has trimmed text or attachments. */
+ hasContent?: boolean;
attachments?: ReactNode;
modelLabel?: string;
modelIcon?: ReactNode;
@@ -26,6 +28,7 @@ export function ComposerShell({
disabled,
canSubmit,
isRunning = false,
+ hasContent = false,
attachments,
modelLabel,
modelIcon,
@@ -73,6 +76,7 @@ export function ComposerShell({
disabled={disabled}
canSubmit={canSubmit}
isRunning={isRunning}
+ hasContent={hasContent}
onSubmit={onSubmit}
onCancel={onCancel}
/>
diff --git a/packages/trueforge-ui/src/atoms/adapters/AskUserPromptAdapter.tsx b/packages/trueforge-ui/src/atoms/adapters/AskUserPromptAdapter.tsx
index 925ab0891..859bd9118 100644
--- a/packages/trueforge-ui/src/atoms/adapters/AskUserPromptAdapter.tsx
+++ b/packages/trueforge-ui/src/atoms/adapters/AskUserPromptAdapter.tsx
@@ -22,6 +22,17 @@ export type AskUserAnswerDraft = {
export const ASK_USER_CUSTOM_OPTION = '__tfy_ask_user_question_custom__';
+/** A, B, … Z, then AA, AB, … for option indices. */
+export function askUserOptionLetter(index: number): string {
+ let n = index;
+ let label = '';
+ do {
+ label = String.fromCharCode(65 + (n % 26)) + label;
+ n = Math.floor(n / 26) - 1;
+ } while (n >= 0);
+ return label;
+}
+
export type AskUserPromptProps = {
questions: Question[];
answeredQuestions?: AnsweredQuestion[];
@@ -42,6 +53,23 @@ export type AskUserPromptProps = {
className?: string;
};
+function OptionLetterBadge({ letter, selected, className }: { letter: string; selected: boolean; className?: string }) {
+ return (
+ <span
+ aria-hidden
+ className={cn(
+ 'inline-flex size-5 shrink-0 items-center justify-center rounded border font-sans text-[0.6875rem] font-semibold leading-none',
+ selected
+ ? 'border-primary-button-bg/50 bg-primary-button-bg/15 text-primary-button-bg'
+ : 'border-border bg-transparent text-text-secondary',
+ className,
+ )}
+ >
+ {letter}
+ </span>
+ );
+}
+
export function AskUserPrompt({
questions,
answeredQuestions = [],
@@ -92,6 +120,7 @@ export function AskUserPrompt({
const isCustomSelected = currentAnswer.radioValue === ASK_USER_CUSTOM_OPTION;
const hasOptions = currentQuestion.options.length > 0;
+ const customOptionLetter = askUserOptionLetter(currentQuestion.options.length);
const handleOptionSelect = (value: string) => {
if (readOnly) return;
@@ -130,19 +159,23 @@ export function AskUserPrompt({
placeholder={hasOptions ? 'Other' : 'Type your answer'}
aria-label={hasOptions ? 'Other (custom answer)' : 'Your answer'}
className={cn(
- 'field-sizing-content min-h-6 max-h-[3lh] w-full resize-none overflow-y-auto rounded border border-input-border bg-primary-bg px-2 py-0.5 text-[0.8125rem] leading-snug text-text-primary',
- 'placeholder:text-[0.8125rem] focus:outline-none focus:ring-1 focus:ring-focus-ring',
+ 'field-sizing-content min-h-8 max-h-[3lh] w-full resize-none overflow-y-auto rounded-md border border-input-border bg-primary-bg px-2.5 py-1 text-sm leading-5 text-text-primary',
+ 'placeholder:text-sm focus:outline-none focus:ring-1 focus:ring-focus-ring',
)}
/>
);
return (
<div
- className={cn('aui-ask-user-prompt', className)}
+ className={cn(
+ // Inset vs composer so stacked pause chrome matches the design (~1rem each side).
+ 'aui-ask-user-prompt mx-auto w-[calc(100%-2rem)] min-w-0 overflow-hidden rounded-lg',
+ className,
+ )}
data-testid={dataTestPrefix ? `${dataTestPrefix}-question-card` : undefined}
>
- <div className="flex items-center justify-between rounded-t-lg border border-primary-button-bg/30 bg-primary-button-bg/10 px-4 py-2">
- <div className="font-sans text-sm font-medium text-primary-button-bg">
+ <div className="flex items-center justify-between border rounded-t-lg border-primary-button-bg/30 bg-primary-button-bg/10 px-4 py-2.5">
+ <div className="min-w-0 font-sans text-sm font-medium text-primary-button-bg">
{totalQuestions > 1 ? 'Questions' : currentQuestion.question}
</div>
{readOnly ? (
@@ -151,7 +184,7 @@ export function AskUserPrompt({
</div>
) : null}
{!readOnly && isMultiQuestion && (
- <div className="flex items-center gap-1">
+ <div className="flex shrink-0 items-center gap-1">
<IconButton
aria-label="Previous question"
variant="ghost"
@@ -177,26 +210,27 @@ export function AskUserPrompt({
)}
</div>
- <div className="flex flex-col gap-4 rounded-b-lg border border-t-0 border-border px-4 py-3">
- <div className="flex flex-col gap-3">
+ <div className="flex flex-col gap-2 bg-primary-bg px-4 py-3 border border-t-0 border-border">
+ <div className="flex min-w-0 flex-col gap-3">
{isMultiQuestion && (
<div className="font-sans text-xs font-medium text-text-primary">
{currentQuestion.question || 'What would you like to do?'}
</div>
)}
<div
- className="flex flex-col gap-3 overflow-visible"
+ className="grid min-w-0 grid-cols-[auto_minmax(0,1fr)] gap-x-2 gap-y-3 overflow-visible"
role={hasOptions ? 'radiogroup' : undefined}
aria-label={hasOptions ? currentQuestion.question || 'Answer options' : undefined}
onKeyDown={handleAnswerKeyDown}
>
{currentQuestion.options.map((opt, index) => {
const isSelected = currentAnswer.radioValue === opt;
+ const letter = askUserOptionLetter(index);
return (
<label
key={`${index}:${opt}`}
className={cn(
- 'flex w-fit items-start gap-x-2 overflow-visible',
+ 'col-span-2 grid grid-cols-subgrid items-center overflow-visible',
readOnly ? 'cursor-default' : 'cursor-pointer',
)}
>
@@ -207,11 +241,10 @@ export function AskUserPrompt({
name={`ask-user-question-option-${currentQuestion.id}`}
checked={isSelected}
onChange={() => handleOptionSelect(opt)}
- className="mt-0.5 accent-primary-button-bg"
+ className="sr-only"
/>
- <span className="min-w-0 font-sans text-[0.8125rem] font-medium leading-snug text-text-primary">
- {opt}
- </span>
+ <OptionLetterBadge letter={letter} selected={isSelected} />
+ <span className="min-w-0 font-sans text-sm font-medium text-text-primary">{opt}</span>
</label>
);
})}
@@ -219,7 +252,8 @@ export function AskUserPrompt({
{hasOptions ? (
<label
className={cn(
- 'flex items-start gap-x-2 overflow-visible',
+ // Top-align so the letter stays on the first line as the textarea grows.
+ 'col-span-2 grid grid-cols-subgrid items-start overflow-visible',
readOnly ? 'cursor-default' : 'cursor-pointer',
)}
>
@@ -230,12 +264,13 @@ export function AskUserPrompt({
name={`ask-user-question-option-${currentQuestion.id}`}
checked={isCustomSelected}
onChange={() => handleOptionSelect(ASK_USER_CUSTOM_OPTION)}
- className="mt-1 accent-primary-button-bg"
+ className="sr-only"
/>
- <div className="min-w-0 flex-1">{answerInput}</div>
+ <OptionLetterBadge letter={customOptionLetter} selected={isCustomSelected} className="mt-1.5" />
+ <div className="min-w-0">{answerInput}</div>
</label>
) : (
- answerInput
+ <div className="col-span-2 min-w-0">{answerInput}</div>
)}
</div>
</div>
@@ -244,7 +279,7 @@ export function AskUserPrompt({
<div
className={cn('flex items-center', {
'justify-between': isMultiQuestion,
- 'justify-start': !isMultiQuestion,
+ 'justify-end': !isMultiQuestion,
})}
>
{isMultiQuestion && isLastQuestion && !allQuestionsAnswered ? (
@@ -253,12 +288,24 @@ export function AskUserPrompt({
<span />
)}
{isNextStep ? (
- <Button.Primary type="button" size="small" onClick={goToNextQuestion} disabled={isSubmitDisabled}>
+ <Button.Primary
+ type="button"
+ size="small"
+ onClick={goToNextQuestion}
+ disabled={isSubmitDisabled}
+ className="bg-gray-850 text-white hover:bg-gray-850 dark:text-black"
+ >
Next
</Button.Primary>
) : (
- <Button.Primary type="button" size="small" onClick={onSubmit} disabled={isSubmitAllDisabled}>
- Submit
+ <Button.Primary
+ type="button"
+ size="small"
+ onClick={onSubmit}
+ disabled={isSubmitAllDisabled}
+ className="bg-gray-850 text-white hover:bg-gray-850 dark:text-black"
+ >
+ Continue
</Button.Primary>
)}
</div>
diff --git a/packages/trueforge-ui/src/atoms/adapters/McpAuthPromptAdapter.tsx b/packages/trueforge-ui/src/atoms/adapters/McpAuthPromptAdapter.tsx
index 6b4e799a1..27a7b1ade 100644
--- a/packages/trueforge-ui/src/atoms/adapters/McpAuthPromptAdapter.tsx
+++ b/packages/trueforge-ui/src/atoms/adapters/McpAuthPromptAdapter.tsx
@@ -36,16 +36,21 @@ export function McpAuthPrompt({
return (
<div
- className={cn('aui-mcp-auth-prompt mt-2 overflow-hidden rounded-lg border border-border', className)}
+ className={cn(
+ // Inset vs composer so stacked pause chrome matches the design (~1rem each side).
+ 'aui-mcp-auth-prompt mx-auto w-[calc(100%-2rem)] min-w-0 overflow-hidden rounded-lg',
+ className,
+ )}
data-testid={dataTestPrefix ? `${dataTestPrefix}-mcp-auth-card` : undefined}
>
- <div className="border-b border-primary-button-bg/30 bg-primary-button-bg/10 px-4 py-2">
+ <div className="border rounded-t-lg border-primary-button-bg/30 bg-primary-button-bg/10 px-4 py-2.5">
<div className="font-sans text-sm font-medium text-primary-button-bg">{title}</div>
</div>
- <div className="flex flex-col gap-3 bg-primary-bg px-4 py-3">
+ <div className="flex flex-col gap-3 bg-primary-bg px-4 py-3 border border-border border-t-0">
{servers.map(server => (
<div key={server.id} className="flex items-center justify-between gap-4">
<div className="flex min-w-0 items-center gap-1.5 text-sm">
+ <Icon name="mcp-server" size="0.875rem" className="shrink-0 text-text-secondary" />
<span className="shrink-0 font-medium text-text-secondary">MCP Server Name</span>
<span className="shrink-0 text-xs font-semibold text-text-secondary">:</span>
<span className="truncate font-sans font-medium text-text-primary">{server.name}</span>
@@ -56,7 +61,7 @@ export function McpAuthPrompt({
Connected
</span>
) : (
- <Button.Primary
+ <Button.Secondary
size="small"
disabled={readOnly}
onClick={() => onConnect(server.id)}
@@ -64,13 +69,18 @@ export function McpAuthPrompt({
>
Connect
<Icon name="external-link" size="0.75em" className="ml-1" />
- </Button.Primary>
+ </Button.Secondary>
)}
</div>
))}
{onContinue && (
- <div className="flex justify-end border-t border-border pt-2">
- <Button.Primary size="small" disabled={readOnly || continueLoading} onClick={onContinue}>
+ <div className="flex justify-end pt-1">
+ <Button.Primary
+ size="small"
+ disabled={readOnly || continueLoading}
+ onClick={onContinue}
+ className="bg-gray-850 text-white hover:bg-gray-850 dark:text-black"
+ >
{continueLoading ? <Icon name="loader" className="animate-spin" /> : null}
Continue
</Button.Primary>
diff --git a/packages/trueforge-ui/src/atoms/primitives/DropdownMenu.tsx b/packages/trueforge-ui/src/atoms/primitives/DropdownMenu.tsx
index 6d83da954..a35e814d7 100644
--- a/packages/trueforge-ui/src/atoms/primitives/DropdownMenu.tsx
+++ b/packages/trueforge-ui/src/atoms/primitives/DropdownMenu.tsx
@@ -151,7 +151,7 @@ export function DropdownMenu({
};
document.addEventListener('keydown', handler);
return () => document.removeEventListener('keydown', handler);
- }, [open]);
+ }, [open, setOpen]);
const triggerEl = React.isValidElement(trigger)
? React.cloneElement(trigger as React.ReactElement<Record<string, unknown>>, {
diff --git a/packages/trueforge-ui/src/containers/ComposerContainer.tsx b/packages/trueforge-ui/src/containers/ComposerContainer.tsx
index a8db0b14b..b6f98e7aa 100644
--- a/packages/trueforge-ui/src/containers/ComposerContainer.tsx
+++ b/packages/trueforge-ui/src/containers/ComposerContainer.tsx
@@ -2,7 +2,7 @@
import { ComposerPrimitive, useAui, useAuiState } from '@assistant-ui/react';
import { useTrueForgeAgentSpec, useTrueForgeCancel } from '@truefoundry/trueforge-assistant-ui-runtime';
-import { useRef } from 'react';
+import { useRef, type KeyboardEvent } from 'react';
import { DraftCatalogProvider } from '../atoms/draft/DraftCatalogProvider.js';
import { useComposerBusyState } from '../hooks/useComposerBusyState.js';
@@ -38,12 +38,10 @@ export function canSubmitComposer({
function ComposerBody({
placeholder,
- forceDisabled = false,
connectedToBanner = false,
}: {
placeholder: string;
- forceDisabled?: boolean;
- /** Flatten top radius/border so the approval banner sits flush above. */
+ /** Flatten top radius/border so pause chrome sits flush above. */
connectedToBanner?: boolean;
}) {
const ComposerShell = useSlot('ComposerShell');
@@ -51,6 +49,7 @@ function ComposerBody({
const shell = useOptionalShellMode();
const hasText = useAuiState(s => s.composer.text.trim().length > 0);
const hasAttachments = useAuiState(s => s.composer.attachments.length > 0);
+ const hasContent = hasText || hasAttachments;
const { agentSpec } = useTrueForgeAgentSpec();
// Named (immutable) agents use a server-side model; only draft/mutable composers pick one here.
const requiresModel = shell == null || (shell.mode.status === 'active' && shell.mode.isMutable);
@@ -59,13 +58,24 @@ function ComposerBody({
const canManageSession = useActiveSessionCanManage();
const cancel = useTrueForgeCancel();
const fileInputRef = useRef<HTMLInputElement>(null);
- const disabled = isBusy || forceDisabled || !canManageSession;
+ // Running/pause no longer lock the input — only session permissions do.
+ const disabled = !canManageSession;
const canSubmit = canSubmitComposer({ disabled, hasText, hasAttachments, requiresModel, hasModel });
const submit = () => {
if (!canSubmit) return;
+ // Do not cancelSession here; sendTurn detaches the prior client stream.
send(() => aui.composer().send());
};
+ // assistant-ui blocks Enter while the thread is running without queue support.
+ // Intercept before the primitive handler so Send can supersede a running turn.
+ const onInputKeyDown = (event: KeyboardEvent<HTMLTextAreaElement>) => {
+ if (event.key !== 'Enter' || event.shiftKey || event.nativeEvent.isComposing) return;
+ if (!canSubmit) return;
+ event.preventDefault();
+ submit();
+ };
+
return (
<>
<input
@@ -111,13 +121,15 @@ function ComposerBody({
placeholder={placeholder}
disabled={disabled}
submitMode="enter"
+ onKeyDown={onInputKeyDown}
aria-label="Message input"
className="text-text-primary placeholder:text-text-secondary/80 max-h-[10lh] min-h-10 w-full resize-none overflow-y-auto rounded-lg border-none bg-transparent px-1 py-1 text-base leading-normal shadow-none outline-none disabled:cursor-not-allowed"
/>
}
disabled={disabled}
canSubmit={canSubmit}
- isRunning={isBusy && !forceDisabled}
+ hasContent={hasContent}
+ isRunning={isBusy}
onSubmit={submit}
onCancel={
canManageSession
@@ -137,11 +149,9 @@ function ComposerBody({
function ComposerWithOptionalDraft({
placeholder,
- forceDisabled = false,
connectedToBanner = false,
}: {
placeholder: string;
- forceDisabled?: boolean;
connectedToBanner?: boolean;
}) {
const shell = useOptionalShellMode();
@@ -162,13 +172,13 @@ function ComposerWithOptionalDraft({
ComposerRightSection: usesDefaultRightSection ? DraftComposerRightSection : parentRightSection,
}}
>
- <ComposerBody placeholder={placeholder} forceDisabled={forceDisabled} connectedToBanner={connectedToBanner} />
+ <ComposerBody placeholder={placeholder} connectedToBanner={connectedToBanner} />
</SlotsProvider>
</DraftCatalogProvider>
);
}
- return <ComposerBody placeholder={placeholder} forceDisabled={forceDisabled} connectedToBanner={connectedToBanner} />;
+ return <ComposerBody placeholder={placeholder} connectedToBanner={connectedToBanner} />;
}
export function ComposerContainer({
@@ -177,23 +187,49 @@ export function ComposerContainer({
const pauseView = useComposerPauseView();
const canManageSession = useActiveSessionCanManage();
- if (pauseView.kind === 'mcp') {
- return <McpAuthContainer disabled={!canManageSession} />;
- }
- if (pauseView.kind === 'custom') {
- return <CustomActionContainer disabled={!canManageSession} />;
- }
- if (pauseView.kind === 'ask-user') {
- return <AskUserContainer disabled={!canManageSession} />;
+ const pauseChrome =
+ pauseView.kind === 'mcp' ? (
+ <McpAuthContainer disabled={!canManageSession} />
+ ) : pauseView.kind === 'custom' ? (
+ <CustomActionContainer disabled={!canManageSession} />
+ ) : pauseView.kind === 'ask-user' ? (
+ <AskUserContainer disabled={!canManageSession} />
+ ) : pauseView.kind === 'approval' ? (
+ <ApprovalNavContainer />
+ ) : null;
+
+ if (pauseChrome == null) {
+ return <ComposerWithOptionalDraft placeholder={placeholder} />;
}
+
+ // Approval sits flush on the composer. Ask User keeps a small gap. MCP tucks the
+ // composer over the card’s bottom edge (screenshot stack).
if (pauseView.kind === 'approval') {
return (
- <div data-slot="aui_composer-approval-pause" className="flex w-full flex-col">
- <ApprovalNavContainer />
- <ComposerWithOptionalDraft placeholder={placeholder} forceDisabled connectedToBanner />
+ <div data-slot="aui_composer-pause" data-pause-kind={pauseView.kind} className="flex w-full flex-col">
+ {pauseChrome}
+ <ComposerWithOptionalDraft placeholder={placeholder} connectedToBanner />
</div>
);
}
- return <ComposerWithOptionalDraft placeholder={placeholder} />;
+ if (pauseView.kind === 'mcp') {
+ return (
+ <div data-slot="aui_composer-pause" data-pause-kind={pauseView.kind} className="relative flex w-full flex-col">
+ <div className="pb-2">{pauseChrome}</div>
+ <div className="relative z-10 -mt-3">
+ <ComposerWithOptionalDraft placeholder={placeholder} />
+ </div>
+ </div>
+ );
+ }
+
+ return (
+ <div data-slot="aui_composer-pause" data-pause-kind={pauseView.kind} className="flex w-full flex-col">
+ {pauseChrome}
+ <div className="relative z-10 -mt-1">
+ <ComposerWithOptionalDraft placeholder={placeholder} />
+ </div>
+ </div>
+ );
}
diff --git a/packages/trueforge-ui/src/containers/TrueForgeUIShell.tsx b/packages/trueforge-ui/src/containers/TrueForgeUIShell.tsx
index 0b7043a18..c8993663c 100644
--- a/packages/trueforge-ui/src/containers/TrueForgeUIShell.tsx
+++ b/packages/trueforge-ui/src/containers/TrueForgeUIShell.tsx
@@ -62,7 +62,7 @@ export type TrueForgeUIProps = {
initialSettingsOpen?: boolean;
/**
* Host UI for pending client-side tools, keyed by tool name.
- * When a pending tool matches, the composer mounts that component instead of Ask User.
+ * When a pending tool matches, that component is shown above the composer instead of Ask User.
*/
customActionRenderers?: CustomActionRenderers;
/**
diff --git a/packages/trueforge-ui/src/styles.css b/packages/trueforge-ui/src/styles.css
index ea369e41b..350b0c359 100644
--- a/packages/trueforge-ui/src/styles.css
+++ b/packages/trueforge-ui/src/styles.css
@@ -44,6 +44,7 @@
--color-gray-700: #3f3f46;
--color-gray-750: #303036;
--color-gray-800: #27272a;
+ --color-gray-850: #18181b;
--color-gray-1000: #09090b;
--color-indigo-500: #6366f1;
--color-red-500: #ef4444;
@@ -115,6 +116,7 @@
--color-gray-700: #d4d4d8;
--color-gray-750: #dfdfe2;
--color-gray-800: #ececee;
+ --color-gray-850: #f5f5f7;
--color-gray-1000: #fdfdfd;
--sidebar-bg: var(--color-gray-200);
@@ -337,6 +339,7 @@
--color-gray-700: var(--color-gray-700);
--color-gray-750: var(--color-gray-750);
--color-gray-800: var(--color-gray-800);
+ --color-gray-850: var(--color-gray-850);
--color-gray-1000: var(--color-gray-1000);
--color-indigo-500: var(--color-indigo-500);
--color-red-500: var(--color-red-500);
diff --git a/packages/trueforge-ui/test/atoms/ComposerSections.test.tsx b/packages/trueforge-ui/test/atoms/ComposerSections.test.tsx
index 275582750..351fde4ed 100644
--- a/packages/trueforge-ui/test/atoms/ComposerSections.test.tsx
+++ b/packages/trueforge-ui/test/atoms/ComposerSections.test.tsx
@@ -35,7 +35,13 @@ describe('ComposerSendButton', () => {
it('disables submission until the composer can submit', () => {
const onSubmit = vi.fn();
const { rerender } = render(
- <ComposerSendButton disabled={false} canSubmit={false} isRunning={false} onSubmit={onSubmit} />,
+ <ComposerSendButton
+ disabled={false}
+ canSubmit={false}
+ isRunning={false}
+ hasContent={false}
+ onSubmit={onSubmit}
+ />,
);
const unavailableButton = screen.getByRole('button', { name: 'Send message' });
@@ -43,7 +49,7 @@ describe('ComposerSendButton', () => {
fireEvent.click(unavailableButton);
expect(onSubmit).not.toHaveBeenCalled();
- rerender(<ComposerSendButton disabled={false} canSubmit isRunning={false} onSubmit={onSubmit} />);
+ rerender(<ComposerSendButton disabled={false} canSubmit isRunning={false} hasContent onSubmit={onSubmit} />);
const availableButton = screen.getByRole('button', { name: 'Send message' });
expect(availableButton).toBeEnabled();
expect(availableButton).toHaveAttribute('title', 'Send message');
@@ -51,10 +57,19 @@ describe('ComposerSendButton', () => {
expect(onSubmit).toHaveBeenCalledOnce();
});
- it('switches to a cancel action while running', () => {
+ it('shows cancel only while running with an empty composer', () => {
const onSubmit = vi.fn();
const onCancel = vi.fn();
- render(<ComposerSendButton disabled={false} canSubmit isRunning onSubmit={onSubmit} onCancel={onCancel} />);
+ render(
+ <ComposerSendButton
+ disabled={false}
+ canSubmit={false}
+ isRunning
+ hasContent={false}
+ onSubmit={onSubmit}
+ onCancel={onCancel}
+ />,
+ );
const cancelButton = screen.getByRole('button', { name: 'Cancel' });
expect(cancelButton).toHaveTextContent('Cancel');
@@ -64,8 +79,37 @@ describe('ComposerSendButton', () => {
expect(onSubmit).not.toHaveBeenCalled();
});
+ it('shows send while running when the composer has content', () => {
+ const onSubmit = vi.fn();
+ const onCancel = vi.fn();
+ render(
+ <ComposerSendButton disabled={false} canSubmit isRunning hasContent onSubmit={onSubmit} onCancel={onCancel} />,
+ );
+
+ expect(screen.queryByRole('button', { name: 'Cancel' })).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole('button', { name: 'Send message' }));
+ expect(onSubmit).toHaveBeenCalledOnce();
+ expect(onCancel).not.toHaveBeenCalled();
+ });
+
+ it('shows disabled send while running with content that cannot submit', () => {
+ render(
+ <ComposerSendButton
+ disabled={false}
+ canSubmit={false}
+ isRunning
+ hasContent
+ onSubmit={() => {}}
+ onCancel={() => {}}
+ />,
+ );
+
+ expect(screen.queryByRole('button', { name: 'Cancel' })).not.toBeInTheDocument();
+ expect(screen.getByRole('button', { name: 'Send message' })).toBeDisabled();
+ });
+
it('disables cancellation when no cancel handler is supplied', () => {
- render(<ComposerSendButton disabled={false} canSubmit isRunning onSubmit={() => {}} />);
+ render(<ComposerSendButton disabled={false} canSubmit={false} isRunning hasContent={false} onSubmit={() => {}} />);
expect(screen.getByRole('button', { name: 'Cancel' })).toBeDisabled();
});
diff --git a/packages/trueforge-ui/test/atoms/ComposerShell.test.tsx b/packages/trueforge-ui/test/atoms/ComposerShell.test.tsx
index 25ba7ca9a..37a3ec6e2 100644
--- a/packages/trueforge-ui/test/atoms/ComposerShell.test.tsx
+++ b/packages/trueforge-ui/test/atoms/ComposerShell.test.tsx
@@ -13,6 +13,7 @@ describe('ComposerShell', () => {
attachments={<div>design.png</div>}
disabled={false}
canSubmit
+ hasContent
modelLabel="GPT 5"
modelIcon={<span aria-label="Model icon">M</span>}
connectorStatusLabel="Connected"
@@ -42,8 +43,9 @@ describe('ComposerShell', () => {
render(
<ComposerShell
input={<textarea aria-label="Message" />}
- disabled
+ disabled={false}
canSubmit={false}
+ hasContent={false}
isRunning
onSubmit={onSubmit}
onCancel={onCancel}
@@ -58,9 +60,34 @@ describe('ComposerShell', () => {
expect(onSubmit).not.toHaveBeenCalled();
});
+ it('shows send while running when hasContent is true', () => {
+ const onSubmit = vi.fn();
+ render(
+ <ComposerShell
+ input={<textarea aria-label="Message" />}
+ disabled={false}
+ canSubmit
+ hasContent
+ isRunning
+ onSubmit={onSubmit}
+ onCancel={() => {}}
+ />,
+ );
+
+ expect(screen.queryByRole('button', { name: 'Cancel' })).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole('button', { name: 'Send message' }));
+ expect(onSubmit).toHaveBeenCalledOnce();
+ });
+
it('omits optional composer chrome when labels and attachment handling are absent', () => {
render(
- <ComposerShell input={<input aria-label="Message" />} disabled={false} canSubmit={false} onSubmit={() => {}} />,
+ <ComposerShell
+ input={<input aria-label="Message" />}
+ disabled={false}
+ canSubmit={false}
+ hasContent={false}
+ onSubmit={() => {}}
+ />,
);
expect(screen.queryByRole('button', { name: 'Attach' })).not.toBeInTheDocument();
diff --git a/packages/trueforge-ui/test/atoms/adapters/AskUserPromptAdapter.test.tsx b/packages/trueforge-ui/test/atoms/adapters/AskUserPromptAdapter.test.tsx
index f4bf4c994..b7085b3f2 100644
--- a/packages/trueforge-ui/test/atoms/adapters/AskUserPromptAdapter.test.tsx
+++ b/packages/trueforge-ui/test/atoms/adapters/AskUserPromptAdapter.test.tsx
@@ -2,7 +2,12 @@
import { fireEvent, render, screen } from '@testing-library/react';
import { describe, expect, it, vi } from 'vitest';
-import { ASK_USER_CUSTOM_OPTION, AskUserPrompt, type Question } from '@/atoms/adapters/AskUserPromptAdapter.js';
+import {
+ ASK_USER_CUSTOM_OPTION,
+ AskUserPrompt,
+ askUserOptionLetter,
+ type Question,
+} from '@/atoms/adapters/AskUserPromptAdapter.js';
const firstQuestion: Question = {
id: 'deployment',
@@ -16,6 +21,14 @@ const secondQuestion: Question = {
options: ['US', 'EU'],
};
+describe('askUserOptionLetter', () => {
+ it('maps indices to A…Z then AA…', () => {
+ expect(askUserOptionLetter(0)).toBe('A');
+ expect(askUserOptionLetter(25)).toBe('Z');
+ expect(askUserOptionLetter(26)).toBe('AA');
+ });
+});
+
describe('AskUserPrompt', () => {
it('renders nothing without questions or answers, then summarizes answered questions', () => {
const onSubmit = vi.fn();
@@ -56,6 +69,9 @@ describe('AskUserPrompt', () => {
fireEvent.click(screen.getByRole('radio', { name: 'Immediately' }));
expect(onCurrentAnswerChange).toHaveBeenCalledWith('deployment', { radioValue: 'Immediately' });
+ expect(screen.getByText('A')).toBeInTheDocument();
+ expect(screen.getByText('B')).toBeInTheDocument();
+ expect(screen.getByText('C')).toBeInTheDocument();
const customAnswer = screen.getByRole('textbox', { name: 'Other (custom answer)' });
fireEvent.focus(customAnswer);
@@ -69,7 +85,7 @@ describe('AskUserPrompt', () => {
radioValue: ASK_USER_CUSTOM_OPTION,
});
- fireEvent.click(screen.getByRole('button', { name: 'Submit' }));
+ fireEvent.click(screen.getByRole('button', { name: 'Continue' }));
expect(onSubmit).toHaveBeenCalledOnce();
});
@@ -90,7 +106,7 @@ describe('AskUserPrompt', () => {
expect(screen.getByText('Which region?')).toBeInTheDocument();
expect(screen.getByText('Answer all questions to submit')).toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Next question' })).toBeDisabled();
- expect(screen.getByRole('button', { name: 'Submit' })).toBeDisabled();
+ expect(screen.getByRole('button', { name: 'Continue' })).toBeDisabled();
fireEvent.click(screen.getByRole('button', { name: 'Previous question' }));
expect(onCurrentQuestionIndexChange).toHaveBeenCalledWith(0);
@@ -174,7 +190,7 @@ describe('AskUserPrompt', () => {
expect(radio).toBeDisabled();
}
expect(screen.getByRole('textbox', { name: 'Other (custom answer)' })).toBeDisabled();
- expect(screen.queryByRole('button', { name: 'Submit' })).not.toBeInTheDocument();
+ expect(screen.queryByRole('button', { name: 'Continue' })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('radio', { name: 'Immediately' }));
expect(onCurrentAnswerChange).not.toHaveBeenCalled();
diff --git a/packages/trueforge-ui/test/containers/ComposerContainer.test.tsx b/packages/trueforge-ui/test/containers/ComposerContainer.test.tsx
index 01be1f138..052005f63 100644
--- a/packages/trueforge-ui/test/containers/ComposerContainer.test.tsx
+++ b/packages/trueforge-ui/test/containers/ComposerContainer.test.tsx
@@ -32,8 +32,10 @@ const approvalsState = vi.hoisted(() => ({
}>,
}));
+const cancelMock = vi.hoisted(() => vi.fn());
+
vi.mock('@truefoundry/trueforge-assistant-ui-runtime', () => ({
- useTrueForgeCancel: () => vi.fn(),
+ useTrueForgeCancel: () => cancelMock,
useTrueForgeToolResponses: () => toolResponsesState,
useTrueForgeApprovals: () => approvalsState,
useTrueForgeAgentSpec: () => ({ agentSpec: agentSpecState.agentSpec }),
@@ -102,6 +104,7 @@ describe('ComposerContainer', () => {
toolResponsesState.pending = [];
toolResponsesState.respond = vi.fn();
approvalsState.pending = [];
+ cancelMock.mockReset();
});
it('wraps the composer in an attachment dropzone by default', () => {
renderComposer();
@@ -212,7 +215,7 @@ describe('ComposerContainer', () => {
expect(screen.getByText('Custom right')).toBeInTheDocument();
});
- it('mounts a registered custom action renderer instead of the composer', () => {
+ it('keeps the composer enabled under a custom action renderer', () => {
toolResponsesState.pending = [{ toolCallId: 'tc-1', toolName: 'secret_select', args: { secrets: ['a'] } }];
render(
@@ -226,7 +229,8 @@ describe('ComposerContainer', () => {
);
expect(screen.getByRole('button', { name: 'Secret selector' })).toBeInTheDocument();
- expect(screen.queryByRole('textbox', { name: 'Message input' })).not.toBeInTheDocument();
+ expect(screen.getByRole('textbox', { name: 'Message input' })).toBeEnabled();
+ expect(document.querySelector('[data-slot="aui_composer-pause"]')).toHaveAttribute('data-pause-kind', 'custom');
fireEvent.click(screen.getByRole('button', { name: 'Secret selector' }));
expect(toolResponsesState.respond).toHaveBeenCalledWith({
@@ -235,7 +239,7 @@ describe('ComposerContainer', () => {
});
});
- it('shows the approval banner above a disabled composer while approvals are pending', () => {
+ it('keeps the composer enabled under the approval banner', () => {
approvalsState.pending = [
{
approvalId: 'appr-1',
@@ -257,7 +261,54 @@ describe('ComposerContainer', () => {
expect(screen.getByText('2 tools need your input')).toBeInTheDocument();
expect(screen.getByText('(1/2)')).toBeInTheDocument();
- expect(screen.getByRole('textbox', { name: 'Message input' })).toBeDisabled();
- expect(document.querySelector('[data-slot="aui_composer-approval-pause"]')).toBeInTheDocument();
+ expect(screen.getByRole('textbox', { name: 'Message input' })).toBeEnabled();
+ expect(document.querySelector('[data-slot="aui_composer-pause"]')).toHaveAttribute('data-pause-kind', 'approval');
+ });
+
+ it('shows cancel while running with an empty composer', () => {
+ render(
+ <RuntimeHarness messages={[]} isRunning>
+ <ComposerBusyProvider>
+ <ComposerContainer />
+ </ComposerBusyProvider>
+ </RuntimeHarness>,
+ );
+
+ expect(screen.getByRole('textbox', { name: 'Message input' })).toBeEnabled();
+ expect(screen.getByRole('button', { name: 'Cancel' })).toBeEnabled();
+ expect(screen.queryByRole('button', { name: 'Send message' })).not.toBeInTheDocument();
+ });
+
+ it('sends while running without calling cancel', async () => {
+ const onNew = vi.fn(async () => {});
+ render(
+ <RuntimeHarness messages={[]} isRunning onNew={onNew}>
+ <ComposerBusyProvider>
+ <ComposerContainer />
+ </ComposerBusyProvider>
+ </RuntimeHarness>,
+ );
+
+ const input = screen.getByRole<HTMLTextAreaElement>('textbox', { name: 'Message input' });
+ fireEvent.change(input, { target: { value: 'follow up' } });
+ expect(screen.getByRole('button', { name: 'Send message' })).toBeEnabled();
+ expect(screen.queryByRole('button', { name: 'Cancel' })).not.toBeInTheDocument();
+
+ fireEvent.keyDown(input, { key: 'Enter' });
+ await waitFor(() => expect(onNew).toHaveBeenCalledTimes(1));
+ expect(cancelMock).not.toHaveBeenCalled();
+ });
+
+ it('does not cancel on empty Enter while running', () => {
+ render(
+ <RuntimeHarness messages={[]} isRunning>
+ <ComposerBusyProvider>
+ <ComposerContainer />
+ </ComposerBusyProvider>
+ </RuntimeHarness>,
+ );
+
+ fireEvent.keyDown(screen.getByRole('textbox', { name: 'Message input' }), { key: 'Enter' });
+ expect(cancelMock).not.toHaveBeenCalled();
});
});