@superblocksteam/vite-plugin-file-sync 2.0.162 → 2.0.163-next.1

package/dist/ai-service/index.js

@@ -31,6 +31,7 @@ import { NpmPackageLookup } from "./app-interface/npm-package-lookup.js";
 import { NpmRegistryClient, createDiskRegistryPolicyStore, } from "./app-interface/npm-registry.js";
 import { AppShell } from "./app-interface/shell.js";
 import { AppSkillsManager } from "./app-skills/manager.js";
+import { recordAttachmentLabelTruncated } from "./attachment-label-metrics.js";
 import { parseDataUrl } from "./attachments/parse-data-url.js";
 import { isUploadedAttachment, toUploadedAttachmentContentPart, } from "./attachments/uploaded-content-part.js";
 import { ChatSessionStore } from "./chat/chat-session-store.js";
@@ -71,9 +72,11 @@ import { isMigrationSessionActive } from "./migration-session-active.js";
 import { hasSettledNormalMigrationTurn, recordMigrationTurnDispatched, recordMigrationTurnSettled, } from "./migration-turns-log.js";
 import { recordPolicyAgentExecution, } from "./policy-agent-metrics.js";
 import { classifyPolicyGateError } from "./policy-gate-error.js";
+import { buildPolicyGateRemediationUsageMetadata } from "./policy-gate-remediation-usage.js";
 import { policyGateStreamPartToAgentStep } from "./policy-gate-step.js";
 import { ClarkProfiler } from "./profiler/clark-profiler.js";
 import { buildSummarizeApiUsagePrompt } from "./prompts/summarize-api-usage.js";
+import { buildSummarizeDestructiveMigrationPrompt } from "./prompts/summarize-destructive-migration.js";
 import { checkAiQuota } from "./quota-client.js";
 import { RecordingManager, createRecordingFetch } from "./recording/index.js";
 import { RequestDeduplicator } from "./request-deduplicator.js";
@@ -141,6 +144,18 @@ export { isSdkApiTemplate } from "./sdk-api-templates.js";
 export function buildLastKnownPolicyStore(opts) {
     return createDiskRegistryPolicyStore(opts);
 }
+// A label + one-sentence insight only needs the head of a file.
+const LABEL_ATTACHMENT_TRUNCATION_CHARS = 50_000;
+// Back off one char if the cut point falls inside a UTF-16 surrogate pair,
+// so we never emit a lone unpaired surrogate to the model.
+function truncateTextForLabeling(content, maxChars) {
+    let end = maxChars;
+    const code = content.charCodeAt(end - 1);
+    if (code >= 0xd800 && code <= 0xdbff) {
+        end -= 1;
+    }
+    return content.slice(0, end);
+}
 const MAX_POLICY_GATE_STREAM_ERRORS = 5;
 const MAX_POLICY_GATE_STREAM_ERROR_ARRAY_LENGTH = 10;
 const MAX_POLICY_GATE_STREAM_ERROR_FIELD_LENGTH = 500;
@@ -599,9 +614,6 @@ export class AiService extends TracedEventEmitter {
     /**
      * Updates the JWT in Clark context.
      *
-     * A token that expires before the one already installed is ignored, because
-     * primes can arrive out of order.
-     *
      * @returns whether the pod ended up holding a usable token. A rejected token
      *   used to look exactly like one that landed, and like one that was never
      *   sent at all, which is why a run could die holding a credential nobody
@@ -613,11 +625,6 @@ export class AiService extends TracedEventEmitter {
             getLogger().warn(`[ai-service] Rejected an inference JWT (present: ${jwtDetails.present}, hasFederatedToken: ${jwtDetails.hasFederatedToken}, scope: ${jwtDetails.scope ?? "none"})`);
             return false;
         }
-        // Whichever prime finishes last wins. Two overlapping browser
-        // connections can therefore leave the pod holding a token one refresh
-        // generation old, which the next refresh repairs because primes on a
-        // single connection run one at a time and newest-last. Deciding which
-        // connection owns the pod is ENG-6236.
         getLogger().info("[ai-service] Accepted a new inference JWT");
         this.clark.updateContext({ jwt });
         const llmConfig = this.lastMigrationTurnCredentials?.llmConfig ??
@@ -1573,6 +1580,7 @@ export class AiService extends TracedEventEmitter {
     }
     buildContextManagementForCurrentClark(llmConfig) {
         return selectContextManagementStrategy({
+            coreModel: llmConfig?.coreModel,
             serverContextManagementEnabled: llmConfig?.serverContextManagement?.enabled,
             thresholds: llmConfig?.serverContextManagement,
             summarizeModel: () => createLLMProvider(this.getLLMProviderSettings(llmConfig), () => this.getProviderInferenceAuthToken(), llmConfig, () => this.getLlmAiAttributes(this.clark), this.clark.context.traceHeaders).modelForTask("summarizeMessages"),
@@ -2331,10 +2339,15 @@ export class AiService extends TracedEventEmitter {
             outcomeDedupeKey: resolvePromptRequestDedupeKey(request),
             coreModel: request.llmConfig?.coreModel,
         });
+        const requestUsageMetadata = request.importSource
+            ? {
+                origin: CLARK_USAGE_ORIGIN.app_migration,
+                source: request.importSource,
+                surface: "app",
+            }
+            : buildPolicyGateRemediationUsageMetadata(request.policyGateRemediation);
         const generateStreakEligible = resolvePromptMetricLabels({
-            usageMetadata: request.importSource
-                ? { origin: CLARK_USAGE_ORIGIN.app_migration }
-                : undefined,
+            usageMetadata: requestUsageMetadata,
         }).streakEligible;
         // The id is now recorded. If anything below throws before generation is
         // actually kicked off (the `transitionTo` USER_SENT_PROMPT), evict it so a
@@ -2372,17 +2385,10 @@ export class AiService extends TracedEventEmitter {
                     baseCommitId,
                     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.
-                    // Both are app building, so the surface matches the default that
-                    // this object replaces.
-                    usageMetadata: request.importSource
-                        ? {
-                            origin: CLARK_USAGE_ORIGIN.app_migration,
-                            source: request.importSource,
-                            surface: "app",
-                        }
-                        : undefined,
+                    // Explicit per-turn attribution replaces the default in-app Clark
+                    // metadata. Both migration and policy remediation still use the app
+                    // surface, while the origin and IDs make their spend queryable.
+                    usageMetadata: requestUsageMetadata,
                     useMockGeneration: request.mockGeneration ?? false,
                     planContext: mergePlanContexts(context.planContext, request.planContext),
                     browserContext: request.browserContext,
@@ -2678,6 +2684,96 @@ export class AiService extends TracedEventEmitter {
             });
         }
     }
+    async handleAiSummarizeDestructiveMigration(request) {
+        if (this.clark.state === ClarkStateNames.Dead) {
+            throw new Error("Service is unavailable");
+        }
+        const peer = this.clark.context.peer;
+        try {
+            const wantedFiles = [
+                ...new Set(request.findings.map((finding) => finding.fileName)),
+            ];
+            const migrationFiles = {};
+            if (wantedFiles.length > 0) {
+                let sqlPaths = [];
+                try {
+                    sqlPaths = await this.appShell.listFiles(["**/*.sql"]);
+                }
+                catch {
+                    sqlPaths = [];
+                }
+                for (const fileName of wantedFiles) {
+                    const match = sqlPaths.find((sqlPath) => sqlPath === fileName || sqlPath.endsWith(`/${fileName}`));
+                    if (match === undefined) {
+                        continue;
+                    }
+                    try {
+                        migrationFiles[fileName] = await this.appShell.readFile(match);
+                    }
+                    catch {
+                        // The excerpt on the finding is enough when the file cannot be read.
+                    }
+                }
+            }
+            const prompt = buildSummarizeDestructiveMigrationPrompt({
+                findings: request.findings,
+                migrationFiles: Object.keys(migrationFiles).length > 0 ? migrationFiles : undefined,
+                scanUnavailable: request.scanUnavailable,
+            });
+            const llmConfig = request.llmConfig
+                ? {
+                    ...request.llmConfig,
+                    interleavedThinking: false,
+                    thinkingEnabled: false,
+                }
+                : undefined;
+            const { providerOptions, headers } = processLLMConfig(llmConfig, 2000, `AI Summarize Destructive Migration`);
+            const llmProviderSettings = this.getLLMProviderSettings(llmConfig);
+            const llmProvider = createLLMProvider(llmProviderSettings, () => this.requireProvidedInferenceJwt(request.jwt, "live-edit request"), llmConfig, () => helperSystemAiAttributes({
+                applicationId: this.config.applicationId,
+                sessionId: this.sessionId,
+                triggerType: AiSystemTriggerType.DESTRUCTIVE_MIGRATION_SUMMARY,
+            }));
+            const { model, providerConfig } = llmProvider.modelForTask("explain");
+            await traceLLM("handleAiSummarizeDestructiveMigration", model.modelId, model.provider, async () => {
+                try {
+                    const streamResult = await this.llmClient.streamText({
+                        model,
+                        user: { role: "user", content: prompt },
+                        providerOptions,
+                        headers,
+                        providerConfig,
+                        enableFallback: llmConfig?.unifiedProviderEnabled ?? false,
+                    });
+                    for await (const chunk of streamResult.textStream) {
+                        if (chunk) {
+                            await peer.call.aiPushDestructiveMigrationSummary({
+                                summaryKey: request.summaryKey,
+                                delta: chunk,
+                            });
+                        }
+                    }
+                    await peer.call.aiPushDestructiveMigrationSummary({
+                        summaryKey: request.summaryKey,
+                        isComplete: true,
+                    });
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    getLogger().error(`[ai-service] streamText error for destructive migration summary: ${errorMsg}`);
+                    throw error;
+                }
+            }, {}, llmobs);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            getLogger().error(`[ai-service] Error summarizing destructive migrations: ${errorMessage}`, getErrorMeta(error));
+            await peer.call.aiPushDestructiveMigrationSummary({
+                summaryKey: request.summaryKey,
+                error: "Failed to generate destructive migration summary",
+            });
+        }
+    }
     async handleAiLabelAttachment(request) {
         const logger = getLogger();
         const startTime = Date.now();
@@ -2824,9 +2920,20 @@ export class AiService extends TracedEventEmitter {
                 .replace(/'/g, "&apos;")
                 .replace(/</g, "&lt;")
                 .replace(/>/g, "&gt;");
+            // Cap content sent for labeling only; the model never sees the rest.
+            const isTruncated = normalizedTextAttachment.content.length >
+                LABEL_ATTACHMENT_TRUNCATION_CHARS;
+            const content = isTruncated
+                ? truncateTextForLabeling(normalizedTextAttachment.content, LABEL_ATTACHMENT_TRUNCATION_CHARS) + "\n...[truncated]"
+                : normalizedTextAttachment.content;
+            if (isTruncated) {
+                recordAttachmentLabelTruncated({
+                    mimeType: normalizedTextAttachment.mimeType,
+                });
+            }
             return {
                 type: "text",
-                text: `<${normalizedTextAttachment.tagName}_file name="${sanitizedFileName}" mimeType="${sanitizedMimeType}">\n${normalizedTextAttachment.content}\n</${normalizedTextAttachment.tagName}_file>`,
+                text: `<${normalizedTextAttachment.tagName}_file name="${sanitizedFileName}" mimeType="${sanitizedMimeType}">\n${content}\n</${normalizedTextAttachment.tagName}_file>`,
             };
         }
         throw new Error(`Unsupported attachment type: ${attachment.type}`);
@@ -3811,6 +3918,13 @@ export class AiService extends TracedEventEmitter {
         if (this.taskStore) {
             this.pendingTaskResyncPeerIds.add(peerId);
         }
+        // 4. Close out tool calls the transcript still reports as running but
+        //    that no process is executing (ENG-6785). Does not gate the connect
+        //    handshake: the peer is already bound, and the reconcile is several
+        //    RPCs long. Reconnect `getMessages({ force })` joins this promise so
+        //    the open tab's history reload includes the repair. A failed load or
+        //    push retries on a later bind.
+        void this.chatSessionStore.reconcileAbandonedToolCalls();
         this.tryAutoDispatchMigrationTurnIfReady();
     }
     /**
@@ -3939,6 +4053,46 @@ export class AiService extends TracedEventEmitter {
         }
         this.clearPeerConnection();
     }
+    /**
+     * A lifecycle transition failed after potentially replacing the transport.
+     * The socket manager no longer has a trustworthy owner to disconnect by ID.
+     * Drop the actual binding even if context disposal fails; the caller must
+     * retry this cleanup successfully before allowing another editor to bind.
+     */
+    resetEditorConnection() {
+        try {
+            const contextId = this.getContextId();
+            if (contextId)
+                this.contextManagerV2.clearContext(contextId);
+        }
+        finally {
+            this.pendingTaskResyncPeerIds.clear();
+            this.authenticatedPeerUserId = undefined;
+            this.authenticatedPeerId = undefined;
+            this.clearPeerConnection();
+            this.stablePeer.closeAndRejectPendingRequests();
+        }
+    }
+    /**
+     * The bound editor's transport is gone, but a reconnect for the same peer
+     * is already open and on its way to proving its authorization. The
+     * conversation stays: only the socket is dropped, so calls made in the
+     * meantime queue on the StablePeer and flush when that reconnect binds,
+     * instead of being written into a dead connection. The peer identity is
+     * kept, so the full teardown in `handleUserDisconnected` still recognizes
+     * the peer when the last socket for it closes.
+     */
+    detachPeerTransport(peerId) {
+        if (this.stablePeer.peerId !== peerId) {
+            this.getLogger().debug("[ai-service] Ignored detach for a different peer", {
+                "peer.id": peerId,
+                "peer.bound_id": this.stablePeer.peerId,
+            });
+            return;
+        }
+        this.getLogger().info(`[ai-service] Editor transport detached while peer ${peerId} reconnects`);
+        this.stablePeer.detachTransport();
+    }
     clearPeerConnection() {
         this.getLogger().info(`[ai-service] Clearing peer connection`);
         // The StablePeer reference on `clark.context.peer` stays — we only mark