Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
SKY-10142: render turn narrative bubble (FE, 2/2) (#6231)
Andrew Neilson18b2f05822b4
diff --git a/skyvern-frontend/src/routes/workflows/copilot/NarrativeView.test.ts b/skyvern-frontend/src/routes/workflows/copilot/NarrativeView.test.tsnew file mode 100644index 000000000..b1dd9ed44--- /dev/null+++ b/skyvern-frontend/src/routes/workflows/copilot/NarrativeView.test.ts@@ -0,0 +1,290 @@+import { describe, expect, it } from "vitest";++import {+ EMPTY_NARRATIVE,+ TurnNarrativeState,+ applyNarrativeEvent,+} from "./narrativeState";+import {+ WorkflowCopilotBlockProgressUpdate,+ WorkflowCopilotDesignEndUpdate,+ WorkflowCopilotDesignStartUpdate,+ WorkflowCopilotStreamErrorUpdate,+ WorkflowCopilotStreamResponseUpdate,+ WorkflowCopilotTurnStartUpdate,+ WorkflowCopilotWorkflowDraftUpdate,+} from "./workflowCopilotTypes";++const turnStart = (+ overrides: Partial<WorkflowCopilotTurnStartUpdate> = {},+): WorkflowCopilotTurnStartUpdate => ({+ type: "turn_start",+ turn_id: "turn-1",+ turn_index: 0,+ mode: "build",+ timestamp: "2026-05-25T00:00:00Z",+ ...overrides,+});++const designStart = (): WorkflowCopilotDesignStartUpdate => ({+ type: "design_start",+ timestamp: "2026-05-25T00:00:01Z",+});++const designEnd = (): WorkflowCopilotDesignEndUpdate => ({+ type: "design_end",+ timestamp: "2026-05-25T00:00:02Z",+});++const workflowDraft = (+ overrides: Partial<WorkflowCopilotWorkflowDraftUpdate> = {},+): WorkflowCopilotWorkflowDraftUpdate => ({+ type: "workflow_draft",+ block_count: 2,+ block_labels: ["block_one", "block_two"],+ summary: "two block workflow",+ timestamp: "2026-05-25T00:00:03Z",+ ...overrides,+});++const blockProgress = (+ overrides: Partial<WorkflowCopilotBlockProgressUpdate> &+ Pick<WorkflowCopilotBlockProgressUpdate, "block_label" | "status">,+): WorkflowCopilotBlockProgressUpdate => ({+ type: "block_progress",+ workflow_run_block_id: `wrb_${overrides.block_label}`,+ block_type: "task",+ iteration: 0,+ timestamp: "2026-05-25T00:00:04Z",+ ...overrides,+});++const response = (+ overrides: Partial<WorkflowCopilotStreamResponseUpdate> = {},+): WorkflowCopilotStreamResponseUpdate => ({+ type: "response",+ workflow_copilot_chat_id: "chat-1",+ message: "Done.",+ response_time: "2026-05-25T00:00:05Z",+ proposal_disposition: "auto_applicable",+ ...overrides,+});++const errorUpdate = (+ overrides: Partial<WorkflowCopilotStreamErrorUpdate> = {},+): WorkflowCopilotStreamErrorUpdate => ({+ type: "error",+ error: "Something broke.",+ ...overrides,+});++describe("applyNarrativeEvent — turn_start", () => {+ it("seeds turnId/turnIndex/mode from an empty narrative", () => {+ const next = applyNarrativeEvent(EMPTY_NARRATIVE, turnStart());+ expect(next.turnId).toBe("turn-1");+ expect(next.turnIndex).toBe(0);+ expect(next.mode).toBe("build");+ expect(next.designStarted).toBe(false);+ expect(next.designEnded).toBe(false);+ expect(next.blocks).toEqual([]);+ expect(next.draft).toBeNull();+ expect(next.terminal).toBeNull();+ });++ it("falls back to 'unknown' mode when an empty mode is sent", () => {+ const next = applyNarrativeEvent(EMPTY_NARRATIVE, turnStart({ mode: "" }));+ expect(next.mode).toBe("unknown");+ });++ it("resets prior turn state when a new turn_start arrives mid-stream", () => {+ let s: TurnNarrativeState = EMPTY_NARRATIVE;+ s = applyNarrativeEvent(s, turnStart({ turn_id: "t1", turn_index: 0 }));+ s = applyNarrativeEvent(s, designStart());+ s = applyNarrativeEvent(s, workflowDraft());+ s = applyNarrativeEvent(+ s,+ blockProgress({ block_label: "block_one", status: "running" }),+ );+ s = applyNarrativeEvent(+ s,+ turnStart({ turn_id: "t2", turn_index: 1, mode: "edit" }),+ );++ expect(s).toEqual({+ ...EMPTY_NARRATIVE,+ turnId: "t2",+ turnIndex: 1,+ mode: "edit",+ });+ });+});++describe("applyNarrativeEvent — design phase", () => {+ it("sets designStarted on design_start", () => {+ const s = applyNarrativeEvent(EMPTY_NARRATIVE, designStart());+ expect(s.designStarted).toBe(true);+ expect(s.designEnded).toBe(false);+ });++ it("sets designEnded on design_end", () => {+ let s = applyNarrativeEvent(EMPTY_NARRATIVE, designStart());+ s = applyNarrativeEvent(s, designEnd());+ expect(s.designStarted).toBe(true);+ expect(s.designEnded).toBe(true);+ });++ it("captures workflow_draft summary, count, and labels", () => {+ const s = applyNarrativeEvent(EMPTY_NARRATIVE, workflowDraft());+ expect(s.draft).toEqual({+ blockCount: 2,+ blockLabels: ["block_one", "block_two"],+ summary: "two block workflow",+ });+ });++ it("last workflow_draft wins on multi-iteration designs", () => {+ let s = applyNarrativeEvent(EMPTY_NARRATIVE, workflowDraft());+ s = applyNarrativeEvent(+ s,+ workflowDraft({+ block_count: 3,+ block_labels: ["block_one", "block_two", "block_three"],+ summary: "expanded workflow",+ }),+ );+ expect(s.draft).toEqual({+ blockCount: 3,+ blockLabels: ["block_one", "block_two", "block_three"],+ summary: "expanded workflow",+ });+ });+});++describe("applyNarrativeEvent — block_progress", () => {+ it("appends a new block entry on first sighting", () => {+ const s = applyNarrativeEvent(+ EMPTY_NARRATIVE,+ blockProgress({ block_label: "block_one", status: "running" }),+ );+ expect(s.blocks).toEqual([+ {+ workflowRunBlockId: "wrb_block_one",+ label: "block_one",+ blockType: "task",+ state: "running",+ lastSeenIteration: 0,+ },+ ]);+ });++ it("upserts in place when the same workflow_run_block_id is seen again", () => {+ let s = applyNarrativeEvent(+ EMPTY_NARRATIVE,+ blockProgress({ block_label: "block_one", status: "running" }),+ );+ s = applyNarrativeEvent(+ s,+ blockProgress({+ block_label: "block_one",+ status: "completed",+ iteration: 2,+ block_type: "task",+ }),+ );+ expect(s.blocks).toHaveLength(1);+ expect(s.blocks[0]).toMatchObject({+ label: "block_one",+ state: "completed",+ lastSeenIteration: 2,+ });+ });++ it("keeps loop iterations as distinct rows when they share a block_label", () => {+ let s = applyNarrativeEvent(+ EMPTY_NARRATIVE,+ blockProgress({+ block_label: "iterate_url",+ status: "running",+ workflow_run_block_id: "wrb_1",+ }),+ );+ s = applyNarrativeEvent(+ s,+ blockProgress({+ block_label: "iterate_url",+ status: "running",+ workflow_run_block_id: "wrb_2",+ }),+ );+ expect(s.blocks).toHaveLength(2);+ expect(s.blocks.map((b) => b.workflowRunBlockId)).toEqual([+ "wrb_1",+ "wrb_2",+ ]);+ });++ it.each([+ ["failed", "failed"],+ ["terminated", "failed"],+ ["timed_out", "failed"],+ ["canceled", "failed"],+ ["skipped", "skipped"],+ ["queued", "queued"],+ ["something_new", "queued"],+ ])("maps raw status %p to UI state %p", (raw, expected) => {+ const s = applyNarrativeEvent(+ EMPTY_NARRATIVE,+ blockProgress({ block_label: "b", status: raw }),+ );+ expect(s.blocks[0]?.state).toBe(expected);+ });+});++describe("applyNarrativeEvent — terminal", () => {+ it("response closes designEnded and uses narrative_summary when present", () => {+ let s = applyNarrativeEvent(EMPTY_NARRATIVE, designStart());+ s = applyNarrativeEvent(+ s,+ response({+ message: "full message text",+ narrative_summary: "one-liner",+ }),+ );+ expect(s.designEnded).toBe(true);+ expect(s.terminal).toBe("response");+ expect(s.terminalMessage).toBe("full message text");+ expect(s.narrativeSummary).toBe("one-liner");+ });++ it("response falls back to message when narrative_summary is null", () => {+ const s = applyNarrativeEvent(+ EMPTY_NARRATIVE,+ response({ message: "full text", narrative_summary: null }),+ );+ expect(s.narrativeSummary).toBe("full text");+ });++ it("response closes design even when design_end was never emitted (CORR-3)", () => {+ let s = applyNarrativeEvent(EMPTY_NARRATIVE, designStart());+ expect(s.designEnded).toBe(false);+ s = applyNarrativeEvent(s, response());+ expect(s.designEnded).toBe(true);+ });++ it("error closes designEnded and leaves narrativeSummary null when absent", () => {+ let s = applyNarrativeEvent(EMPTY_NARRATIVE, designStart());+ s = applyNarrativeEvent(s, errorUpdate({ narrative_summary: null }));+ expect(s.designEnded).toBe(true);+ expect(s.terminal).toBe("error");+ expect(s.terminalMessage).toBe("Something broke.");+ expect(s.narrativeSummary).toBeNull();+ });++ it("error uses narrative_summary when populated", () => {+ const s = applyNarrativeEvent(+ EMPTY_NARRATIVE,+ errorUpdate({ narrative_summary: "refused: too risky" }),+ );+ expect(s.narrativeSummary).toBe("refused: too risky");+ });+});diff --git a/skyvern-frontend/src/routes/workflows/copilot/NarrativeView.tsx b/skyvern-frontend/src/routes/workflows/copilot/NarrativeView.tsxnew file mode 100644index 000000000..c33853a5c--- /dev/null+++ b/skyvern-frontend/src/routes/workflows/copilot/NarrativeView.tsx@@ -0,0 +1,148 @@+import { BlockState, BlockUIState, TurnNarrativeState } from "./narrativeState";++const MODE_CHIP_UNKNOWN = {+ label: "THINKING",+ classes: "bg-slate-700/50 text-slate-200 border-slate-600",+};++const MODE_CHIP: Record<string, { label: string; classes: string }> = {+ build: {+ label: "BUILDING",+ classes: "bg-blue-900/40 text-blue-200 border-blue-700/60",+ },+ edit: {+ label: "EDITING",+ classes: "bg-indigo-900/40 text-indigo-200 border-indigo-700/60",+ },+ docs_answer: {+ label: "ANSWERING",+ classes: "bg-emerald-900/40 text-emerald-200 border-emerald-700/60",+ },+ clarify: {+ label: "CLARIFYING",+ classes: "bg-amber-900/40 text-amber-200 border-amber-700/60",+ },+ diagnose: {+ label: "DIAGNOSING",+ classes: "bg-orange-900/40 text-orange-200 border-orange-700/60",+ },+ draft_only: {+ label: "DRAFTING",+ classes: "bg-cyan-900/40 text-cyan-200 border-cyan-700/60",+ },+ refuse: {+ label: "REFUSING",+ classes: "bg-rose-900/40 text-rose-200 border-rose-700/60",+ },+ unknown: MODE_CHIP_UNKNOWN,+};++const BLOCK_STATE_CHIP: Record<+ BlockUIState,+ { label: string; classes: string }+> = {+ queued: {+ label: "queued",+ classes: "bg-slate-800 text-slate-400 border-slate-700",+ },+ running: {+ label: "running",+ classes: "bg-blue-900/40 text-blue-200 border-blue-700/60",+ },+ completed: {+ label: "done",+ classes: "bg-emerald-900/40 text-emerald-200 border-emerald-700/60",+ },+ failed: {+ label: "failed",+ classes: "bg-rose-900/40 text-rose-200 border-rose-700/60",+ },+ skipped: {+ label: "skipped",+ classes: "bg-slate-800 text-slate-500 border-slate-700",+ },+};++function ModeChip({ mode }: { mode: string }) {+ const cfg = MODE_CHIP[mode] ?? MODE_CHIP_UNKNOWN;+ return (+ <span+ className={`inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-[10px] font-semibold uppercase tracking-wide ${cfg.classes}`}+ >+ {cfg.label}+ </span>+ );+}++function BlockCard({ block }: { block: BlockState }) {+ const stateChip = BLOCK_STATE_CHIP[block.state];+ return (+ <div className="flex items-center justify-between gap-2 rounded border border-slate-700/60 bg-slate-900/40 px-2 py-1 text-xs">+ <div className="flex min-w-0 flex-1 items-center gap-2">+ <span className="truncate font-mono text-slate-200">{block.label}</span>+ <span className="shrink-0 text-[10px] text-slate-500">+ {block.blockType}+ </span>+ </div>+ <span+ className={`shrink-0 rounded-full border px-1.5 py-px text-[9px] font-bold uppercase tracking-wide ${stateChip.classes}`}+ >+ {stateChip.label}+ </span>+ </div>+ );+}++export function NarrativeView({ turn }: { turn: TurnNarrativeState }) {+ const hasBlocks = turn.blocks.length > 0;+ const showDesignSpinner = turn.designStarted && !turn.designEnded;+ const showWaiting = turn.designEnded && !hasBlocks && !turn.terminal;++ return (+ <div className="flex flex-col gap-2 text-sm text-slate-200">+ <div className="flex items-center gap-2">+ <ModeChip mode={turn.mode} />+ {turn.draft ? (+ <span className="text-[11px] text-slate-400">+ Drafted workflow with {turn.draft.blockCount} block+ {turn.draft.blockCount === 1 ? "" : "s"}+ {turn.draft.blockLabels.length > 0 ? (+ <>+ :{" "}+ <span className="font-mono text-slate-300">+ {turn.draft.blockLabels.join(", ")}+ </span>+ </>+ ) : null}+ </span>+ ) : null}+ </div>++ {showDesignSpinner ? (+ <div className="text-xs italic text-slate-400">+ Designing the workflow…+ </div>+ ) : null}++ {hasBlocks ? (+ <div className="flex flex-col gap-1">+ {turn.blocks.map((b) => (+ <BlockCard key={b.workflowRunBlockId} block={b} />+ ))}+ </div>+ ) : null}++ {showWaiting ? (+ <div className="text-xs italic text-slate-500">+ Waiting for the first block to start…+ </div>+ ) : null}++ {turn.terminal && turn.narrativeSummary ? (+ <div className="rounded border border-slate-700/40 bg-slate-900/30 px-2 py-1 text-xs text-slate-300">+ {turn.narrativeSummary}+ </div>+ ) : null}+ </div>+ );+}diff --git a/skyvern-frontend/src/routes/workflows/copilot/WorkflowCopilotChat.tsx b/skyvern-frontend/src/routes/workflows/copilot/WorkflowCopilotChat.tsxindex cdb92554d..1306ba3f5 100644--- a/skyvern-frontend/src/routes/workflows/copilot/WorkflowCopilotChat.tsx+++ b/skyvern-frontend/src/routes/workflows/copilot/WorkflowCopilotChat.tsx@@ -20,6 +20,8 @@ import { cn } from "@/util/utils";import {WorkflowCopilotCancelRequest,WorkflowCopilotChatHistoryResponse,+ WorkflowCopilotDesignEndUpdate,+ WorkflowCopilotDesignStartUpdate,WorkflowCopilotProcessingUpdate,WorkflowCopilotStreamErrorUpdate,WorkflowCopilotStreamResponseUpdate,@@ -28,23 +30,24 @@ import {WorkflowCopilotCondensingUpdate,WorkflowCopilotNarrationUpdate,WorkflowCopilotBlockProgressUpdate,+ WorkflowCopilotTurnStartUpdate,+ WorkflowCopilotWorkflowDraftUpdate,WorkflowCopilotChatSender,WorkflowCopilotChatRequest,WorkflowCopilotClearProposedWorkflowRequest,WorkflowCopilotApplyProposedWorkflowRequest,} from "./workflowCopilotTypes";-import {- ToolActivity,- applyBlockProgress,- applyToolCall,- applyToolResult,- getActivityDotClass,-} from "./toolActivity";import {shouldQueuePromptForLiveBrowser,shouldWaitForLiveBrowser,} from "./browserReadiness";import { shouldAutoApplyWorkflowResponse } from "./proposalDisposition";+import { NarrativeView } from "./NarrativeView";+import {+ EMPTY_NARRATIVE,+ TurnNarrativeState,+ applyNarrativeEvent,+} from "./narrativeState";interface ChatMessage {id: string;@@ -71,26 +74,11 @@ type WorkflowCopilotSsePayload =| WorkflowCopilotToolResultUpdate| WorkflowCopilotCondensingUpdate| WorkflowCopilotNarrationUpdate- | WorkflowCopilotBlockProgressUpdate;--const TOOL_DISPLAY_NAMES: Record<string, string> = {- update_workflow: "Updating agent",- update_and_run_blocks: "Updating & running blocks",- list_credentials: "Listing credentials",- get_block_schema: "Looking up block schema",- validate_block: "Validating block",- run_blocks_and_collect_debug: "Running blocks",- get_run_results: "Getting run results",- get_browser_screenshot: "Taking screenshot",- navigate_browser: "Navigating browser",- evaluate: "Inspecting the page",- click: "Clicking on the page",- type_text: "Filling a field",- scroll: "Scrolling",- console_messages: "Reading console",- select_option: "Selecting option",- press_key: "Pressing key",-};+ | WorkflowCopilotBlockProgressUpdate+ | WorkflowCopilotTurnStartUpdate+ | WorkflowCopilotDesignStartUpdate+ | WorkflowCopilotDesignEndUpdate+ | WorkflowCopilotWorkflowDraftUpdate;const formatChatTimestamp = (value: string) => {let normalizedValue = value.replace(/\.(\d{3})\d*/, ".$1");@@ -221,9 +209,8 @@ export function WorkflowCopilotChat({const [inputValue, setInputValue] = useState("");const [isLoading, setIsLoading] = useState(false);const [queuedPrompt, setQueuedPrompt] = useState<QueuedPrompt | null>(null);- const [processingStatus, setProcessingStatus] = useState<string>("");- const [latestNarration, setLatestNarration] = useState<string>("");- const [toolActivity, setToolActivity] = useState<ToolActivity[]>([]);+ const [narrative, setNarrative] =+ useState<TurnNarrativeState>(EMPTY_NARRATIVE);const [isLoadingHistory, setIsLoadingHistory] = useState(false);const streamingAbortController = useRef<AbortController | null>(null);const pendingMessageId = useRef<string | null>(null);@@ -323,6 +310,7 @@ export function WorkflowCopilotChat({setWorkflowCopilotChatId(null);setProposedWorkflow(null);setAutoAccept(false);+ setNarrative(EMPTY_NARRATIVE);hasScrolledOnLoad.current = false;};@@ -535,6 +523,7 @@ export function WorkflowCopilotChat({setWorkflowCopilotChatId(null);setProposedWorkflow(null);setAutoAccept(false);+ setNarrative(EMPTY_NARRATIVE);historyLoadedForRef.current = null;return;}@@ -597,9 +586,6 @@ export function WorkflowCopilotChat({pendingCancelToken.current = null;if (!cancelToken) return;- setProcessingStatus("Cancelling...");- setLatestNarration("");- setToolActivity([]);cancelInFlightController.current = controllerAtCancel;const appendCancelledBubble = () => {@@ -612,6 +598,8 @@ export function WorkflowCopilotChat({timestamp: new Date().toISOString(),},]);+ // Otherwise the bubble freezes mid-state next to the Cancelled message.+ setNarrative(EMPTY_NARRATIVE);};try {@@ -638,7 +626,7 @@ export function WorkflowCopilotChat({controllerAtCancel.abort();appendCancelledBubble();}- }, [credentialGetter, setToolActivity]);+ }, [credentialGetter]);const cancelQueuedPrompt = useCallback(() => {if (!queuedPrompt) {@@ -746,9 +734,6 @@ export function WorkflowCopilotChat({setInputValue("");}setIsLoading(true);- setProcessingStatus("Starting...");- setLatestNarration("");- setToolActivity([]);const abortController = new AbortController();streamingAbortController.current?.abort();@@ -832,10 +817,6 @@ export function WorkflowCopilotChat({const handleProcessingUpdate = (payload: WorkflowCopilotProcessingUpdate,) => {- if (payload.status) {- setProcessingStatus(payload.status);- }-const pendingId = pendingMessageId.current;if (!pendingId || !payload.timestamp) {return;@@ -909,33 +890,33 @@ export function WorkflowCopilotChat({case "processing_update":handleProcessingUpdate(payload);return false;+ // Legacy in-flight signals — the narrative bubble derives its+ // state from turn_start/design_*/block_progress/workflow_draft+ // instead, so these are intentionally dropped here.case "tool_call":- setProcessingStatus(- TOOL_DISPLAY_NAMES[payload.tool_name] ??- payload.tool_name + "...",- );- setToolActivity((prev) => applyToolCall(prev, payload));- return false;case "tool_result":- setToolActivity((prev) => applyToolResult(prev, payload));- return false;case "condensing":- if (payload.status === "started") {- setProcessingStatus("Condensing context...");- }- return false;case "narration":- if (payload.narration) {- setLatestNarration(payload.narration);- }return false;case "block_progress":- setToolActivity((prev) => applyBlockProgress(prev, payload));+ setNarrative((prev) => applyNarrativeEvent(prev, payload));+ return false;+ case "turn_start":+ setNarrative(() =>+ applyNarrativeEvent(EMPTY_NARRATIVE, payload),+ );+ return false;+ case "design_start":+ case "design_end":+ case "workflow_draft":+ setNarrative((prev) => applyNarrativeEvent(prev, payload));return false;case "response":+ setNarrative((prev) => applyNarrativeEvent(prev, payload));handleResponse(payload);return true;case "error":+ setNarrative((prev) => applyNarrativeEvent(prev, payload));handleError(payload);return true;default:@@ -969,9 +950,6 @@ export function WorkflowCopilotChat({pendingMessageId.current = null;pendingCancelToken.current = null;setIsLoading(false);- setProcessingStatus("");- setLatestNarration("");- setToolActivity([]);}},[@@ -1371,61 +1349,17 @@ export function WorkflowCopilotChat({/>);})}- {(isLoading || isQueuedPromptWaiting) && (- <div className="flex items-start gap-3">- <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-neutral-950 text-xs font-bold text-white dark:bg-neutral-100 dark:text-neutral-950">+ {narrative.turnId !== null && (+ <div+ className="flex items-start gap-3"+ role="status"+ aria-live="polite"+ >+ <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-blue-600 text-xs font-bold text-white">AI</div>- <div className="flex-1 rounded-lg bg-neutral-100 p-3 dark:bg-neutral-900">- <div className="flex items-center gap-2 text-sm text-neutral-700 dark:text-neutral-300">- <ReloadIcon className="h-4 w-4 animate-spin" />- <span>- {isQueuedPromptWaiting- ? queuedPromptWaitingStatus- : latestNarration || processingStatus || "Processing..."}- </span>- </div>- {isQueuedPromptWaiting ? (- <div className="mt-2 text-xs text-neutral-500">- Copilot will start automatically once the browser is ready.- </div>- ) : null}- {!isQueuedPromptWaiting && toolActivity.length > 0 && (- <div className="mt-2 space-y-1">- {toolActivity.map((activity) => {- const isRetrySuccess =- activity.status === "success" &&- activity.linkedRecovery === true;- const tooltip = activity.detail ?? activity.summary;- const displayName =- TOOL_DISPLAY_NAMES[activity.tool_name] ??- activity.tool_name;- const containerClass = cn(- "flex items-start gap-1.5 text-xs text-neutral-500 dark:text-neutral-400",- activity.linkedRecovery &&- "border-l border-amber-400/40 pl-2",- );- return (- <div- key={activity.tool_call_id}- className={containerClass}- >- <span- className={`mt-1.5 inline-block h-1.5 w-1.5 shrink-0 rounded-full ${getActivityDotClass(activity)}`}- />- <span- className="line-clamp-2 min-w-0 flex-1"- title={tooltip}- >- {isRetrySuccess ? "↻ " : ""}- {displayName}- {activity.summary ? ` — ${activity.summary}` : ""}- </span>- </div>- );- })}- </div>- )}+ <div className="flex-1 rounded-lg bg-slate-800 p-3">+ <NarrativeView turn={narrative} /></div></div>)}diff --git a/skyvern-frontend/src/routes/workflows/copilot/narrativeState.ts b/skyvern-frontend/src/routes/workflows/copilot/narrativeState.tsnew file mode 100644index 000000000..4b0140630--- /dev/null+++ b/skyvern-frontend/src/routes/workflows/copilot/narrativeState.ts@@ -0,0 +1,172 @@+// Pure reducer + types for the workflow copilot turn-narrative bubble. Kept+// separate from NarrativeView.tsx so Vite Fast Refresh can hot-reload the+// component without re-evaluating reducer state, and so the reducer can be+// exercised under vitest without a JSX runtime.++import {+ WorkflowCopilotBlockProgressUpdate,+ WorkflowCopilotDesignEndUpdate,+ WorkflowCopilotDesignStartUpdate,+ WorkflowCopilotStreamErrorUpdate,+ WorkflowCopilotStreamResponseUpdate,+ WorkflowCopilotTurnStartUpdate,+ WorkflowCopilotWorkflowDraftUpdate,+} from "./workflowCopilotTypes";++// Discriminated union of every event the reducer below consumes. The bubble+// only renders state derived from these payloads — it does not subscribe to+// tool_call / tool_result / processing_update / narration / condensing.+export type NarrativeEvent =+ | WorkflowCopilotTurnStartUpdate+ | WorkflowCopilotDesignStartUpdate+ | WorkflowCopilotDesignEndUpdate+ | WorkflowCopilotWorkflowDraftUpdate+ | WorkflowCopilotBlockProgressUpdate+ | WorkflowCopilotStreamResponseUpdate+ | WorkflowCopilotStreamErrorUpdate;++// Block lifecycle states as observed via block_progress. The bubble groups+// failed-style states (failed, terminated, timed_out, canceled) under one+// chip and treats `skipped` as a separate neutral state.+export type BlockUIState =+ | "queued"+ | "running"+ | "completed"+ | "failed"+ | "skipped";++export interface BlockState {+ workflowRunBlockId: string;+ label: string;+ blockType: string;+ state: BlockUIState;+ lastSeenIteration: number;+}++export interface TurnNarrativeState {+ turnId: string | null;+ turnIndex: number | null;+ mode: string;+ designStarted: boolean;+ designEnded: boolean;+ draft: {+ blockCount: number;+ blockLabels: string[];+ summary: string | null;+ } | null;+ blocks: BlockState[];+ terminal: "response" | "error" | null;+ terminalMessage: string | null;+ narrativeSummary: string | null;+}++export const EMPTY_NARRATIVE: TurnNarrativeState = Object.freeze({+ turnId: null,+ turnIndex: null,+ mode: "unknown",+ designStarted: false,+ designEnded: false,+ draft: null,+ blocks: [],+ terminal: null,+ terminalMessage: null,+ narrativeSummary: null,+}) as TurnNarrativeState;++export function mapBlockStatus(raw: string): BlockUIState {+ switch (raw) {+ case "running":+ return "running";+ case "completed":+ return "completed";+ case "failed":+ case "terminated":+ case "timed_out":+ case "canceled":+ return "failed";+ case "skipped":+ return "skipped";+ case "queued":+ default:+ return "queued";+ }+}++export function applyNarrativeEvent(+ prev: TurnNarrativeState,+ event: NarrativeEvent,+): TurnNarrativeState {+ switch (event.type) {+ case "turn_start":+ return {+ ...EMPTY_NARRATIVE,+ turnId: event.turn_id,+ turnIndex: event.turn_index,+ mode: event.mode || "unknown",+ };++ case "design_start":+ return { ...prev, designStarted: true };++ case "design_end":+ return { ...prev, designEnded: true };++ case "workflow_draft":+ return {+ ...prev,+ draft: {+ blockCount: event.block_count,+ blockLabels: event.block_labels,+ summary: event.summary,+ },+ };++ case "block_progress": {+ const incomingState = mapBlockStatus(event.status);+ // Key on workflow_run_block_id, not block_label, so loop iterations+ // (e.g. a for_loop body) render as distinct rows.+ const existing = prev.blocks.findIndex(+ (b) => b.workflowRunBlockId === event.workflow_run_block_id,+ );+ const nextEntry: BlockState = {+ workflowRunBlockId: event.workflow_run_block_id,+ label: event.block_label,+ blockType: event.block_type,+ state: incomingState,+ lastSeenIteration: event.iteration,+ };+ if (existing >= 0) {+ const nextBlocks = prev.blocks.slice();+ nextBlocks[existing] = nextEntry;+ return { ...prev, blocks: nextBlocks };+ }+ return { ...prev, blocks: [...prev.blocks, nextEntry] };+ }++ case "response":+ // Close the design phase on terminal regardless of whether design_end+ // arrived — a refusal turn can emit design_start via the first tool+ // call and then exit without persisting a workflow.+ return {+ ...prev,+ designEnded: true,+ terminal: "response",+ terminalMessage: event.message,+ narrativeSummary: event.narrative_summary ?? event.message,+ };++ case "error":+ return {+ ...prev,+ designEnded: true,+ terminal: "error",+ terminalMessage: event.error,+ narrativeSummary: event.narrative_summary ?? null,+ };++ default:+ // Exhaustiveness guard — any new NarrativeEvent variant added to the+ // union must extend this switch.+ return prev;+ }+}diff --git a/skyvern-frontend/src/routes/workflows/copilot/toolActivity.test.ts b/skyvern-frontend/src/routes/workflows/copilot/toolActivity.test.tsdeleted file mode 100644index c4739cdd2..000000000--- a/skyvern-frontend/src/routes/workflows/copilot/toolActivity.test.ts+++ /dev/null@@ -1,480 +0,0 @@-import { describe, expect, it } from "vitest";--import {- ToolActivity,- applyBlockProgress,- applyToolCall,- applyToolResult,-} from "./toolActivity";-import {- WorkflowCopilotBlockProgressUpdate,- WorkflowCopilotToolCallUpdate,- WorkflowCopilotToolResultUpdate,-} from "./workflowCopilotTypes";--const make = (- overrides: Partial<ToolActivity> & Pick<ToolActivity, "tool_call_id">,-): ToolActivity => ({- tool_name: "update_workflow",- status: "running",- ...overrides,-});--const result = (- overrides: Partial<WorkflowCopilotToolResultUpdate> &- Pick<WorkflowCopilotToolResultUpdate, "tool_call_id" | "success">,-): WorkflowCopilotToolResultUpdate => ({- type: "tool_result",- tool_name: "update_workflow",- summary: "",- iteration: 0,- ...overrides,-});--const call = (- overrides: Partial<WorkflowCopilotToolCallUpdate> &- Pick<WorkflowCopilotToolCallUpdate, "tool_call_id">,-): WorkflowCopilotToolCallUpdate => ({- type: "tool_call",- tool_name: "update_workflow",- tool_input: {},- iteration: 0,- ...overrides,-});--describe("applyToolResult", () => {- it("returns prev unchanged when tool_call_id has no matching entry", () => {- const prev = [make({ tool_call_id: "c1" })];- const next = applyToolResult(- prev,- result({ tool_call_id: "missing", success: true, summary: "ok" }),- );- expect(next).toBe(prev);- });-- it("flips a running entry to error and copies detail", () => {- const prev = [make({ tool_call_id: "c1" })];- const next = applyToolResult(- prev,- result({- tool_call_id: "c1",- success: false,- summary: "Failed: short",- detail: "long sanitized error text for tooltip",- }),- );- expect(next[0]!).toMatchObject({- status: "error",- summary: "Failed: short",- detail: "long sanitized error text for tooltip",- });- });-- it("normalizes payload null detail to undefined on the activity", () => {- const prev = [make({ tool_call_id: "c1" })];- const next = applyToolResult(- prev,- result({- tool_call_id: "c1",- success: false,- summary: "x",- detail: null,- }),- );- expect(next[0]!.detail).toBeUndefined();- });-- it("links an adjacent failure to the next same-tool success", () => {- const prev: ToolActivity[] = [- make({- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- summary: "Failed: bad yaml",- }),- make({- tool_name: "update_workflow",- tool_call_id: "c2",- status: "running",- }),- ];- const next = applyToolResult(- prev,- result({- tool_call_id: "c2",- success: true,- summary: "Workflow updated",- }),- );- expect(next[0]!).toMatchObject({- status: "error",- recovered: true,- linkedRecovery: true,- });- expect(next[1]!).toMatchObject({- status: "success",- linkedRecovery: true,- });- });-- it("recovers but does NOT link a non-adjacent prior failure", () => {- const prev: ToolActivity[] = [- make({- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- }),- make({- tool_name: "get_block_schema",- tool_call_id: "c2",- status: "success",- }),- make({- tool_name: "update_workflow",- tool_call_id: "c3",- status: "running",- }),- ];- const next = applyToolResult(- prev,- result({ tool_call_id: "c3", success: true, summary: "ok" }),- );- expect(next[0]!).toMatchObject({- status: "error",- recovered: true,- });- expect(next[0]!.linkedRecovery).toBeFalsy();- expect(next[2]!.linkedRecovery).toBeFalsy();- expect(next[2]!.status).toBe("success");- expect(next[1]!).toEqual(prev[1]!);- });-- it("recovers ALL prior unrecovered same-tool failures, not just one", () => {- const prev: ToolActivity[] = [- make({- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- }),- make({- tool_name: "update_workflow",- tool_call_id: "c2",- status: "error",- }),- make({- tool_name: "update_workflow",- tool_call_id: "c3",- status: "running",- }),- ];- const next = applyToolResult(- prev,- result({ tool_call_id: "c3", success: true, summary: "ok" }),- );- expect(next[0]!.recovered).toBe(true);- expect(next[1]!.recovered).toBe(true);- expect(next[0]!.linkedRecovery).toBeFalsy();- expect(next[1]!.linkedRecovery).toBe(true);- expect(next[2]!).toMatchObject({- linkedRecovery: true,- });- });-- it("does not re-recover a failure that an earlier intermediate success already resolved", () => {- const prev: ToolActivity[] = [- {- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- recovered: true,- linkedRecovery: true,- },- {- tool_name: "update_workflow",- tool_call_id: "c2",- status: "success",- linkedRecovery: true,- },- {- tool_name: "update_workflow",- tool_call_id: "c3",- status: "error",- },- {- tool_name: "update_workflow",- tool_call_id: "c4",- status: "running",- },- ];- const next = applyToolResult(- prev,- result({ tool_call_id: "c4", success: true, summary: "ok" }),- );- expect(next[0]).toBe(prev[0]);- expect(next[1]).toBe(prev[1]);- expect(next[2]!).toMatchObject({- recovered: true,- linkedRecovery: true,- });- expect(next[3]!).toMatchObject({- status: "success",- linkedRecovery: true,- });- });-- it("links the adjacent retry success after applyToolCall has already marked the prior failure recovered", () => {- // Live flow: tool_call appends running and clears the pulse on the- // prior failure (recovered=true). Then tool_result success arrives and- // must still draw the connector on the adjacent pair.- let state: ToolActivity[] = [- {- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- },- ];- state = applyToolCall(- state,- call({ tool_name: "update_workflow", tool_call_id: "c2" }),- );- expect(state[0]!.recovered).toBe(true);- expect(state[0]!.linkedRecovery).toBeUndefined();-- state = applyToolResult(- state,- result({ tool_call_id: "c2", success: true, summary: "ok" }),- );- expect(state[0]!).toMatchObject({- status: "error",- recovered: true,- linkedRecovery: true,- });- expect(state[1]!).toMatchObject({- status: "success",- linkedRecovery: true,- });- });-- it("does not link to a different tool's failure", () => {- const prev: ToolActivity[] = [- make({- tool_name: "click",- tool_call_id: "c1",- status: "error",- }),- make({- tool_name: "update_workflow",- tool_call_id: "c2",- status: "running",- }),- ];- const next = applyToolResult(- prev,- result({- tool_name: "update_workflow",- tool_call_id: "c2",- success: true,- summary: "ok",- }),- );- // Different tool: not linked, but the click failure stays unrecovered- // until a tool_call event clears it (handled by applyToolCall).- expect(next[0]!.recovered).toBeUndefined();- expect(next[1]!.linkedRecovery).toBeFalsy();- });-});--describe("applyToolCall", () => {- it("appends a running entry", () => {- const prev: ToolActivity[] = [];- const next = applyToolCall(- prev,- call({ tool_name: "update_workflow", tool_call_id: "c1" }),- );- expect(next).toHaveLength(1);- expect(next[0]!).toMatchObject({- tool_name: "update_workflow",- tool_call_id: "c1",- status: "running",- });- });-- it("stops the pulse on prior unrecovered failures of any tool", () => {- const prev: ToolActivity[] = [- {- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- },- {- tool_name: "evaluate",- tool_call_id: "c2",- status: "success",- },- ];- const next = applyToolCall(- prev,- call({ tool_name: "evaluate", tool_call_id: "c3" }),- );- expect(next[0]!.recovered).toBe(true);- expect(next[0]!.linkedRecovery).toBeUndefined();- expect(next[1]).toEqual(prev[1]);- expect(next[2]!).toMatchObject({- tool_call_id: "c3",- status: "running",- });- });-- it("leaves already-recovered failures untouched", () => {- const prior: ToolActivity = {- tool_name: "update_workflow",- tool_call_id: "c1",- status: "error",- recovered: true,- linkedRecovery: true,- };- const prev: ToolActivity[] = [prior];- const next = applyToolCall(- prev,- call({ tool_name: "evaluate", tool_call_id: "c2" }),- );- expect(next[0]!).toBe(prior);- });-});--const block = (- overrides: Partial<WorkflowCopilotBlockProgressUpdate> &- Pick<- WorkflowCopilotBlockProgressUpdate,- "workflow_run_block_id" | "status"- >,-): WorkflowCopilotBlockProgressUpdate => ({- type: "block_progress",- block_label: `label_${overrides.workflow_run_block_id}`,- block_type: "navigation",- iteration: 0,- timestamp: "2026-04-30T07:00:00Z",- ...overrides,-});--describe("applyBlockProgress", () => {- it("appends a running entry on first sighting", () => {- const next = applyBlockProgress(- [],- block({- workflow_run_block_id: "wrb_1",- status: "running",- block_label: "step_navigate",- }),- );- expect(next).toHaveLength(1);- expect(next[0]!).toMatchObject({- tool_name: "Block step_navigate",- tool_call_id: "block:wrb_1",- status: "running",- summary: "running",- });- });-- it("updates the same row by workflow_run_block_id when status changes", () => {- const prev = applyBlockProgress(- [],- block({- workflow_run_block_id: "wrb_1",- status: "running",- block_label: "step_navigate",- }),- );- const next = applyBlockProgress(- prev,- block({- workflow_run_block_id: "wrb_1",- status: "completed",- block_label: "step_navigate",- }),- );- expect(next).toHaveLength(1);- expect(next[0]!).toMatchObject({- tool_call_id: "block:wrb_1",- status: "success",- summary: "completed",- });- });-- it("treats two blocks with the same label as separate rows when ids differ", () => {- let state: ToolActivity[] = [];- state = applyBlockProgress(- state,- block({- workflow_run_block_id: "wrb_1",- status: "running",- block_label: "iterate_url",- }),- );- state = applyBlockProgress(- state,- block({- workflow_run_block_id: "wrb_2",- status: "running",- block_label: "iterate_url",- }),- );- expect(state).toHaveLength(2);- expect(state[0]!.tool_call_id).toBe("block:wrb_1");- expect(state[1]!.tool_call_id).toBe("block:wrb_2");- });-- it("maps failed/terminated/timed_out/canceled to error status", () => {- for (const status of [- "failed",- "terminated",- "timed_out",- "canceled",- ] as const) {- const next = applyBlockProgress(- [],- block({ workflow_run_block_id: `wrb_${status}`, status }),- );- expect(next[0]!.status).toBe("error");- expect(next[0]!.summary).toBe(status);- }- });-- it("maps skipped to success status (benign-completed)", () => {- const next = applyBlockProgress(- [],- block({ workflow_run_block_id: "wrb_1", status: "skipped" }),- );- expect(next[0]!.status).toBe("success");- });-- it("ignores unknown status values without mutating the list", () => {- const prev: ToolActivity[] = [- { tool_name: "x", tool_call_id: "x", status: "running" },- ];- const next = applyBlockProgress(- prev,- block({ workflow_run_block_id: "wrb_1", status: "weird_state" }),- );- expect(next).toBe(prev);- });-- it("does not collide with regular tool_call rows that have different tool_call_ids", () => {- let state: ToolActivity[] = [];- state = applyToolCall(- state,- call({ tool_call_id: "c1", tool_name: "update_and_run_blocks" }),- );- state = applyBlockProgress(- state,- block({- workflow_run_block_id: "wrb_1",- status: "running",- block_label: "step_navigate",- }),- );- expect(state).toHaveLength(2);- expect(state[0]!.tool_call_id).toBe("c1");- expect(state[1]!.tool_call_id).toBe("block:wrb_1");- });-});diff --git a/skyvern-frontend/src/routes/workflows/copilot/toolActivity.ts b/skyvern-frontend/src/routes/workflows/copilot/toolActivity.tsdeleted file mode 100644index 1c875511c..000000000--- a/skyvern-frontend/src/routes/workflows/copilot/toolActivity.ts+++ /dev/null@@ -1,183 +0,0 @@-import {- WorkflowCopilotBlockProgressUpdate,- WorkflowCopilotToolCallUpdate,- WorkflowCopilotToolResultUpdate,-} from "./workflowCopilotTypes";--export interface ToolActivity {- tool_name: string;- tool_call_id: string;- status: "running" | "success" | "error";- summary?: string;- detail?: string;- recovered?: boolean;- // True for the adjacent failure/success pair only — gates the visual- // connector (left border + ↻). Non-adjacent retries get amber dot only.- linkedRecovery?: boolean;-}--export function getActivityDotClass(activity: ToolActivity): string {- if (activity.status === "running") {- return "animate-pulse bg-neutral-400 dark:bg-neutral-500";- }- if (activity.status === "success") {- return "bg-green-400";- }- return activity.recovered ? "bg-amber-400" : "animate-pulse bg-amber-400";-}--// Append a new running entry and stop the pulse on any prior unrecovered-// failure — once the agent has started anything new, the previous failure-// is no longer the live event.-export function applyToolCall(- prev: ToolActivity[],- payload: WorkflowCopilotToolCallUpdate,-): ToolActivity[] {- const cleared = prev.map((item) =>- item.status === "error" && !item.recovered- ? { ...item, recovered: true }- : item,- );- return [- ...cleared,- {- tool_name: payload.tool_name,- tool_call_id: payload.tool_call_id,- status: "running" as const,- },- ];-}--// On success, marks every prior unrecovered same-tool error as `recovered`;-// only the immediately adjacent failure also gets `linkedRecovery` so the-// visual connector renders for that pair alone.-export function applyToolResult(- prev: ToolActivity[],- payload: WorkflowCopilotToolResultUpdate,-): ToolActivity[] {- const idx = prev.findIndex(- (item) => item.tool_call_id === payload.tool_call_id,- );- if (idx === -1) {- return prev;- }-- // Wire shape allows null on optional fields; UI shape uses undefined.- const detail = payload.detail ?? undefined;-- if (!payload.success) {- return prev.map((item, i) =>- i === idx- ? {- ...item,- status: "error" as const,- summary: payload.summary,- detail,- }- : item,- );- }-- // Adjacency for the visual link is independent of `recovered` — by the- // time this fires, applyToolCall has already marked the prior failure- // recovered, but the connector still belongs on the immediately adjacent- // pair regardless.- const adjacent = prev[idx - 1];- const linkedFailureIdx =- adjacent &&- adjacent.status === "error" &&- adjacent.tool_name === payload.tool_name- ? idx - 1- : -1;-- // Backwards scan covers the isolated case (applyToolResult invoked- // without applyToolCall having run first, e.g. unit tests, replay).- // In the live flow these entries are already recovered=true.- const recoveredIndices = new Set<number>();- for (let i = idx - 1; i >= 0; i -= 1) {- const candidate = prev[i];- if (- candidate &&- candidate.status === "error" &&- candidate.tool_name === payload.tool_name &&- !candidate.recovered- ) {- recoveredIndices.add(i);- }- }-- return prev.map((item, i) => {- if (i === idx) {- return {- ...item,- status: "success" as const,- summary: payload.summary,- detail,- linkedRecovery: linkedFailureIdx !== -1,- };- }- if (i === linkedFailureIdx) {- return { ...item, recovered: true, linkedRecovery: true };- }- if (recoveredIndices.has(i)) {- return { ...item, recovered: true };- }- return item;- });-}--// Same status taxonomy as the backend BlockStatus enum.-const BLOCK_FAILED_STATUSES = new Set([- "failed",- "terminated",- "timed_out",- "canceled",-]);-const BLOCK_COMPLETED_STATUSES = new Set(["completed", "skipped"]);--function blockStatusToActivityStatus(- status: string,-): "running" | "success" | "error" | null {- if (status === "running") return "running";- if (BLOCK_COMPLETED_STATUSES.has(status)) return "success";- if (BLOCK_FAILED_STATUSES.has(status)) return "error";- return null;-}--// Per-block lifecycle update from inside long-running tool calls. Keyed by-// `workflow_run_block_id` so duplicate labels in the same run never collide.-export function applyBlockProgress(- prev: ToolActivity[],- payload: WorkflowCopilotBlockProgressUpdate,-): ToolActivity[] {- const nextStatus = blockStatusToActivityStatus(payload.status);- if (nextStatus === null) return prev;-- const tool_call_id = `block:${payload.workflow_run_block_id}`;- const tool_name = `Block ${payload.block_label}`;- const summary = payload.status;-- const idx = prev.findIndex((item) => item.tool_call_id === tool_call_id);- if (idx === -1) {- return [- ...prev,- {- tool_name,- tool_call_id,- status: nextStatus,- summary,- },- ];- }-- return prev.map((item, i) =>- i === idx- ? {- ...item,- tool_name,- status: nextStatus,- summary,- }- : item,- );-}diff --git a/skyvern-frontend/src/routes/workflows/copilot/workflowCopilotTypes.ts b/skyvern-frontend/src/routes/workflows/copilot/workflowCopilotTypes.tsindex b9089585b..86d284857 100644--- a/skyvern-frontend/src/routes/workflows/copilot/workflowCopilotTypes.ts+++ b/skyvern-frontend/src/routes/workflows/copilot/workflowCopilotTypes.ts@@ -74,7 +74,11 @@ export type WorkflowCopilotStreamMessageType =| "tool_result"| "condensing"| "narration"- | "block_progress";+ | "block_progress"+ | "turn_start"+ | "design_start"+ | "design_end"+ | "workflow_draft";export interface WorkflowCopilotProcessingUpdate {type: "processing_update";@@ -91,11 +95,46 @@ export interface WorkflowCopilotStreamResponseUpdate {proposal_disposition: ProposalDisposition;// Cancel forces explicit review.cancelled?: boolean;+ // Optional so the FE tolerates an older backend that does not emit the+ // turn-narrative envelope.+ turn_id?: string | null;+ narrative_summary?: string | null;}export interface WorkflowCopilotStreamErrorUpdate {type: "error";error: string;+ turn_id?: string | null;+ narrative_summary?: string | null;+}++export interface WorkflowCopilotTurnStartUpdate {+ type: "turn_start";+ turn_id: string;+ turn_index: number;+ mode: string;+ timestamp: string;+}++export interface WorkflowCopilotDesignStartUpdate {+ type: "design_start";+ timestamp: string;+}++export interface WorkflowCopilotDesignEndUpdate {+ type: "design_end";+ timestamp: string;+}++// Summary-only payload — the full workflow definition is delivered via the+// terminal response's updated_workflow or via the chat's proposed_workflow+// field, not here.+export interface WorkflowCopilotWorkflowDraftUpdate {+ type: "workflow_draft";+ block_count: number;+ block_labels: string[];+ summary: string | null;+ timestamp: string;}export interface WorkflowCopilotToolCallUpdate {