@superblocksteam/vite-plugin-file-sync 2.0.139 → 2.0.140-next.1

package/dist/ai-service/index.js

@@ -1,7 +1,8 @@
 import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
-import { generateObject, stepCountIs, streamText as aiStreamText, } from "ai";
+import { context as otelContext, propagation, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { stepCountIs, streamText as aiStreamText, } from "ai";
 import { z } from "zod";
 import { AiGenerationState, AiMode, resolveAttachmentFileName, } from "@superblocksteam/library-shared/types";
 import { addTracingToMethods, classifyAttachmentDelivery, FactAccessType, FactCreatedSource, FactEntityScope, TracedEventEmitter, getAiQuotaPaywallReasonFromMessage, } from "@superblocksteam/shared";
@@ -47,7 +48,7 @@ import { selectContextManagementStrategy, } from "./llm/context-v2/context-manag
 import { ContextManagerV2 } from "./llm/context-v2/manager.js";
 import { JsonlEventStore } from "./llm/context-v2/storage/jsonl-event-store.js";
 import { LocalContextStorageV2 } from "./llm/context-v2/storage/local.js";
-import { createLLMProvider } from "./llm/provider.js";
+import { createLLMProvider, setSpanError } from "./llm/provider.js";
 import { traceLLM } from "./llmobs/helpers.js";
 import { getJwtTraceTags } from "./llmobs/helpers.js";
 import llmobs from "./llmobs/index.js";
@@ -72,6 +73,7 @@ import { classificationHelper } from "./state-machine/helpers/classification.js"
 import { getContextId } from "./state-machine/helpers/context-id.js";
 import { sendUserGenerationStateChannel } from "./state-machine/helpers/peer.js";
 import { sendUserMessageChannel, clearPendingToolPermissionRequest, } from "./state-machine/helpers/peer.js";
+import { promptFailureFromStreamAbort, promptFailurePaywall, promptFailurePlatform, promptFailureUserCanceled, recordPromptAttempt, recordPromptEntryRejection, recordPromptOutcome, recordAwaitingUserHandoffDismissed, resolvePromptOutcomeDedupeKey, resolvePromptRequestDedupeKey, setPromptRequestMetricIdentity, } from "./state-machine/helpers/prompt-request-metrics.js";
 import { catchBackgroundPeerDisconnect, StablePeer, } from "./state-machine/helpers/stable-peer.js";
 import { transitionFrom } from "./state-machine/helpers/transition.js";
 import { isTaskAccessibleTo, registerBackgroundTaskTypes, resyncActiveTaskStatusesToPeer, TaskStore, wireTaskStatusPushToPeer, } from "./tasks/index.js";
@@ -326,6 +328,7 @@ export class AiService extends TracedEventEmitter {
     requestDeduplicator = new RequestDeduplicator();
     entityPermissionStore = new SessionEntityPermissionStore();
     _onGenerationCompleteCallback;
+    activeGenerationTrace;
     /** JWT-derived userId of the currently-authenticated peer, set by
      * `notifyAuthenticatedRpc` and cleared on disconnect / peer swap.
      * Only trusted while `authenticatedPeerId` still matches the bound
@@ -510,6 +513,10 @@ export class AiService extends TracedEventEmitter {
         super(config.tracer);
         this.config = config;
         setDefaultLogger(config.logger);
+        setPromptRequestMetricIdentity({
+            applicationId: config.applicationId,
+            organizationId: config.organizationId,
+        });
         // Store the wrapped logger so getLogger() can return it
         // The wrapped logger forwards logs to the browser console when Clark logs are enabled
         this._logger = getLogger();
@@ -923,6 +930,67 @@ export class AiService extends TracedEventEmitter {
         // when Clark logs are enabled (via ?clark_logs=true or SUPERBLOCKS_CLI_ENV=local)
         return this._logger;
     }
+    startGenerationTrace(request, promptId) {
+        // A span still open here means the previous run never reached a terminal
+        // transition. Close it now so its listeners cannot fire on this run's
+        // events.
+        this.activeGenerationTrace?.finish();
+        const parentContext = otelContext.active();
+        const span = this.config.tracer.startSpan("AiService.generation", {
+            attributes: {
+                "ai.mode": request.mode,
+                "ai.model": request.llmConfig?.coreModel,
+                "ai.provider": request.llmConfig?.provider,
+                "app.id": this.config.applicationId,
+                "org.id": this.config.organizationId,
+            },
+            kind: SpanKind.INTERNAL,
+        }, parentContext);
+        const spanContext = trace.setSpan(parentContext, span);
+        const traceHeaders = {};
+        propagation.inject(spanContext, traceHeaders);
+        let finished = false;
+        const finish = (error) => {
+            if (finished)
+                return;
+            finished = true;
+            this.off("generationCompleted", onCompleted);
+            this.off("generationFailed", onFailed);
+            if (this.activeGenerationTrace === generationTrace) {
+                this.activeGenerationTrace = undefined;
+            }
+            if (error === undefined) {
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            else {
+                setSpanError(span, error);
+            }
+            span.end();
+        };
+        // Only end this span for its own run: generationCompleted carries the
+        // generation id, so a stale listener cannot close a later run's span.
+        // generationFailed carries no id, but a stale listener cannot survive
+        // into the next run either way — the span is finished (removing both
+        // listeners) when the FSM parks and, as a backstop, when the next run
+        // starts.
+        const onCompleted = (_producedDraft, generationId) => {
+            if (generationId === promptId) {
+                finish();
+            }
+        };
+        const onFailed = (error) => finish(error);
+        this.on("generationCompleted", onCompleted);
+        this.on("generationFailed", onFailed);
+        const generationTrace = {
+            context: spanContext,
+            finish,
+            traceHeaders: traceHeaders.traceparent || traceHeaders.tracestate
+                ? traceHeaders
+                : undefined,
+        };
+        this.activeGenerationTrace = generationTrace;
+        return generationTrace;
+    }
     createClarkTransitionHandler() {
         const clarkStateHandlerFactories = {
             Idle: doIdle,
@@ -960,7 +1028,7 @@ export class AiService extends TracedEventEmitter {
                     integrationStore: this.integrationStore,
                     knowledgeManager: this.knowledgeManager,
                     appContextStore: this.appContext,
-                    llmProvider: createLLMProvider(this.getLLMProviderSettings(clark.context.llmConfig), () => this.requireInferenceJwt(), clark.context.llmConfig, () => this.getLlmAiAttributes(clark)),
+                    llmProvider: createLLMProvider(this.getLLMProviderSettings(clark.context.llmConfig), () => this.requireInferenceJwt(), clark.context.llmConfig, () => this.getLlmAiAttributes(clark), clark.context.traceHeaders),
                     chatSessionStore: this.chatSessionStore,
                     clarkProfiler: this.clarkProfiler,
                     contextManagerV2: this.contextManagerV2,
@@ -1021,12 +1089,16 @@ export class AiService extends TracedEventEmitter {
                     if (clark.context.abortController?.signal.aborted &&
                         event.type !== USER_CANCELED &&
                         event.type !== AGENT_CANCELED) {
-                        return clark.send({ type: USER_CANCELED });
+                        return clark.send({
+                            type: USER_CANCELED,
+                            failure: promptFailureFromStreamAbort(clark.context),
+                        });
                     }
                     if (event.type !== AGENT_CANCELED) {
                         return clark.send({
                             type: AGENT_CANCELED,
                             advice: `An unexpected error occurred. Please try again.`,
+                            failure: promptFailurePlatform("handler_error"),
                         });
                     }
                     throw error;
@@ -1134,7 +1206,7 @@ export class AiService extends TracedEventEmitter {
         return selectContextManagementStrategy({
             serverContextManagementEnabled: llmConfig?.serverContextManagement?.enabled,
             thresholds: llmConfig?.serverContextManagement,
-            summarizationModel: () => createLLMProvider(this.getLLMProviderSettings(llmConfig), () => this.getInferenceJwt(), llmConfig, () => this.getLlmAiAttributes(this.clark)).modelForTask("summarizeMessages").model,
+            summarizationModel: () => createLLMProvider(this.getLLMProviderSettings(llmConfig), () => this.getInferenceJwt(), llmConfig, () => this.getLlmAiAttributes(this.clark), this.clark.context.traceHeaders).modelForTask("summarizeMessages").model,
         });
     }
     getLlmAiAttributes(clark) {
@@ -1384,14 +1456,14 @@ export class AiService extends TracedEventEmitter {
     async tryHandlePaywallForRequest(request) {
         try {
             await this.ensureAiQuotaAvailable(request.jwt);
-            return false;
+            return undefined;
         }
         catch (error) {
             if (error instanceof Error) {
                 const reason = getAiQuotaPaywallReasonFromMessage(error.message);
                 if (reason) {
                     await this.handlePreCallPaywall(request, reason);
-                    return true;
+                    return reason;
                 }
             }
             throw error;
@@ -1666,6 +1738,10 @@ export class AiService extends TracedEventEmitter {
     async handleAiGenerate(request) {
         this.getLogger().info(`[ai-service] handleAiGenerate: peerId=${this.stablePeer.peerId ?? "unknown"}`);
         if (this.clark.state === ClarkStateNames.Dead) {
+            recordPromptEntryRejection({
+                dedupeKey: resolvePromptRequestDedupeKey(request),
+                failure: promptFailurePlatform("service_dead"),
+            });
             throw new Error("Service is unavailable");
         }
         // a reconnect can cause the client to re-send this prompt
@@ -1676,6 +1752,10 @@ export class AiService extends TracedEventEmitter {
         this.assertNoActivePolicyGateRun();
         if (this.isBusy()) {
             this.getLogger().warn("[ai-service] Service is busy. State:", this.clark.state);
+            recordPromptEntryRejection({
+                dedupeKey: resolvePromptRequestDedupeKey(request),
+                failure: promptFailurePlatform("service_busy"),
+            });
             throw new Error("Service is busy");
         }
         // Pre-call quota check. When denied, `ensureAiQuotaAvailable` throws so
@@ -1688,7 +1768,12 @@ export class AiService extends TracedEventEmitter {
         // advice + open modal via the same `aiSetGenerationState(CANCELLED,
         // paywallReason)` saga path the mid-stream paywall uses, then resolve
         // the socket call so the UI's catch doesn't run. (APPS-4080)
-        if (await this.tryHandlePaywallForRequest(request)) {
+        const paywallReason = await this.tryHandlePaywallForRequest(request);
+        if (paywallReason) {
+            recordPromptEntryRejection({
+                dedupeKey: resolvePromptRequestDedupeKey(request),
+                failure: promptFailurePaywall(paywallReason),
+            });
             return;
         }
         if (request.requestId &&
@@ -1696,11 +1781,18 @@ export class AiService extends TracedEventEmitter {
             this.getLogger().warn("[ai-service] Ignoring duplicate aiGenerate re-send (lost dedup race)", { requestId: request.requestId });
             return;
         }
+        recordPromptAttempt(resolvePromptRequestDedupeKey(request));
         // The id is now recorded. If anything below throws before generation is
         // actually kicked off (the `transitionTo` USER_SENT_PROMPT), evict it so a
         // legitimate reconnect re-send of this same prompt is not swallowed as a
         // duplicate while nothing is running. (APPS-4663)
+        let generationTrace;
         try {
+            // Generate prompt_id for this user interaction. It doubles as the
+            // generation id on terminal events, so the trace needs it up front.
+            const promptId = randomUUID();
+            generationTrace = this.startGenerationTrace(request, promptId);
+            const activeGenerationTrace = generationTrace;
             this.clarkProfiler.startSession();
             getLogger().info("AI Service received request with llmConfig:", request.llmConfig || {});
             getLogger().info("[ai-service] handleAiGenerate received request", {
@@ -1710,16 +1802,20 @@ export class AiService extends TracedEventEmitter {
                 existingPlanContextApproved: this.clark.context.planContext?.approved,
                 responseMetadataType: request.responseMetadata?.type,
             });
-            // Generate prompt_id for this user interaction
-            const promptId = randomUUID();
+            const promptOutcomeDedupeKey = resolvePromptRequestDedupeKey(request);
             getLogger().info("[ai-service] Generated prompt_id for user interaction", {
                 promptId,
+                requestId: request.requestId,
+                dedupeKeySource: request.requestId ? "requestId" : "ephemeral",
                 applicationId: this.config.applicationId,
             });
             this.clark.updateContext((context) => {
                 return {
                     ...context,
                     promptId,
+                    promptOutcomeDedupeKey,
+                    isInterruptAbort: undefined,
+                    userInitiatedPromptAbort: undefined,
                     // Third-party import turns are billed as app_migration; everything
                     // else falls back to the default in-app Clark generation metadata.
                     usageMetadata: request.importSource
@@ -1740,20 +1836,42 @@ export class AiService extends TracedEventEmitter {
                         workflowStartedAt: new Date().toISOString(),
                     },
                     llmConfig: request.llmConfig,
+                    traceHeaders: activeGenerationTrace.traceHeaders,
                     partialResponse: undefined,
                     userPreferences: request.userPreferences,
                 };
             });
             const transitionTo = transitionFrom(this.clark);
-            void transitionTo({
+            void otelContext
+                .with(activeGenerationTrace.context, () => Promise.resolve(transitionTo({
                 type: USER_SENT_PROMPT,
                 request,
+            })))
+                .catch((error) => {
+                activeGenerationTrace.finish(error);
+                if (request.requestId) {
+                    this.requestDeduplicator.forget(request.requestId);
+                }
+                recordPromptOutcome({
+                    dedupeKey: promptOutcomeDedupeKey,
+                    outcome: "failure",
+                    failure: promptFailurePlatform("handler_error"),
+                });
+                this.getLogger().error("[ai-service] Failed to start generation", {
+                    error,
+                });
             });
         }
         catch (error) {
+            generationTrace?.finish(error);
             if (request.requestId) {
                 this.requestDeduplicator.forget(request.requestId);
             }
+            recordPromptOutcome({
+                dedupeKey: resolvePromptRequestDedupeKey(request),
+                outcome: "failure",
+                failure: promptFailurePlatform("handler_error"),
+            });
             throw error;
         }
     }
@@ -2049,7 +2167,7 @@ export class AiService extends TracedEventEmitter {
             application_id: this.config.applicationId,
             session_id: this.sessionId,
         }));
-        const { model } = llmProvider.modelForTask("fast");
+        const { model, providerConfig } = llmProvider.modelForTask("fast");
         const LabelAttachmentSchema = z.object({
             label: z
                 .string()
@@ -2065,21 +2183,31 @@ export class AiService extends TracedEventEmitter {
         try {
             // Build the appropriate content part based on attachment type
             const contentPart = this.attachmentToContentPart(attachment);
-            const { object: result } = await generateObject({
+            // Route labeling through the shared LLMClient (APPS-5061) as a stateless
+            // one-shot, mirroring the APPS-1213 (#20263) migrations. No safety config:
+            // labeling had no safety pass before this migration, and redacting the
+            // upload before the model would defeat labeling (the model must see it).
+            // Upload content can still carry secrets, so we keep it out of telemetry
+            // via recordObsContent: false rather than via a safety pass.
+            const result = await this.llmClient.generateObject({
                 model,
                 schema: LabelAttachmentSchema,
-                messages: [
-                    {
-                        role: "user",
-                        content: [
-                            {
-                                type: "text",
-                                text: "Analyze this attachment and provide a brief label and key insight about its content.",
-                            },
-                            contentPart,
-                        ],
-                    },
-                ],
+                context: { mode: "stateless" },
+                // Raw user data may carry secrets; keep it out of LLMObs span content
+                // (metrics/model/timing are still recorded).
+                recordObsContent: false,
+                user: {
+                    role: "user",
+                    content: [
+                        {
+                            type: "text",
+                            text: "Analyze this attachment and provide a brief label and key insight about its content.",
+                        },
+                        contentPart,
+                    ],
+                },
+                providerConfig,
+                retry: { maxAttempts: 2 },
                 abortSignal: timeoutController.signal,
             });
             const durationMs = Date.now() - startTime;
@@ -2207,17 +2335,44 @@ export class AiService extends TracedEventEmitter {
         await this.clark.recordSystemMessage(params, "Environment event", "User closed the integration setup form. The integration setup might not have been completed successfully.");
     }
     async handleUserCanceled() {
-        if (!this.isBusy()) {
+        const awaitingUser = this.isAwaitingUser();
+        if (!this.isBusy() && !awaitingUser) {
             return;
         }
+        this.clark.updateContext((context) => ({
+            ...context,
+            userInitiatedPromptAbort: true,
+        }));
         this.clark.context.abortController?.abort();
+        if (this.isBusy()) {
+            recordPromptOutcome({
+                dedupeKey: resolvePromptOutcomeDedupeKey(this.clark.context),
+                outcome: "failure",
+                failure: promptFailureUserCanceled(),
+            });
+        }
+        if (awaitingUser && this.clark.context.awaitingUserHandoffRecorded) {
+            recordAwaitingUserHandoffDismissed({
+                awaitingUserHandoffPromptId: this.clark.context.awaitingUserHandoffPromptId,
+                awaitingUserHandoffRecorded: this.clark.context.awaitingUserHandoffRecorded,
+                promptId: this.clark.context.promptId,
+                promptOutcomeDedupeKey: this.clark.context.promptOutcomeDedupeKey,
+                reason: "cancel",
+            });
+        }
         // Clear the prompt_id since this prompt was abandoned
         this.clark.updateContext((context) => ({
             ...context,
             promptId: undefined,
+            promptOutcomeDedupeKey: undefined,
             usageMetadata: undefined,
+            awaitingUserHandoffPromptId: undefined,
+            awaitingUserHandoffRecorded: undefined,
         }));
-        void this.clark.send({ type: USER_CANCELED });
+        void this.clark.send({
+            type: USER_CANCELED,
+            failure: promptFailureUserCanceled(),
+        });
     }
     /**
      * UI-initiated cancellation of a background task. Delegates to
@@ -2268,11 +2423,16 @@ export class AiService extends TracedEventEmitter {
     async handleAiGenerateWithQueue(request, mode) {
         this.getLogger().info(`[ai-service] handleAiGenerateWithQueue: peerId=${this.stablePeer.peerId ?? "unknown"}, mode=${mode}`);
         if (this.clark.state === ClarkStateNames.Dead) {
+            recordPromptEntryRejection({
+                dedupeKey: resolvePromptRequestDedupeKey(request),
+                failure: promptFailurePlatform("service_dead"),
+            });
             throw new Error("Service is unavailable");
         }
         // peek (do not record) so a re-sent prompt is dropped before the
-        // interrupt path tears down the in-flight generation. `handleAiGenerate` is
-        // the single recording point and stamps the id once this proceeds.
+        // interrupt path tears down the in-flight generation. Entry metrics
+        // (attempt + pre-call paywall) are recorded in handleAiGenerate or
+        // interruptAndContinue once this proceeds.
         if (request.requestId && this.requestDeduplicator.has(request.requestId)) {
             this.getLogger().info("[ai-service] Ignoring duplicate aiGenerateWithQueue re-send", { requestId: request.requestId, mode });
             return { status: "started" };
@@ -2306,7 +2466,10 @@ export class AiService extends TracedEventEmitter {
             availableIntegrations: this.clark.context.availableIntegrations,
         };
         this.getLogger().info(`[ai-service] Interrupting current generation. Partial response length: ${partialResponse.length}`);
-        this.clark.updateContext({ isInterruptAbort: true });
+        this.clark.updateContext({
+            isInterruptAbort: true,
+            userInitiatedPromptAbort: true,
+        });
         this.clark.context.abortController?.abort();
         await this.waitForAbortComplete();
         // Note: `interruptedPreviousGeneration` and `interruptOriginalPrompt`
@@ -2322,6 +2485,8 @@ export class AiService extends TracedEventEmitter {
             availableIntegrations: preservedContext.availableIntegrations,
             abortController: new AbortController(),
             partialResponse: undefined,
+            isInterruptAbort: undefined,
+            userInitiatedPromptAbort: undefined,
         });
         if (partialResponse.trim().length > 10) {
             await this.chatSessionStore.recordAssistant({
@@ -2335,7 +2500,12 @@ export class AiService extends TracedEventEmitter {
         // `handleAiGenerate`. The aborted run is NOT resumed; the user can
         // start fresh once credits are restored via the same "send any
         // message" affordance the standard paywall uses.
-        if (await this.tryHandlePaywallForRequest(request)) {
+        const paywallReason = await this.tryHandlePaywallForRequest(request);
+        if (paywallReason) {
+            recordPromptEntryRejection({
+                dedupeKey: resolvePromptRequestDedupeKey(request),
+                failure: promptFailurePaywall(paywallReason),
+            });
             return;
         }
         // Only set the interrupt-state fields once we're committed to calling
@@ -3636,6 +3806,11 @@ export class AiService extends TracedEventEmitter {
      * Should be called when Clark transitions to Idle or AwaitingUser state.
      */
     triggerGenerationComplete() {
+        // The FSM parked, so any still-open generation span is over. Runs that
+        // completed or failed already ended it via the generation events; this
+        // ends it on the paths that emit neither (user/agent cancel,
+        // runtime-updated-without-edits, planning errors that park in Idle).
+        this.activeGenerationTrace?.finish();
         if (this._onGenerationCompleteCallback) {
             const callback = this._onGenerationCompleteCallback;
             this._onGenerationCompleteCallback = undefined;