@superblocksteam/vite-plugin-file-sync 2.0.41-next.5 → 2.0.41-next.51

package/dist/ai-service/state-machine/handlers/llm-generating.js

@@ -1,9 +1,8 @@
-import { hasToolCall, smoothStream } from "ai";
-import ddTrace from "dd-trace";
+import { hasToolCall, smoothStream, } from "ai";
 import { getLogger } from "../../../util/logger.js";
 import { buildTools } from "../../agent/tools.js";
 import { getAppState, getAvailableComponents, processStreamChunk, } from "../../agent/utils.js";
-import { tracedStreamText, traceWorkflow } from "../../util/ddog-llmobs.js";
+import { tracedStreamText } from "../../llmobs/helpers.js";
 import { processLLMConfig } from "../../util/llm-config-utils.js";
 import { AGENT_PLANNED, APP_RUNTIME_UPDATED_WITHOUT_EDITS, V3_AGENT_FINISHED, } from "../clark-fsm.js";
 import { cacheBreakpointHelper } from "../helpers/cache-breakpoint.js";
@@ -40,6 +39,37 @@ function formatSummaryForAgents(latestSummary) {
     }
     return parts.length > 0 ? parts.join("\n\n") : null;
 }
+const buildUserPromptContentWithParts = (userPrompt, attachments) => {
+    return [
+        { type: "text", text: userPrompt },
+        ...attachments.map((attachment) => {
+            if (attachment.type === "image") {
+                return {
+                    type: attachment.type,
+                    image: attachment.image,
+                };
+            }
+            else {
+                throw "Unsupported attachment type";
+            }
+        }),
+    ];
+};
+const buildUserMessage = (userPrompt, promptContext, cache) => {
+    if (promptContext?.attachments?.length) {
+        return {
+            role: "user",
+            content: buildUserPromptContentWithParts(userPrompt, promptContext.attachments),
+            providerOptions: cache(),
+        };
+    }
+    else {
+        return {
+            role: "user",
+            content: userPrompt,
+        };
+    }
+};
 export const doLLMGenerating = (clark, services) => {
     const { chatSessionStore } = services;
     const transitionTo = transitionFrom(clark);
@@ -67,7 +97,7 @@ export const doLLMGenerating = (clark, services) => {
                     {
                         role: "user",
                         content: `<available_components>\nHere is a list of all the components that are available in the application.\n\`\`\`json\n${JSON.stringify(availableComponents)}\n\`\`\`\n</available_components>`,
-                        ...nextCacheBreakpoint(),
+                        providerOptions: nextCacheBreakpoint(),
                     },
                     ...(latestSummary
                         ? [
@@ -89,16 +119,13 @@ export const doLLMGenerating = (clark, services) => {
                             },
                         ]
                         : []),
-                    {
-                        role: "user",
-                        content: userPrompt,
-                    },
+                    buildUserMessage(userPrompt, promptContext, nextCacheBreakpoint),
                 ];
                 const model = services.llmProvider.modelForClassification("broad_edit");
                 // Process LLM configuration up front so we can log it once at the top
                 const llmConfig = clark.context.llmConfig;
                 const disabledTools = clark.context.llmConfig?.disabledTools;
-                const { headers, thinkingEnabled, thinkingBudgetTokens, interleavedThinking, } = processLLMConfig(llmConfig, 5000, // default budget tokens
+                const { headers, thinkingEnabled, thinkingBudgetTokens, interleavedThinking, providerOptions, } = processLLMConfig(llmConfig, 5000, // default budget tokens
                 `LLM Generating (model=${model.modelId}, disabledTools=${disabledTools?.length ? disabledTools.join(",") : "none"})`);
                 const conversationId = Date.now();
                 const startTimestamp = new Date().toISOString();
@@ -124,277 +151,258 @@ export const doLLMGenerating = (clark, services) => {
                 });
                 // Note: Input token count will be logged once LLM call begins
                 const tools = buildTools(clark, services, promptContext, logRef, disabledTools);
-                await traceWorkflow("doLLMGenerating", async () => {
-                    let stepCount = 0;
-                    const llmConfig = clark.context.llmConfig;
-                    const { providerOptions, headers } = processLLMConfig(llmConfig, 5000, `LLM Generating (model=${model.modelId}, disabledTools=${disabledTools?.length ? disabledTools.join(",") : "none"})`);
-                    // Track cumulative token usage across all steps
-                    let totalInputTokens = 0;
-                    let totalOutputTokens = 0;
-                    let totalCachedTokens = 0;
-                    services.clarkProfiler.startLLMWaiting({
-                        messages: messages,
-                        model: model.modelId,
-                    });
-                    let firstTokenReceived = false;
-                    let thinkingSpanActive = false;
-                    let textSpanActive = false;
-                    const allReasoningDeltas = [];
-                    let currentStepReasoningDeltas = [];
-                    let currentStepTextDeltas = [];
-                    const build = tracedStreamText({
-                        abortSignal: abortController?.signal,
-                        model,
-                        providerOptions,
-                        headers,
-                        experimental_transform: [smoothStream({ chunking: "line" })],
-                        messages,
-                        tools,
-                        prepareStep: breakpointAwarePrepareStep({
-                            getInputTokens: () => totalInputTokens,
-                            onAddBreakpoint: (stepNumber) => {
-                                logRef.content += `[CACHE] Added breakpoint at step ${stepNumber}, ${totalInputTokens} input tokens\n\n`;
-                            },
-                        }),
-                        stopWhen: hasToolCall("build_finalize"),
-                        onChunk: (chunkData) => {
-                            if (!firstTokenReceived) {
-                                firstTokenReceived = true;
-                                services.clarkProfiler.startLLMStreaming({
-                                    firstChunk: chunkData.chunk.type === "text-delta"
-                                        ? chunkData.chunk.text
-                                        : `[${chunkData.chunk.type}]`,
-                                });
-                            }
-                            if (chunkData.chunk.type === "reasoning-delta") {
-                                const thinkingTrack = "thinking";
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .createTrack(thinkingTrack, "AI Thinking/Reasoning", "llm");
-                                allReasoningDeltas.push(chunkData.chunk.text);
-                                currentStepReasoningDeltas.push(chunkData.chunk.text);
-                                if (!thinkingSpanActive) {
-                                    thinkingSpanActive = true;
-                                    services.clarkProfiler
-                                        .getProfiler()
-                                        .startFrame(`Thinking Step ${stepCount + 1}`, thinkingTrack, {
-                                        stepNumber: stepCount + 1,
-                                        chunkType: chunkData.chunk.type,
-                                    });
-                                }
-                            }
-                            if (chunkData.chunk.type === "text-delta") {
-                                const textTrack = "text_generation";
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .createTrack(textTrack, "Text Generation", "llm");
-                                currentStepTextDeltas.push(chunkData.chunk.text);
-                                if (!textSpanActive) {
-                                    textSpanActive = true;
-                                    services.clarkProfiler
-                                        .getProfiler()
-                                        .startFrame(`Text Generation Step ${stepCount + 1}`, textTrack, {
-                                        stepNumber: stepCount + 1,
-                                        firstTextDelta: chunkData.chunk.text.slice(0, 50) +
-                                            (chunkData.chunk.text.length > 50 ? "..." : ""),
-                                    });
-                                }
-                            }
+                let stepCount = 0;
+                // Track cumulative token usage across all steps
+                let totalInputTokens = 0;
+                let totalOutputTokens = 0;
+                let totalCachedTokens = 0;
+                services.clarkProfiler.startLLMWaiting({
+                    messages: messages,
+                    model: model.modelId,
+                });
+                let firstTokenReceived = false;
+                let thinkingSpanActive = false;
+                let textSpanActive = false;
+                const allReasoningDeltas = [];
+                let currentStepReasoningDeltas = [];
+                let currentStepTextDeltas = [];
+                const build = tracedStreamText({
+                    abortSignal: abortController?.signal,
+                    model,
+                    providerOptions,
+                    headers,
+                    experimental_transform: [smoothStream({ chunking: "line" })],
+                    messages,
+                    tools,
+                    prepareStep: breakpointAwarePrepareStep({
+                        getInputTokens: () => totalInputTokens,
+                        onAddBreakpoint: (stepNumber) => {
+                            logRef.content += `[CACHE] Added breakpoint at step ${stepNumber}, ${totalInputTokens} input tokens\n\n`;
                         },
-                        onStepFinish: async (step) => {
-                            stepCount++;
-                            const stepTimestamp = new Date().toISOString();
-                            logRef.content += `--- OUTPUT STEP ${stepCount} [${stepTimestamp}] ---\n`;
-                            if (step.reasoning && thinkingSpanActive) {
-                                const thinkingTrack = "thinking";
+                    }),
+                    stopWhen: hasToolCall("build_finalize"),
+                    onChunk: (chunkData) => {
+                        if (!firstTokenReceived) {
+                            firstTokenReceived = true;
+                            services.clarkProfiler.startLLMStreaming({
+                                firstChunk: chunkData.chunk.type === "text-delta"
+                                    ? chunkData.chunk.text
+                                    : `[${chunkData.chunk.type}]`,
+                            });
+                        }
+                        if (chunkData.chunk.type === "reasoning-delta") {
+                            const thinkingTrack = "thinking";
+                            services.clarkProfiler
+                                .getProfiler()
+                                .createTrack(thinkingTrack, "AI Thinking/Reasoning", "llm");
+                            allReasoningDeltas.push(chunkData.chunk.text);
+                            currentStepReasoningDeltas.push(chunkData.chunk.text);
+                            if (!thinkingSpanActive) {
+                                thinkingSpanActive = true;
                                 services.clarkProfiler
                                     .getProfiler()
-                                    .updateActiveFrameArgs(thinkingTrack, {
-                                    completeReasoningText: currentStepReasoningDeltas.join(" "),
-                                    reasoningLength: step.reasoning.length,
-                                    stepComplete: true,
+                                    .startFrame(`Thinking Step ${stepCount + 1}`, thinkingTrack, {
+                                    stepNumber: stepCount + 1,
+                                    chunkType: chunkData.chunk.type,
                                 });
-                                services.clarkProfiler.getProfiler().endFrame(thinkingTrack);
-                                thinkingSpanActive = false;
-                                currentStepReasoningDeltas = [];
-                            }
-                            // Log token usage for this step and accumulate totals
-                            if (step.usage) {
-                                const stepInputTokens = step.usage.inputTokens ?? 0;
-                                const stepOutputTokens = step.usage.outputTokens ?? 0;
-                                const stepCachedTokens = step.usage.cachedInputTokens ?? 0;
-                                // Accumulate totals
-                                totalInputTokens += stepInputTokens;
-                                totalOutputTokens += stepOutputTokens;
-                                totalCachedTokens += stepCachedTokens;
-                                logRef.content += `[TOKEN USAGE] Input: ${stepInputTokens}, Output: ${stepOutputTokens}, Total: ${step.usage.totalTokens ?? 0}`;
-                                if (stepCachedTokens) {
-                                    logRef.content += `, Cached: ${stepCachedTokens}`;
-                                }
-                                logRef.content += `\n`;
-                            }
-                            if (step.reasoning) {
-                                const reasoningLines = [
-                                    "[REASONING]",
-                                    ...step.reasoning.map(({ text }) => text),
-                                    "",
-                                ];
-                                logRef.content += reasoningLines.join("\n");
                             }
-                            if (step.text && textSpanActive) {
-                                const textTrack = "text_generation";
+                        }
+                        if (chunkData.chunk.type === "text-delta") {
+                            const textTrack = "text_generation";
+                            services.clarkProfiler
+                                .getProfiler()
+                                .createTrack(textTrack, "Text Generation", "llm");
+                            currentStepTextDeltas.push(chunkData.chunk.text);
+                            if (!textSpanActive) {
+                                textSpanActive = true;
                                 services.clarkProfiler
                                     .getProfiler()
-                                    .updateActiveFrameArgs(textTrack, {
-                                    completeTextContent: currentStepTextDeltas.join(""),
-                                    finalText: step.text,
-                                    textLength: step.text.length,
-                                    stepComplete: true,
+                                    .startFrame(`Text Generation Step ${stepCount + 1}`, textTrack, {
+                                    stepNumber: stepCount + 1,
+                                    firstTextDelta: chunkData.chunk.text.slice(0, 50) +
+                                        (chunkData.chunk.text.length > 50 ? "..." : ""),
                                 });
-                                services.clarkProfiler.getProfiler().endFrame(textTrack);
-                                textSpanActive = false;
-                                currentStepTextDeltas = [];
                             }
-                            if (step.text) {
-                                logRef.content += `[ASSISTANT TEXT] ${step.text}\n`;
-                                void services.chatSessionStore.recordAssistant({
-                                    type: "text",
-                                    text: step.text,
-                                });
-                            }
-                            const toolsCalled = step.content
-                                .filter((c) => c.type === "tool-result")
-                                .map((c) => ({
-                                toolName: c.toolName,
-                                input: JSON.stringify(c.input),
-                                output: JSON.stringify(c.output, null, 2),
-                            }));
-                            if (toolsCalled.length > 0) {
-                                logRef.content += `[TOOLS CALLED]\n`;
-                                toolsCalled.forEach((tool, idx) => {
-                                    logRef.content += `  Tool ${idx + 1}: ${tool.toolName}\n`;
-                                    logRef.content += `    Input: ${tool.input}\n`;
-                                    logRef.content += `    Output: ${tool.output}\n`;
-                                });
-                                toolsCalled.forEach((tool, idx) => {
-                                    let parsedInput, parsedOutput;
-                                    try {
-                                        parsedInput = JSON.parse(tool.input);
-                                    }
-                                    catch {
-                                        parsedInput = tool.input;
-                                    }
-                                    try {
-                                        parsedOutput = JSON.parse(tool.output);
-                                    }
-                                    catch {
-                                        parsedOutput = tool.output;
-                                    }
-                                    services.clarkProfiler
-                                        .getProfiler()
-                                        .addInstantEvent(`Tool Call: ${tool.toolName}`, "llm", {
-                                        step: stepCount,
-                                        toolIndex: idx + 1,
-                                        toolName: tool.toolName,
-                                        input: parsedInput,
-                                        output: parsedOutput,
-                                        inputSize: tool.input.length,
-                                        outputSize: tool.output.length,
-                                    });
-                                });
+                        }
+                    },
+                    onStepFinish: async (step) => {
+                        stepCount++;
+                        const stepTimestamp = new Date().toISOString();
+                        logRef.content += `--- OUTPUT STEP ${stepCount} [${stepTimestamp}] ---\n`;
+                        if (step.reasoning && thinkingSpanActive) {
+                            const thinkingTrack = "thinking";
+                            services.clarkProfiler
+                                .getProfiler()
+                                .updateActiveFrameArgs(thinkingTrack, {
+                                completeReasoningText: currentStepReasoningDeltas.join(" "),
+                                reasoningLength: step.reasoning.length,
+                                stepComplete: true,
+                            });
+                            services.clarkProfiler.getProfiler().endFrame(thinkingTrack);
+                            thinkingSpanActive = false;
+                            currentStepReasoningDeltas = [];
+                        }
+                        // Log token usage for this step and accumulate totals
+                        if (step.usage) {
+                            const stepInputTokens = step.usage.inputTokens ?? 0;
+                            const stepOutputTokens = step.usage.outputTokens ?? 0;
+                            const stepCachedTokens = step.usage.cachedInputTokens ?? 0;
+                            // Accumulate totals
+                            totalInputTokens += stepInputTokens;
+                            totalOutputTokens += stepOutputTokens;
+                            totalCachedTokens += stepCachedTokens;
+                            logRef.content += `[TOKEN USAGE] Input: ${stepInputTokens}, Output: ${stepOutputTokens}, Total: ${step.usage.totalTokens ?? 0}`;
+                            if (stepCachedTokens) {
+                                logRef.content += `, Cached: ${stepCachedTokens}`;
                             }
                             logRef.content += `\n`;
-                        },
-                    });
-                    for await (const chunk of build.fullStream) {
-                        await processStreamChunk(chunk, clark, services.chatSessionStore, logRef);
-                    }
-                    if (firstTokenReceived) {
-                        services.clarkProfiler.endFrame();
-                    }
+                        }
+                        if (step.reasoning) {
+                            const reasoningLines = [
+                                "[REASONING]",
+                                ...step.reasoning.map(({ text }) => text),
+                                "",
+                            ];
+                            logRef.content += reasoningLines.join("\n");
+                        }
+                        if (step.text && textSpanActive) {
+                            const textTrack = "text_generation";
+                            services.clarkProfiler
+                                .getProfiler()
+                                .updateActiveFrameArgs(textTrack, {
+                                completeTextContent: currentStepTextDeltas.join(""),
+                                finalText: step.text,
+                                textLength: step.text.length,
+                                stepComplete: true,
+                            });
+                            services.clarkProfiler.getProfiler().endFrame(textTrack);
+                            textSpanActive = false;
+                            currentStepTextDeltas = [];
+                        }
+                        if (step.text) {
+                            logRef.content += `[ASSISTANT TEXT] ${step.text}\n`;
+                            void services.chatSessionStore.recordAssistant({
+                                type: "text",
+                                text: step.text,
+                            });
+                        }
+                        const toolsCalled = step.content
+                            .filter((c) => c.type === "tool-result")
+                            .map((c) => ({
+                            toolName: c.toolName,
+                            input: JSON.stringify(c.input),
+                            output: JSON.stringify(c.output, null, 2),
+                        }));
+                        if (toolsCalled.length > 0) {
+                            logRef.content += `[TOOLS CALLED]\n`;
+                            toolsCalled.forEach((tool, idx) => {
+                                logRef.content += `  Tool ${idx + 1}: ${tool.toolName}\n`;
+                                logRef.content += `    Input: ${tool.input}\n`;
+                                logRef.content += `    Output: ${tool.output}\n`;
+                            });
+                            toolsCalled.forEach((tool, idx) => {
+                                let parsedInput, parsedOutput;
+                                try {
+                                    parsedInput = JSON.parse(tool.input);
+                                }
+                                catch {
+                                    parsedInput = tool.input;
+                                }
+                                try {
+                                    parsedOutput = JSON.parse(tool.output);
+                                }
+                                catch {
+                                    parsedOutput = tool.output;
+                                }
+                                services.clarkProfiler
+                                    .getProfiler()
+                                    .addInstantEvent(`Tool Call: ${tool.toolName}`, "llm", {
+                                    step: stepCount,
+                                    toolIndex: idx + 1,
+                                    toolName: tool.toolName,
+                                    input: parsedInput,
+                                    output: parsedOutput,
+                                    inputSize: tool.input.length,
+                                    outputSize: tool.output.length,
+                                });
+                            });
+                        }
+                        logRef.content += `\n`;
+                    },
+                }, clark.tracer, clark.logger);
+                for await (const chunk of build.fullStream) {
+                    await processStreamChunk(chunk, clark, services.chatSessionStore, logRef);
+                }
+                if (firstTokenReceived) {
                     services.clarkProfiler.endFrame();
-                    if (thinkingSpanActive) {
-                        services.clarkProfiler.getProfiler().endFrame("thinking");
-                    }
-                    if (textSpanActive) {
-                        services.clarkProfiler.getProfiler().endFrame("text_generation");
-                    }
-                    const usage = await build.usage;
-                    const { llmobs } = ddTrace;
-                    llmobs.annotate({
-                        inputData: JSON.stringify(messages),
-                        outputData: JSON.stringify(build.fullStream),
-                        metrics: {
-                            inputTokens: usage?.inputTokens ?? 0,
-                            outputTokens: usage?.outputTokens ?? 0,
-                            totalTokens: usage?.totalTokens ?? 0,
-                            cachedInputTokens: usage?.cachedInputTokens ?? 0,
-                        },
-                        metadata: {
-                            request: build.request,
+                }
+                services.clarkProfiler.endFrame();
+                if (thinkingSpanActive) {
+                    services.clarkProfiler.getProfiler().endFrame("thinking");
+                }
+                if (textSpanActive) {
+                    services.clarkProfiler.getProfiler().endFrame("text_generation");
+                }
+                const endTimestamp = new Date().toISOString();
+                logRef.content += `=== LLM CONVERSATION END [${conversationId}] ===\n`;
+                logRef.content += `End Timestamp: ${endTimestamp}\n`;
+                logRef.content += `Total Steps: ${stepCount}\n`;
+                // Log final token usage summary using accumulated totals
+                const finalTotalTokens = totalInputTokens + totalOutputTokens;
+                logRef.content += `[TOTAL TOKEN USAGE] Input: ${totalInputTokens}, Output: ${totalOutputTokens}, Total: ${finalTotalTokens}`;
+                if (totalCachedTokens > 0) {
+                    logRef.content += `, Cached: ${totalCachedTokens}`;
+                }
+                logRef.content += `\n`;
+                try {
+                    // Create TokenRequestData object from accumulated step data (not AI SDK usage which is only final step)
+                    const requestTokenData = {
+                        requestId: conversationId.toString(),
+                        inputTokens: totalInputTokens,
+                        outputTokens: totalOutputTokens,
+                        totalTokens: totalInputTokens + totalOutputTokens,
+                        cachedInputTokens: totalCachedTokens,
+                        model: model.modelId,
+                        startTime: startTimestamp,
+                        endTime: endTimestamp,
+                    };
+                    await clark.context.peer?.call.aiPushTokenUsage(requestTokenData);
+                }
+                catch (error) {
+                    // Token tracking is non-critical - log error but don't fail the AI request
+                    getLogger().warn("Failed to send token usage data", error instanceof Error ? error.message : String(error));
+                }
+                // Save the complete log using saveGeneratedArtifact
+                try {
+                    const logArtifact = {
+                        type: "file",
+                        filePath: `llm-conversation-${conversationId}.log`,
+                        content: logRef.content,
+                    };
+                    const stepId = `llm-conversation-${conversationId}`;
+                    await services.appShell.saveGeneratedArtifact(logArtifact, stepId, runTimestamp);
+                    getLogger().debug("LLM conversation log saved");
+                }
+                catch (error) {
+                    getLogger().error("Failed to save LLM conversation log", {
+                        error: {
+                            kind: "SaveLogError",
+                            message: error instanceof Error ? error.message : String(error),
+                            stack: error instanceof Error ? error.stack : undefined,
                         },
                     });
-                    const endTimestamp = new Date().toISOString();
-                    logRef.content += `=== LLM CONVERSATION END [${conversationId}] ===\n`;
-                    logRef.content += `End Timestamp: ${endTimestamp}\n`;
-                    logRef.content += `Total Steps: ${stepCount}\n`;
-                    // Log final token usage summary using accumulated totals
-                    const finalTotalTokens = totalInputTokens + totalOutputTokens;
-                    logRef.content += `[TOTAL TOKEN USAGE] Input: ${totalInputTokens}, Output: ${totalOutputTokens}, Total: ${finalTotalTokens}`;
-                    if (totalCachedTokens > 0) {
-                        logRef.content += `, Cached: ${totalCachedTokens}`;
-                    }
-                    logRef.content += `\n`;
-                    try {
-                        // Create TokenRequestData object from accumulated step data (not AI SDK usage which is only final step)
-                        const requestTokenData = {
-                            requestId: conversationId.toString(),
-                            inputTokens: totalInputTokens,
-                            outputTokens: totalOutputTokens,
-                            totalTokens: totalInputTokens + totalOutputTokens,
-                            cachedInputTokens: totalCachedTokens,
-                            model: model.modelId,
-                            startTime: startTimestamp,
-                            endTime: endTimestamp,
-                        };
-                        await clark.context.peer?.call.aiPushTokenUsage(requestTokenData);
-                    }
-                    catch (error) {
-                        // Token tracking is non-critical - log error but don't fail the AI request
-                        getLogger().warn("Failed to send token usage data", error instanceof Error ? error.message : String(error));
-                    }
-                    // Save the complete log using saveGeneratedArtifact
-                    try {
-                        const logArtifact = {
-                            type: "file",
-                            filePath: `llm-conversation-${conversationId}.log`,
-                            content: logRef.content,
-                        };
-                        const stepId = `llm-conversation-${conversationId}`;
-                        await services.appShell.saveGeneratedArtifact(logArtifact, stepId, runTimestamp);
-                        getLogger().debug("LLM conversation log saved");
-                    }
-                    catch (error) {
-                        getLogger().error("Failed to save LLM conversation log", {
-                            error: {
-                                kind: "SaveLogError",
-                                message: error instanceof Error ? error.message : String(error),
-                                stack: error instanceof Error ? error.stack : undefined,
-                            },
-                        });
-                    }
-                    const hasLocalDraft = await services.draftInterface.hasLocalDraftChanges();
-                    if (hasLocalDraft) {
-                        void transitionTo({
-                            type: V3_AGENT_FINISHED,
-                        });
-                    }
-                    else {
-                        void transitionTo({
-                            type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
-                        });
-                    }
-                });
+                }
+                const hasLocalDraft = await services.draftInterface.hasLocalDraftChanges();
+                if (hasLocalDraft) {
+                    void transitionTo({
+                        type: V3_AGENT_FINISHED,
+                    });
+                }
+                else {
+                    void transitionTo({
+                        type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
+                    });
+                }
             }
         }
     };