@superblocksteam/vite-plugin-file-sync 2.0.34 → 2.0.35-next.1

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

@@ -1,368 +1,372 @@
-import { AiGenerationState } from "@superblocksteam/library-shared/types";
-import { streamText, smoothStream } from "ai";
+import { hasToolCall, smoothStream } from "ai";
 import ddTrace from "dd-trace";
-import { getErrorMeta, getLogger } from "../../../util/logger.js";
-import { Paths, SAVE_LLM_GENERATION_STEPS, SAVE_RAW_LLM_RESPONSE, } from "../../const.js";
-import { BoltResultBuffer, BoltResultType } from "../../result-buffer/bolt.js";
-import { ApiBuilderToYamlTransformer } from "../../transform/api-builder/to-yaml-transformer.js";
-import { applyFileTransformations, matchPath } from "../../transform/shared.js";
-import { AGENT_PLANNED, APP_RUNTIME_UPDATED_WITHOUT_EDITS, LLM_ERRORED, LLM_FINISHED, LLM_FINISHED_UNEXPECTEDLY, POST_PROCESSING_ERRORED, } from "../clark-fsm.js";
-import { sendChangeInfoHelper } from "../helpers/change-info.js";
-import { classificationHelper } from "../helpers/classification.js";
-import { sendUserGenerationStateChannel, sendUserMessageChannel, } from "../helpers/peer.js";
-import { checkRateLimitHeaders } from "../helpers/rate-limiting.js";
+import { getLogger } from "../../../util/logger.js";
+import { buildTools } from "../../agent/tools.js";
+import { getAppState, processStreamChunk } from "../../agent/utils.js";
+import { DEFAULT_CACHE_PROVIDER_OPTIONS } from "../../const.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 { transitionFrom } from "../helpers/transition.js";
-export const doLLMGenerating = (clark, { appShell, artifactProcessor, templateRenderer, draftInterface, llmProvider, chatSessionStore, }) => {
+import { buildSimplePrompt } from "./simple-prompt-builder.js";
+function formatSummaryForAgents(latestSummary) {
+    if (!latestSummary) {
+        return null;
+    }
+    const parts = [];
+    if (latestSummary.outcome === "accepted") {
+        parts.push(`The user *accepted* the changes associated with the following summary. They have been applied to the application.`);
+    }
+    else if (latestSummary.outcome === "rejected") {
+        parts.push(`The user *rejected* the changes associated with the following summary. The changes were discarded.`);
+    }
+    if (latestSummary.summary) {
+        parts.push(`Summary: ${latestSummary.summary}`);
+    }
+    if (latestSummary.goals && latestSummary.goals.length > 0) {
+        parts.push(`User Goals: ${latestSummary.goals.join(", ")}`);
+    }
+    if (latestSummary.decisions && latestSummary.decisions.length > 0) {
+        parts.push(`Decisions: ${latestSummary.decisions.join(", ")}`);
+    }
+    if (latestSummary.adviceToAgents) {
+        parts.push(`Agent Advice: ${latestSummary.adviceToAgents}`);
+    }
+    if (latestSummary.relevantFilePaths &&
+        latestSummary.relevantFilePaths.length > 0) {
+        parts.push(`Relevant files:\n${latestSummary.relevantFilePaths
+            .map((path) => `- ${path}`)
+            .join("\n")}`);
+    }
+    return parts.length > 0 ? parts.join("\n\n") : null;
+}
+export const doLLMGenerating = (clark, services) => {
+    const { chatSessionStore } = services;
     const transitionTo = transitionFrom(clark);
-    const sendUserMessage = sendUserMessageChannel(clark, chatSessionStore);
-    const sendUserGenerationState = sendUserGenerationStateChannel(clark);
-    const sendChangeInfo = sendChangeInfoHelper(clark, chatSessionStore);
-    const { isFullAppOrBroadUpdate } = classificationHelper(clark);
-    const logger = getLogger();
-    const matchGeneratedApi = matchPath(Paths.GeneratedApis);
-    const { llmobs } = ddTrace;
     return async ({ event }) => {
         switch (event.type) {
             case AGENT_PLANNED: {
-                const { systemMessages, userPrompt, debuggingPrompt: debugging, classification, } = event;
+                const { userPrompt, promptContext } = event;
                 const { abortController } = clark.context;
-                const showControlMessages = isFullAppOrBroadUpdate();
                 await chatSessionStore.getMessages();
-                const historyMessages = classification !== "specific_edit"
-                    ? // only include history for non-specific edits
-                        (chatSessionStore.getRecentExchanges() ?? [])
-                    : [];
-                if (debugging) {
-                    // include the user's original prompt; userPrompt contains the debugging instructions
-                    const lastUserMessage = chatSessionStore.getLastUserMessage();
-                    if (lastUserMessage && lastUserMessage.content !== userPrompt) {
-                        historyMessages.push({
-                            role: "user",
-                            content: lastUserMessage.content,
-                        });
-                    }
-                }
+                const latestSummary = await chatSessionStore.getLatestSummary();
+                const focusedEntities = promptContext?.entities
+                    // tagged integrations are ignored
+                    ?.filter((e) => e.type !== "integration")
+                    .map((e) => `- ${e.id} (${e.type})`)
+                    .join("\n");
+                const appState = await getAppState(services, promptContext);
+                const systemPrompt = buildSimplePrompt();
                 const messages = [
-                    ...systemMessages.map((msg) => ({
-                        role: msg.role,
-                        content: msg.content,
-                    })),
-                    ...historyMessages,
-                    ...(debugging
+                    {
+                        role: "system",
+                        content: systemPrompt,
+                        ...(!clark.context.disablePromptCaching && {
+                            providerOptions: DEFAULT_CACHE_PROVIDER_OPTIONS,
+                        }),
+                    },
+                    ...(latestSummary
                         ? [
                             {
                                 role: "user",
-                                content: debugging,
+                                content: `Reference the context from the previous exchange with the user, if relevant:\n\n${formatSummaryForAgents(latestSummary)}`,
                             },
                         ]
-                        : [
+                        : []),
+                    {
+                        role: "user",
+                        content: `<current_app_state>\nHere is metadata about the current state of the users's application.\n\`\`\`json\n${JSON.stringify(appState)}\n\`\`\`\n</current_app_state>`,
+                    },
+                    ...(focusedEntities
+                        ? [
                             {
                                 role: "user",
-                                content: userPrompt,
+                                content: `<focused_entities>\nThe user has focused the editor on the following entities corresponding to the current app state. Attempt to constrain your actions to affect only these entities.\n${focusedEntities}\n</focused_entities>`,
                             },
-                        ]),
+                        ]
+                        : []),
+                    {
+                        role: "user",
+                        content: userPrompt,
+                    },
                 ];
-                const model = llmProvider.modelForClassification(classification);
-                await llmobs.wrap({
-                    kind: "llm",
-                    name: "doLLMGenerating",
-                    modelName: model.modelId,
-                    modelProvider: model.provider,
-                }, async () => {
-                    llmobs.annotate({
-                        tags: {
-                            classification,
-                        },
-                    });
-                    // Store span context so we can run an eval on it later
-                    clark.updateContext({
-                        spanContext: llmobs.exportSpan(),
+                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
+                `LLM Generating (model=${model.modelId}, disabledTools=${disabledTools?.length ? disabledTools.join(",") : "none"})`);
+                const conversationId = Date.now();
+                const startTimestamp = new Date().toISOString();
+                const runTimestamp = clark.context.runTimestamp || startTimestamp;
+                // Initialize log content
+                const logRef = {
+                    content: `=== LLM CONVERSATION START [${conversationId}] ===\n`,
+                };
+                logRef.content += `Timestamp: ${startTimestamp}\n`;
+                logRef.content += `Model: ${model.modelId}\n`;
+                // Log AI provider config
+                logRef.content += `Provider Config: provider=${llmConfig?.provider || "anthropic (default)"}, thinking=${thinkingEnabled}, budget=${thinkingBudgetTokens}, interleaved=${interleavedThinking}`;
+                if (disabledTools?.length) {
+                    logRef.content += `, disabledTools=${disabledTools.join(",")}`;
+                }
+                if (headers && Object.keys(headers).length > 0) {
+                    logRef.content += `, headers=${JSON.stringify(headers)}`;
+                }
+                logRef.content += `--- INPUT MESSAGES ---\n`;
+                logRef.content += `[SYSTEM] ${systemPrompt}\n\n`;
+                messages.forEach((msg, _index) => {
+                    logRef.content += `[${msg.role.toUpperCase()}] ${msg.content}\n\n`;
+                });
+                // 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,
                     });
-                    const fullStream = streamText({
+                    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,
-                        experimental_transform: smoothStream(),
-                        abortSignal: abortController?.signal,
-                    }).fullStream;
-                    let pendingArtifacts = false;
-                    let artifactChunk = null;
-                    let stepId = null;
-                    const flushedAfterArtifacts = [];
-                    // Raw LLM response text logging
-                    let rawLLMResponse = "";
-                    // the buffer collects the text and artifact chunks and
-                    // yields side effects on flush or when a new chunk type is detected
-                    const resultBuffer = new BoltResultBuffer({
-                        onTypeChange: (type) => {
-                            void (async () => {
-                                switch (type) {
-                                    case BoltResultType.Artifact:
-                                        if (!pendingArtifacts &&
-                                            !debugging &&
-                                            showControlMessages) {
-                                            void sendUserMessage({
-                                                type: "text",
-                                                group: "clark",
-                                                text: "Passing it over to the Engineer Agent to start building!",
-                                            });
-                                            void sendUserMessage({
-                                                type: "text",
-                                                group: "agent-engineer",
-                                                text: "Great, thanks Clark - let's get to work! You can track my progress below.",
-                                            }, 750);
-                                        }
-                                        pendingArtifacts = true;
-                                        break;
-                                    case BoltResultType.Text:
-                                        void sendUserMessage({
-                                            type: "control",
-                                            group: "clark",
-                                            status: "ready",
-                                            text: "Generating…",
-                                        });
-                                        break;
-                                }
-                            })();
-                        },
-                        onFlush: (type, text) => {
-                            void (async () => {
-                                switch (type) {
-                                    case BoltResultType.Text:
-                                        if (!debugging) {
-                                            if (artifactChunk) {
-                                                flushedAfterArtifacts.push([type, text]);
-                                            }
-                                            else {
-                                                void sendUserMessage({ text, type: "text" });
-                                            }
-                                        }
-                                        break;
-                                    case BoltResultType.Think:
-                                        if (artifactChunk) {
-                                            flushedAfterArtifacts.push([type, text]);
-                                        }
-                                        else {
-                                            void sendUserMessage({ text, type: "reasoning" });
-                                        }
-                                        break;
-                                    case BoltResultType.Artifact: {
-                                        if (!artifactChunk) {
-                                            artifactChunk = text;
-                                        }
-                                        break;
-                                    }
-                                }
-                            })();
-                        },
-                        onPendingFile: (filePath) => {
-                            void (async () => {
-                                void sendChangeInfo({
-                                    type: "pending",
-                                    filePath,
+                        tools,
+                        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}]`,
                                 });
-                            })();
-                        },
-                        onFlushFile: (filePath, buffer) => {
-                            void (async () => {
-                                void sendChangeInfo({
-                                    type: "ready",
-                                    filePath,
-                                });
-                                const generatedFileDfd = (async () => {
-                                    const files = artifactProcessor.extractFileArtifacts(buffer);
-                                    return files.find((file) => file.filePath === filePath);
-                                })();
-                                if (SAVE_LLM_GENERATION_STEPS) {
-                                    const generatedFile = await generatedFileDfd;
-                                    if (!generatedFile) {
-                                        return;
-                                    }
-                                    await appShell.saveGeneratedArtifact(generatedFile, stepId ?? "unknown-step-id", clark.context.runTimestamp ?? "unknown-run-timestamp");
-                                }
-                                if (!matchGeneratedApi(filePath).matched) {
-                                    return;
-                                }
-                                const generatedFile = await generatedFileDfd;
-                                if (!generatedFile) {
-                                    return;
-                                }
-                                try {
-                                    const [apiYaml] = await applyFileTransformations([generatedFile], [
-                                        new ApiBuilderToYamlTransformer({
-                                            skipCleanup: true,
-                                            templateRenderer,
-                                        }),
-                                    ]);
-                                    if (apiYaml) {
-                                        await draftInterface.createDraftFile(apiYaml.filePath, apiYaml.content);
-                                    }
+                            }
+                            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,
+                                    });
                                 }
-                                catch (error) {
-                                    logger.error("[ai-service] Error flushing file:", getErrorMeta(error));
-                                    void transitionTo({
-                                        type: POST_PROCESSING_ERRORED,
-                                        error: error instanceof Error
-                                            ? error
-                                            : new Error("Unknown error"),
+                            }
+                            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 ? "..." : ""),
                                     });
                                 }
-                            })();
+                            }
                         },
-                    });
-                    // process stream. in general this should be agnostic to the bolt-oriented prompt
-                    for await (const chunk of fullStream) {
-                        switch (chunk.type) {
-                            case "text-delta":
-                                if (SAVE_LLM_GENERATION_STEPS) {
-                                    rawLLMResponse += chunk.textDelta;
+                        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}`;
                                 }
-                                resultBuffer.add(chunk.textDelta);
-                                resultBuffer.maybeFlush();
-                                break;
-                            case "reasoning":
-                                // note: unused; the system prompt encourages <think> tags
-                                break;
-                            case "file":
-                                // note: unused; the system prompt encourages <boltArtifact> tags
-                                break;
-                            case "step-start":
-                                stepId = chunk.messageId;
-                                logger.debug("[ai-service] Step started:", chunk.messageId);
-                                // Save input messages to the same folder as other artifacts
-                                if (SAVE_LLM_GENERATION_STEPS) {
+                                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 {
-                                        await appShell.saveGeneratedArtifact({
-                                            type: "file",
-                                            filePath: "input-messages.json",
-                                            content: JSON.stringify(messages, null, 2),
-                                        }, stepId, clark.context.runTimestamp ?? "unknown-run-timestamp");
-                                        logger.debug(`[ai-service] Input messages saved to generation folder for step: ${stepId}`);
+                                        parsedInput = JSON.parse(tool.input);
                                     }
-                                    catch (error) {
-                                        logger.error("[ai-service] Failed to save input messages:", getErrorMeta(error));
+                                    catch {
+                                        parsedInput = tool.input;
                                     }
-                                }
-                                break;
-                            case "step-finish":
-                                resultBuffer.maybeFlush(true);
-                                logger.debug("[ai-service] Step finished:", chunk.messageId);
-                                break;
-                            case "error": {
-                                // TODO(saksham, omar): remove this once we have a clear picture of the errors we are dealing with
-                                console.error(typeof chunk.error === "object" && chunk.error != null
-                                    ? JSON.stringify(chunk.error)
-                                    : chunk.error);
-                                logger.error("[ai-service] LLM error chunk:", getErrorMeta(chunk.error));
-                                let error = {
-                                    type: "unknown",
-                                };
-                                if (typeof chunk.error === "object" &&
-                                    chunk.error !== null &&
-                                    "type" in chunk.error &&
-                                    typeof chunk.error.type === "string") {
-                                    error = chunk.error;
-                                }
-                                const chunkError = chunk.error;
-                                if (chunkError?.lastError &&
-                                    chunkError.lastError.data?.error) {
-                                    error = chunkError.lastError.data?.error;
-                                }
-                                void transitionTo({
-                                    type: LLM_ERRORED,
-                                    error: error,
-                                });
-                                return;
-                            }
-                            case "finish": {
-                                // safely set metrics from usage for trace span
-                                const usage = chunk?.usage;
-                                const metrics = usage &&
-                                    typeof usage.promptTokens === "number" &&
-                                    typeof usage.completionTokens === "number" &&
-                                    typeof usage.totalTokens === "number"
-                                    ? {
-                                        inputTokens: usage.promptTokens,
-                                        outputTokens: usage.completionTokens,
-                                        totalTokens: usage.totalTokens,
+                                    try {
+                                        parsedOutput = JSON.parse(tool.output);
                                     }
-                                    : undefined;
-                                llmobs.annotate({
-                                    inputData: messages,
-                                    outputData: { content: rawLLMResponse, role: "assistant" },
-                                    metrics,
-                                });
-                                if (chunk.finishReason !== "stop") {
-                                    const rateLimitErrorMsg = checkRateLimitHeaders("response" in chunk ? chunk.response?.headers : undefined);
-                                    if (rateLimitErrorMsg) {
-                                        logger.error(`[ai-service] Rate limit detected: ${rateLimitErrorMsg}`);
+                                    catch {
+                                        parsedOutput = tool.output;
                                     }
-                                    void transitionTo({
-                                        type: LLM_FINISHED_UNEXPECTEDLY,
-                                        finishReason: chunk.finishReason,
-                                    });
-                                    abortController?.abort();
-                                    return;
-                                }
-                                else if (!pendingArtifacts || !artifactChunk) {
-                                    void transitionTo({
-                                        type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
+                                    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,
                                     });
-                                    // TODO: do this in the state handler
-                                    void sendUserGenerationState({
-                                        state: AiGenerationState.COMPLETED,
-                                        hasSuggestions: false,
-                                    });
-                                }
-                                else {
-                                    const generated = artifactProcessor.extractFileArtifacts(artifactChunk);
-                                    const summaryMessages = flushedAfterArtifacts
-                                        .filter(([type]) => type === BoltResultType.Text)
-                                        .map(([_, content]) => ({
-                                        role: "assistant",
-                                        isDebugging: !!debugging,
-                                        content,
-                                    }));
-                                    clark.updateContext({
-                                        summaryMessages: clark.context.summaryMessages
-                                            ? [...clark.context.summaryMessages, ...summaryMessages]
-                                            : summaryMessages,
-                                    });
-                                    void transitionTo({
-                                        type: LLM_FINISHED,
-                                        files: generated,
-                                    });
-                                }
-                                break;
+                                });
                             }
-                            case "tool-call":
-                            case "tool-call-streaming-start":
-                            case "tool-call-delta":
-                            case "reasoning-signature":
-                            case "redacted-reasoning":
-                            case "source":
-                                break;
-                            default:
-                                logger.error(`[ai-service] Unhandled chunk type: ${chunk.type}`);
-                                break;
-                        }
+                            logRef.content += `\n`;
+                        },
+                    });
+                    for await (const chunk of build.fullStream) {
+                        await processStreamChunk(chunk, clark, logRef);
+                    }
+                    if (firstTokenReceived) {
+                        services.clarkProfiler.endFrame();
+                    }
+                    services.clarkProfiler.endFrame();
+                    if (thinkingSpanActive) {
+                        services.clarkProfiler.getProfiler().endFrame("thinking");
+                    }
+                    if (textSpanActive) {
+                        services.clarkProfiler.getProfiler().endFrame("text_generation");
                     }
-                    resultBuffer.maybeFlush(true);
-                    // Save raw LLM response using existing debug infrastructure
-                    if (SAVE_RAW_LLM_RESPONSE && rawLLMResponse.length > 0) {
-                        try {
-                            logger.debug(`[ai-service] Raw LLM response length: ${rawLLMResponse.length} characters`);
-                            void appShell.saveGeneratedArtifact({
-                                type: "file",
-                                filePath: "raw-llm-response.txt",
-                                content: rawLLMResponse,
-                            }, stepId ?? "unknown-step-id", clark.context.runTimestamp ?? "unknown-run-timestamp");
-                            logger.info(`[ai-service] Raw LLM response saved to debug folder`);
-                        }
-                        catch (error) {
-                            logger.error("[ai-service] Failed to save raw LLM response:", getErrorMeta(error));
-                        }
+                    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`;
+                    // 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,
+                        });
                     }
-                })();
+                });
             }
         }
     };