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

package/dist/ai-service/index.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
-import { stepCountIs, streamText as aiStreamText, } from "ai";
+import { generateObject, 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";
@@ -72,7 +72,6 @@ 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, } 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";
@@ -1022,16 +1021,12 @@ 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,
-                            failure: promptFailureFromStreamAbort(clark.context),
-                        });
+                        return clark.send({ type: USER_CANCELED });
                     }
                     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;
@@ -1389,14 +1384,14 @@ export class AiService extends TracedEventEmitter {
     async tryHandlePaywallForRequest(request) {
         try {
             await this.ensureAiQuotaAvailable(request.jwt);
-            return undefined;
+            return false;
         }
         catch (error) {
             if (error instanceof Error) {
                 const reason = getAiQuotaPaywallReasonFromMessage(error.message);
                 if (reason) {
                     await this.handlePreCallPaywall(request, reason);
-                    return reason;
+                    return true;
                 }
             }
             throw error;
@@ -1671,10 +1666,6 @@ 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
@@ -1685,10 +1676,6 @@ 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
@@ -1701,12 +1688,7 @@ 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)
-        const paywallReason = await this.tryHandlePaywallForRequest(request);
-        if (paywallReason) {
-            recordPromptEntryRejection({
-                dedupeKey: resolvePromptRequestDedupeKey(request),
-                failure: promptFailurePaywall(paywallReason),
-            });
+        if (await this.tryHandlePaywallForRequest(request)) {
             return;
         }
         if (request.requestId &&
@@ -1714,7 +1696,6 @@ 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
@@ -1731,20 +1712,14 @@ export class AiService extends TracedEventEmitter {
             });
             // 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
@@ -1779,11 +1754,6 @@ export class AiService extends TracedEventEmitter {
             if (request.requestId) {
                 this.requestDeduplicator.forget(request.requestId);
             }
-            recordPromptOutcome({
-                dedupeKey: resolvePromptRequestDedupeKey(request),
-                outcome: "failure",
-                failure: promptFailurePlatform("handler_error"),
-            });
             throw error;
         }
     }
@@ -2079,7 +2049,7 @@ export class AiService extends TracedEventEmitter {
             application_id: this.config.applicationId,
             session_id: this.sessionId,
         }));
-        const { model, providerConfig } = llmProvider.modelForTask("fast");
+        const { model } = llmProvider.modelForTask("fast");
         const LabelAttachmentSchema = z.object({
             label: z
                 .string()
@@ -2095,31 +2065,21 @@ export class AiService extends TracedEventEmitter {
         try {
             // Build the appropriate content part based on attachment type
             const contentPart = this.attachmentToContentPart(attachment);
-            // 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({
+            const { object: result } = await generateObject({
                 model,
                 schema: LabelAttachmentSchema,
-                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 },
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: "Analyze this attachment and provide a brief label and key insight about its content.",
+                            },
+                            contentPart,
+                        ],
+                    },
+                ],
                 abortSignal: timeoutController.signal,
             });
             const durationMs = Date.now() - startTime;
@@ -2247,44 +2207,17 @@ 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() {
-        const awaitingUser = this.isAwaitingUser();
-        if (!this.isBusy() && !awaitingUser) {
+        if (!this.isBusy()) {
             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,
-            failure: promptFailureUserCanceled(),
-        });
+        void this.clark.send({ type: USER_CANCELED });
     }
     /**
      * UI-initiated cancellation of a background task. Delegates to
@@ -2335,16 +2268,11 @@ 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. Entry metrics
-        // (attempt + pre-call paywall) are recorded in handleAiGenerate or
-        // interruptAndContinue once this proceeds.
+        // interrupt path tears down the in-flight generation. `handleAiGenerate` is
+        // the single recording point and stamps the id 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" };
@@ -2378,10 +2306,7 @@ 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,
-            userInitiatedPromptAbort: true,
-        });
+        this.clark.updateContext({ isInterruptAbort: true });
         this.clark.context.abortController?.abort();
         await this.waitForAbortComplete();
         // Note: `interruptedPreviousGeneration` and `interruptOriginalPrompt`
@@ -2397,8 +2322,6 @@ 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({
@@ -2412,12 +2335,7 @@ 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.
-        const paywallReason = await this.tryHandlePaywallForRequest(request);
-        if (paywallReason) {
-            recordPromptEntryRejection({
-                dedupeKey: resolvePromptRequestDedupeKey(request),
-                failure: promptFailurePaywall(paywallReason),
-            });
+        if (await this.tryHandlePaywallForRequest(request)) {
             return;
         }
         // Only set the interrupt-state fields once we're committed to calling