@superblocksteam/vite-plugin-file-sync 2.0.43-next.12 → 2.0.43-next.14

package/dist/ai-service/agent/subagents/apis/generate-api-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-api-source.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/agent/subagents/apis/generate-api-source.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EACV,KAAK,EACL,uBAAuB,EACxB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EAIzB,MAAM,uCAAuC,CAAC;AAE/C,eAAO,MAAM,aAAa,GACxB,OAAO;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,EACD,UAAU,OAAO,EACjB,eAAe,aAAa,GAAG,SAAS,EACxC,OAAO,KAAK,EACZ,UAAU,uBAAuB,EACjC,kBAAkB,cAAc,EAEhC,aAAa,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;yBAqD9B,CAAF;uBAIF,CAAJ;;;;;;uBAOsC,CAAC;2BACf,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA4K1B,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,UAAU,MAAM,EAChB,SAAS,MAAM,EACf,iBAAiB,MAAM,EAAE,GAAG,SAAS,EACrC,UAAU,uBAAuB,sCA0ClC,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;GAgehD,CAAC"}
+{"version":3,"file":"generate-api-source.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/agent/subagents/apis/generate-api-source.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EACV,KAAK,EACL,uBAAuB,EACxB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EAIzB,MAAM,uCAAuC,CAAC;AAE/C,eAAO,MAAM,aAAa,GACxB,OAAO;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,EACD,UAAU,OAAO,EACjB,eAAe,aAAa,GAAG,SAAS,EACxC,OAAO,KAAK,EACZ,UAAU,uBAAuB,EACjC,kBAAkB,cAAc,EAEhC,aAAa,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;yBAmDJ,CAAC;uBAErB,CAAC;;;;;;uBAUS,CAAC;2BACyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA6KpD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,UAAU,MAAM,EAChB,SAAS,MAAM,EACf,iBAAiB,MAAM,EAAE,GAAG,SAAS,EACrC,UAAU,uBAAuB,sCA0ClC,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;GA6fhD,CAAC"}

package/dist/ai-service/agent/subagents/apis/generate-api-source.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { hasToolCall, smoothStream, tool, } from "ai";
+import { smoothStream, tool } from "ai";
 import z from "zod";
 import { getErrorMeta, getLogger } from "../../../../util/logger.js";
 import { datasourceSdkClassByType, Paths } from "../../../const.js";
@@ -11,6 +11,7 @@ import { YamlToApiBuilderTransformer } from "../../../transform/api-builder/to-s
 import { ApiBuilderToYamlTransformer } from "../../../transform/api-builder/to-yaml-transformer.js";
 import { applyFileTransformations, renderPath, } from "../../../transform/shared.js";
 import { processLLMConfig } from "../../../util/llm-config-utils.js";
+import { hasToolSuccess } from "../../../util/stop-condition.js";
 import { getToolCallArguments } from "../../tool-message-utils.js";
 import { executeRequestToIntegrationToolFactory, searchIntegrationsToolFactory, } from "../../tools/index.js";
 import { ensureScopeFileDraft, getPageEntitiesFiltered, processStreamChunk, } from "../../utils.js";
@@ -299,276 +300,295 @@ When calling this tool, analyze the user's requirements and provide 2-4 relevant
                 logRef.content += `[EXAMPLE SELECTION] Hints: ${exampleHints.join(", ")}\n`;
                 logRef.content += `[EXAMPLE SELECTION] Selected: ${selectedExampleMetadata.map((e) => e.id).join(", ")}\n\n`;
             }
-            // Set up context for the API subagent
-            const contextId = getContextId(clark, services);
+            // Set up context for the API subagent with thread-safe ownership
+            const subagentName = `api-subagent-${pageName}-${apiName}`;
+            const contextId = getContextId(clark, services, subagentName);
             const contextOptions = clark.context.llmConfig?.contextOptions;
-            const context = await services.contextManager.getContext(contextId, contextOptions);
-            const mainSystemPrompt = context.getSystemPrompt();
-            // Combine system prompt with examples
-            const fullSystemPrompt = examplesContent
-                ? `${systemPrompt}\n\n${examplesContent}`
-                : systemPrompt;
-            context.setSystemPrompt({
-                role: "system",
-                content: fullSystemPrompt,
+            // Generate a unique owner ID for this subagent execution
+            const ownerId = `${subagentName}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+            // Acquire exclusive context access with retries
+            const contextHandle = await services.contextManager.acquireContext(contextId, ownerId, {
+                contextOptions,
+                acquireOptions: {
+                    waitTimeoutMs: 10000, // Wait up to 10 seconds for context
+                    lockTimeoutMs: 300000, // Hold lock for up to 5 minutes
+                    retryIntervalMs: 100,
+                },
             });
-            context.startTurn({
-                role: "user",
-                content: apiPrompt,
-            });
-            // Process LLM configuration
-            const { providerOptions, headers } = processLLMConfig(llmConfig, 5000, // default budget tokens
-            `API Subagent (model=${model.modelId})`);
-            const apiSubagentTrack = "api_subagent";
-            services.clarkProfiler
-                .getProfiler()
-                .createTrack(apiSubagentTrack, "API Subagent", "tool");
-            return services.clarkProfiler.getProfiler().timeAsync(`generateApiSource:${apiName}`, async () => {
-                let stepCount = 0;
-                let thinkingSpanActive = false;
-                let textSpanActive = false;
-                const allReasoningDeltas = [];
-                let currentStepReasoningDeltas = [];
-                let currentStepTextDeltas = [];
-                // Step accumulators for accurate token counting
-                const startTime = new Date().toISOString();
-                let totalInputTokens = 0;
-                let totalOutputTokens = 0;
-                let totalCachedTokens = 0;
-                let finalizeApiData = {
-                    apiName,
-                    responseInterface: "",
-                    inputInterface: "",
-                    summary: "",
-                };
-                const response = tracedStreamText({
-                    model,
-                    messages: context.getMessages(),
-                    abortSignal: clark.context.abortController?.signal,
-                    providerOptions,
-                    headers,
-                    experimental_transform: [smoothStream({ chunking: "line" })],
-                    tools,
-                    prepareStep: async (step) => {
-                        context.startStep();
-                        const messages = context.getMessages();
-                        return { ...step, messages };
-                    },
-                    stopWhen: hasToolCall("finalizeApi"),
-                    onChunk: (chunkData) => {
-                        if (chunkData.chunk.type === "reasoning-delta") {
-                            allReasoningDeltas.push(chunkData.chunk.text);
-                            currentStepReasoningDeltas.push(chunkData.chunk.text);
-                            if (!thinkingSpanActive) {
-                                thinkingSpanActive = true;
+            try {
+                const context = contextHandle.context;
+                const mainSystemPrompt = context.getSystemPrompt();
+                // Combine system prompt with examples
+                const fullSystemPrompt = examplesContent
+                    ? `${systemPrompt}\n\n${examplesContent}`
+                    : systemPrompt;
+                context.setSystemPrompt({
+                    role: "system",
+                    content: fullSystemPrompt,
+                });
+                context.startTurn({
+                    role: "user",
+                    content: apiPrompt,
+                });
+                // Process LLM configuration
+                const { providerOptions, headers } = processLLMConfig(llmConfig, 5000, // default budget tokens
+                `API Subagent (model=${model.modelId})`);
+                const apiSubagentTrack = "api_subagent";
+                services.clarkProfiler
+                    .getProfiler()
+                    .createTrack(apiSubagentTrack, "API Subagent", "tool");
+                return await services.clarkProfiler.getProfiler().timeAsync(`generateApiSource:${apiName}`, async () => {
+                    let stepCount = 0;
+                    let thinkingSpanActive = false;
+                    let textSpanActive = false;
+                    const allReasoningDeltas = [];
+                    let currentStepReasoningDeltas = [];
+                    let currentStepTextDeltas = [];
+                    // Step accumulators for accurate token counting
+                    const startTime = new Date().toISOString();
+                    let totalInputTokens = 0;
+                    let totalOutputTokens = 0;
+                    let totalCachedTokens = 0;
+                    let finalizeApiData = {
+                        apiName,
+                        responseInterface: "",
+                        inputInterface: "",
+                        summary: "",
+                    };
+                    const response = tracedStreamText({
+                        model,
+                        messages: context.getMessages(),
+                        abortSignal: clark.context.abortController?.signal,
+                        providerOptions,
+                        headers,
+                        experimental_transform: [smoothStream({ chunking: "line" })],
+                        tools,
+                        prepareStep: async (step) => {
+                            context.startStep();
+                            const messages = context.getMessages();
+                            return { ...step, messages };
+                        },
+                        stopWhen: hasToolSuccess("finalizeApi"),
+                        onChunk: (chunkData) => {
+                            if (chunkData.chunk.type === "reasoning-delta") {
+                                allReasoningDeltas.push(chunkData.chunk.text);
+                                currentStepReasoningDeltas.push(chunkData.chunk.text);
+                                if (!thinkingSpanActive) {
+                                    thinkingSpanActive = true;
+                                    services.clarkProfiler
+                                        .getProfiler()
+                                        .startFrame(`API Thinking Step ${stepCount + 1}`, apiSubagentTrack, {
+                                        stepNumber: stepCount + 1,
+                                        chunkType: chunkData.chunk.type,
+                                        apiName,
+                                    });
+                                }
+                            }
+                            if (chunkData.chunk.type === "text-delta") {
+                                currentStepTextDeltas.push(chunkData.chunk.text);
+                                if (!textSpanActive) {
+                                    textSpanActive = true;
+                                    services.clarkProfiler
+                                        .getProfiler()
+                                        .startFrame(`API Text Generation Step ${stepCount + 1}`, apiSubagentTrack, {
+                                        stepNumber: stepCount + 1,
+                                        firstTextDelta: chunkData.chunk.text.slice(0, 50) +
+                                            (chunkData.chunk.text.length > 50 ? "..." : ""),
+                                        apiName,
+                                    });
+                                }
+                            }
+                        },
+                        onStepFinish: async (step) => {
+                            stepCount++;
+                            const stepTimestamp = new Date().toISOString();
+                            context.endStep(step.response.messages, step.usage);
+                            logRef.content += `--- OUTPUT STEP (API subagent) [${stepTimestamp}] ---\n`;
+                            totalInputTokens += step.usage?.inputTokens ?? 0;
+                            if (step.reasoning && thinkingSpanActive) {
                                 services.clarkProfiler
                                     .getProfiler()
-                                    .startFrame(`API Thinking Step ${stepCount + 1}`, apiSubagentTrack, {
-                                    stepNumber: stepCount + 1,
-                                    chunkType: chunkData.chunk.type,
+                                    .updateActiveFrameArgs(apiSubagentTrack, {
+                                    completeReasoningText: currentStepReasoningDeltas.join(" "),
+                                    reasoningLength: step.reasoning.length,
+                                    stepComplete: true,
                                     apiName,
                                 });
+                                services.clarkProfiler
+                                    .getProfiler()
+                                    .endFrame(apiSubagentTrack);
+                                thinkingSpanActive = false;
+                                currentStepReasoningDeltas = [];
                             }
-                        }
-                        if (chunkData.chunk.type === "text-delta") {
-                            currentStepTextDeltas.push(chunkData.chunk.text);
-                            if (!textSpanActive) {
-                                textSpanActive = true;
+                            if (step.text && textSpanActive) {
                                 services.clarkProfiler
                                     .getProfiler()
-                                    .startFrame(`API Text Generation Step ${stepCount + 1}`, apiSubagentTrack, {
-                                    stepNumber: stepCount + 1,
-                                    firstTextDelta: chunkData.chunk.text.slice(0, 50) +
-                                        (chunkData.chunk.text.length > 50 ? "..." : ""),
+                                    .updateActiveFrameArgs(apiSubagentTrack, {
+                                    completeTextContent: currentStepTextDeltas.join(""),
+                                    finalText: step.text,
+                                    textLength: step.text.length,
+                                    stepComplete: true,
                                     apiName,
                                 });
+                                services.clarkProfiler
+                                    .getProfiler()
+                                    .endFrame(apiSubagentTrack);
+                                textSpanActive = false;
+                                currentStepTextDeltas = [];
                             }
-                        }
-                    },
-                    onStepFinish: async (step) => {
-                        stepCount++;
-                        const stepTimestamp = new Date().toISOString();
-                        context.endStep(step.response.messages, step.usage);
-                        logRef.content += `--- OUTPUT STEP (API subagent) [${stepTimestamp}] ---\n`;
-                        totalInputTokens += step.usage?.inputTokens ?? 0;
-                        if (step.reasoning && thinkingSpanActive) {
-                            services.clarkProfiler
-                                .getProfiler()
-                                .updateActiveFrameArgs(apiSubagentTrack, {
-                                completeReasoningText: currentStepReasoningDeltas.join(" "),
-                                reasoningLength: step.reasoning.length,
-                                stepComplete: true,
-                                apiName,
-                            });
-                            services.clarkProfiler
-                                .getProfiler()
-                                .endFrame(apiSubagentTrack);
-                            thinkingSpanActive = false;
-                            currentStepReasoningDeltas = [];
-                        }
-                        if (step.text && textSpanActive) {
-                            services.clarkProfiler
-                                .getProfiler()
-                                .updateActiveFrameArgs(apiSubagentTrack, {
-                                completeTextContent: currentStepTextDeltas.join(""),
-                                finalText: step.text,
-                                textLength: step.text.length,
-                                stepComplete: true,
-                                apiName,
-                            });
-                            services.clarkProfiler
-                                .getProfiler()
-                                .endFrame(apiSubagentTrack);
-                            textSpanActive = false;
-                            currentStepTextDeltas = [];
-                        }
-                        if (step.reasoning) {
-                            const reasoningLines = [
-                                "[REASONING]",
-                                ...step.reasoning.map(({ text }) => text),
-                                "",
-                            ];
-                            logRef.content += reasoningLines.join("\n");
-                            const reasoningText = step.reasoning
-                                .map(({ text }) => text)
-                                .join(" ");
-                            if (reasoningText.trim()) {
-                                void services.chatSessionStore.recordAssistant({
-                                    type: "reasoning",
-                                    text: reasoningText,
-                                    group: `api-${apiName}`,
-                                });
-                            }
-                        }
-                        if (step.toolCalls.length > 0) {
-                            try {
-                                await Promise.all(step.toolCalls.map(async (toolCall) => {
-                                    const args = await getToolCallArguments(toolCall.toolName, toolCall.input, clark);
-                                    await services.chatSessionStore.recordAssistant({
-                                        type: "tool",
-                                        tool: toolCall.toolName,
-                                        args: args,
+                            if (step.reasoning) {
+                                const reasoningLines = [
+                                    "[REASONING]",
+                                    ...step.reasoning.map(({ text }) => text),
+                                    "",
+                                ];
+                                logRef.content += reasoningLines.join("\n");
+                                const reasoningText = step.reasoning
+                                    .map(({ text }) => text)
+                                    .join(" ");
+                                if (reasoningText.trim()) {
+                                    void services.chatSessionStore.recordAssistant({
+                                        type: "reasoning",
+                                        text: reasoningText,
                                         group: `api-${apiName}`,
                                     });
-                                }));
-                            }
-                            catch (error) {
-                                getLogger().error("Failed to record subagent tool calls", getErrorMeta(error));
-                            }
-                        }
-                        // Record text messages AFTER tool calls
-                        if (step.text) {
-                            logRef.content += `[ASSISTANT TEXT] ${step.text}\n`;
-                            void services.chatSessionStore.recordAssistant({
-                                type: "text",
-                                text: step.text,
-                                group: `api-${apiName}`,
-                            });
-                        }
-                        // Accumulate token usage for this step
-                        if (step.usage) {
-                            const stepInputTokens = step.usage.inputTokens ?? 0;
-                            const stepOutputTokens = step.usage.outputTokens ?? 0;
-                            const stepCachedTokens = step.usage.cachedInputTokens ?? 0;
-                            // Accumulate tokens across all steps
-                            totalInputTokens += stepInputTokens;
-                            totalOutputTokens += stepOutputTokens;
-                            totalCachedTokens += stepCachedTokens;
-                        }
-                        const finalizeApiResult = step.toolResults.find((r) => r.toolName === "finalizeApi");
-                        if (finalizeApiResult) {
-                            finalizeApiData = finalizeApiResult.input;
-                        }
-                        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;
                                 }
+                            }
+                            if (step.toolCalls.length > 0) {
                                 try {
-                                    parsedOutput = JSON.parse(tool.output);
+                                    await Promise.all(step.toolCalls.map(async (toolCall) => {
+                                        const args = await getToolCallArguments(toolCall.toolName, toolCall.input, clark);
+                                        await services.chatSessionStore.recordAssistant({
+                                            type: "tool",
+                                            tool: toolCall.toolName,
+                                            args: args,
+                                            group: `api-${apiName}`,
+                                        });
+                                    }));
                                 }
-                                catch {
-                                    parsedOutput = tool.output;
+                                catch (error) {
+                                    getLogger().error("Failed to record subagent tool calls", getErrorMeta(error));
                                 }
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .addInstantEvent(`API Tool Call: ${tool.toolName}`, apiSubagentTrack, {
-                                    step: stepCount,
-                                    toolIndex: idx + 1,
-                                    toolName: tool.toolName,
-                                    input: parsedInput,
-                                    output: parsedOutput,
-                                    inputSize: tool.input.length,
-                                    outputSize: tool.output.length,
-                                    apiName,
+                            }
+                            // Record text messages AFTER tool calls
+                            if (step.text) {
+                                logRef.content += `[ASSISTANT TEXT] ${step.text}\n`;
+                                void services.chatSessionStore.recordAssistant({
+                                    type: "text",
+                                    text: step.text,
+                                    group: `api-${apiName}`,
                                 });
-                            });
-                        }
-                        logRef.content += `\n`;
-                    },
-                    onFinish: (result) => {
-                        context.endTurn(result.totalUsage);
-                        if (mainSystemPrompt) {
-                            // restore main system prompt
-                            context.setSystemPrompt(mainSystemPrompt);
-                        }
-                    },
-                }, clark.tracer, clark.logger);
-                for await (const chunk of response.fullStream) {
-                    await processStreamChunk(chunk, clark, logRef, `api-${apiName}`);
-                }
-                if (thinkingSpanActive) {
-                    services.clarkProfiler.getProfiler().endFrame(apiSubagentTrack);
-                }
-                if (textSpanActive) {
-                    services.clarkProfiler.getProfiler().endFrame(apiSubagentTrack);
-                }
-                try {
-                    const requestTokenData = {
-                        requestId: `api-subagent-${apiName}-${Date.now()}`,
-                        inputTokens: totalInputTokens,
-                        outputTokens: totalOutputTokens,
-                        totalTokens: totalInputTokens + totalOutputTokens,
-                        cachedInputTokens: totalCachedTokens,
-                        model: model.modelId,
-                        startTime: startTime,
-                        endTime: new Date().toISOString(),
+                            }
+                            // Accumulate token usage for this step
+                            if (step.usage) {
+                                const stepInputTokens = step.usage.inputTokens ?? 0;
+                                const stepOutputTokens = step.usage.outputTokens ?? 0;
+                                const stepCachedTokens = step.usage.cachedInputTokens ?? 0;
+                                // Accumulate tokens across all steps
+                                totalInputTokens += stepInputTokens;
+                                totalOutputTokens += stepOutputTokens;
+                                totalCachedTokens += stepCachedTokens;
+                            }
+                            const finalizeApiResult = step.toolResults.find((r) => r.toolName === "finalizeApi");
+                            if (finalizeApiResult) {
+                                finalizeApiData =
+                                    finalizeApiResult.input;
+                            }
+                            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(`API Tool Call: ${tool.toolName}`, apiSubagentTrack, {
+                                        step: stepCount,
+                                        toolIndex: idx + 1,
+                                        toolName: tool.toolName,
+                                        input: parsedInput,
+                                        output: parsedOutput,
+                                        inputSize: tool.input.length,
+                                        outputSize: tool.output.length,
+                                        apiName,
+                                    });
+                                });
+                            }
+                            logRef.content += `\n`;
+                        },
+                        onFinish: (result) => {
+                            context.endTurn(result.totalUsage);
+                            if (mainSystemPrompt) {
+                                // restore main system prompt
+                                context.setSystemPrompt(mainSystemPrompt);
+                            }
+                        },
+                    }, clark.tracer, clark.logger);
+                    for await (const chunk of response.fullStream) {
+                        await processStreamChunk(chunk, clark, logRef, `api-${apiName}`);
+                    }
+                    if (thinkingSpanActive) {
+                        services.clarkProfiler.getProfiler().endFrame(apiSubagentTrack);
+                    }
+                    if (textSpanActive) {
+                        services.clarkProfiler.getProfiler().endFrame(apiSubagentTrack);
+                    }
+                    try {
+                        const requestTokenData = {
+                            requestId: `api-subagent-${apiName}-${Date.now()}`,
+                            inputTokens: totalInputTokens,
+                            outputTokens: totalOutputTokens,
+                            totalTokens: totalInputTokens + totalOutputTokens,
+                            cachedInputTokens: totalCachedTokens,
+                            model: model.modelId,
+                            startTime: startTime,
+                            endTime: new Date().toISOString(),
+                        };
+                        await clark.context.peer?.call.aiPushTokenUsage(requestTokenData);
+                    }
+                    catch (error) {
+                        // Token tracking is non-critical - log error but don't fail the API generation
+                        getLogger().warn("Failed to send token usage data for API generation", error instanceof Error ? error.message : String(error));
+                    }
+                    return {
+                        message: finalizedMessage,
+                        apiName,
+                        pageName,
+                        apiData: finalizeApiData,
                     };
-                    await clark.context.peer?.call.aiPushTokenUsage(requestTokenData);
-                }
-                catch (error) {
-                    // Token tracking is non-critical - log error but don't fail the API generation
-                    getLogger().warn("Failed to send token usage data for API generation", error instanceof Error ? error.message : String(error));
-                }
-                return {
-                    message: finalizedMessage,
+                }, apiSubagentTrack, {
                     apiName,
                     pageName,
-                    apiData: finalizeApiData,
-                };
-            }, apiSubagentTrack, {
-                apiName,
-                pageName,
-                promptLength: apiPrompt.length,
-                model: model.modelId,
-            });
+                    promptLength: apiPrompt.length,
+                    model: model.modelId,
+                });
+            }
+            finally {
+                // Always release the context lock when done
+                contextHandle.release();
+            }
         },
     };
 });