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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 RequiredActireturn 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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"><IconButtonaria-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 (<labelkey={`${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 ? (<labelclassName={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({<divclassName={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.tsxindex 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.Secondarysize="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.tsxindex 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.tsxindex 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.tsxindex 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.cssindex 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.tsxindex 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.tsxindex 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+ hasContentmodelLabel="GPT 5"modelIcon={<span aria-label="Model icon">M</span>}connectorStatusLabel="Connected"@@ -42,8 +43,9 @@ describe('ComposerShell', () => {render(<ComposerShellinput={<textarea aria-label="Message" />}- disabled+ disabled={false}canSubmit={false}+ hasContent={false}isRunningonSubmit={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.tsxindex 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.tsxindex 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();});});