Skip to content

Automate browser based workflows with AI

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.ts
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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.ts
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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 {