@superblocksteam/vite-plugin-file-sync 2.0.41-next.53 → 2.0.41-next.6

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

@@ -1,8 +1,9 @@
-import { hasToolCall, smoothStream, } from "ai";
+import { hasToolCall, smoothStream } from "ai";
+import ddTrace from "dd-trace";
 import { getLogger } from "../../../util/logger.js";
 import { buildTools } from "../../agent/tools.js";
 import { getAppState, getAvailableComponents, processStreamChunk, } from "../../agent/utils.js";
-import { tracedStreamText } from "../../llmobs/helpers.js";
+import { tracedStreamText, traceWorkflow } from "../../util/ddog-llmobs.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";
@@ -39,37 +40,6 @@ 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);
@@ -97,7 +67,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>`,
-                        providerOptions: nextCacheBreakpoint(),
+                        ...nextCacheBreakpoint(),
                     },
                     ...(latestSummary
                         ? [
@@ -119,13 +89,16 @@ export const doLLMGenerating = (clark, services) => {
                             },
                         ]
                         : []),
-                    buildUserMessage(userPrompt, promptContext, nextCacheBreakpoint),
+                    {
+                        role: "user",
+                        content: userPrompt,
+                    },
                 ];
                 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, providerOptions, } = processLLMConfig(llmConfig, 5000, // default budget tokens
+                const { headers, thinkingEnabled, thinkingBudgetTokens, interleavedThinking, } = 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();
@@ -151,258 +124,277 @@ export const doLLMGenerating = (clark, services) => {
                 });
                 // Note: Input token count will be logged once LLM call begins
                 const tools = buildTools(clark, services, promptContext, logRef, disabledTools);
-                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`;
-                        },
-                    }),
-                    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;
+                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()
-                                    .startFrame(`Thinking Step ${stepCount + 1}`, thinkingTrack, {
-                                    stepNumber: stepCount + 1,
-                                    chunkType: chunkData.chunk.type,
-                                });
+                                    .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;
+                            if (chunkData.chunk.type === "text-delta") {
+                                const textTrack = "text_generation";
                                 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 ? "..." : ""),
-                                });
+                                    .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 ? "..." : ""),
+                                    });
+                                }
                             }
-                        }
-                    },
-                    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}`;
+                        },
+                        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 = [];
                             }
-                            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";
-                            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;
+                            // 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";
                                 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,
+                                    .updateActiveFrameArgs(textTrack, {
+                                    completeTextContent: currentStepTextDeltas.join(""),
+                                    finalText: step.text,
+                                    textLength: step.text.length,
+                                    stepComplete: true,
                                 });
-                            });
-                        }
-                        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();
-                }
-                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,
+                                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`;
                         },
                     });
-                }
-                const hasLocalDraft = await services.draftInterface.hasLocalDraftChanges();
-                if (hasLocalDraft) {
-                    void transitionTo({
-                        type: V3_AGENT_FINISHED,
-                    });
-                }
-                else {
-                    void transitionTo({
-                        type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
+                    for await (const chunk of build.fullStream) {
+                        await processStreamChunk(chunk, clark, services.chatSessionStore, logRef);
+                    }
+                    if (firstTokenReceived) {
+                        services.clarkProfiler.endFrame();
+                    }
+                    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,
+                        },
                     });
-                }
+                    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,
+                        });
+                    }
+                });
             }
         }
     };