@vibes.diy/api-svc 2.2.7 → 2.2.9

package/public/prompt-chat-section.js

@@ -6,10 +6,11 @@ import { type } from "arktype";
 import { checkAuth } from "../check-auth.js";
 import { unwrapMsgBase, wrapMsgBase } from "../unwrap-msg-base.js";
 import { and, desc, eq } from "drizzle-orm/sql/expressions";
-import { applyEdits, createStatsCollector, createLineStream, createDataStream, createSseStream, createDeltaStream, createSectionsStream, isBlockEnd, isCodeBegin, isCodeEnd, isCodeLine, isToplevelLine, parseFenceBody, FileSystemRef, isBlockStreamMsg, isBlockImage, } from "@vibes.diy/call-ai-v2";
-import { makeBaseSystemPrompt, resolveEffectiveModel } from "@vibes.diy/prompts";
+import { applyEdits, createStatsCollector, createLineStream, createDataStream, createSseStream, createDeltaStream, createSectionsStream, isBlockEnd, isCodeBegin, isCodeEnd, isCodeLine, isDeltaLine, isToplevelLine, parseFenceBody, FileSystemRef, isBlockStreamMsg, isBlockImage, } from "@vibes.diy/call-ai-v2";
+import { getRecoveryAddendum, getRecoveryStitchAddendum, makeBaseSystemPrompt, resolveEffectiveModel } from "@vibes.diy/prompts";
 import { ensureAppSlugItem } from "./ensure-app-slug-item.js";
 import { getModelDefaults } from "../intern/get-model-defaults.js";
+import { buildRecoveryRequest, buildTruncatedEvent, shouldAttemptRecovery, updateRecoveryCounter, } from "../intern/recovery.js";
 export function createPromptAssetFetch(deps) {
     return async (url, _init) => {
         const uri = URI.from(url);
@@ -94,6 +95,97 @@ export function resolveCodeBlocksToFileSystem(blocks, seed) {
     }
     return result;
 }
+function normalizeFilename(rawPath) {
+    const path = rawPath ?? "App.jsx";
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function searchPrefixOf(search) {
+    const firstLine = search.split("\n").find((l) => l.trim().length > 0) ?? "";
+    return firstLine.length > 80 ? `${firstLine.slice(0, 80)}…` : firstLine;
+}
+export function createStreamingResolver(deps) {
+    const vfs = new Map();
+    const seedFor = (filename, rawPath) => {
+        return deps.seed.get(filename) ?? deps.seed.get(rawPath) ?? "";
+    };
+    return {
+        observeBlock(block) {
+            const rawPath = block.begin.path ?? "App.jsx";
+            const filename = normalizeFilename(rawPath);
+            const current = vfs.has(filename) ? (vfs.get(filename) ?? "") : seedFor(filename, rawPath);
+            const parsed = parseFenceBody(block.lines.map((l) => l.line));
+            const errors = [];
+            for (const fenceErr of parsed.errors) {
+                const evt = {
+                    chatId: deps.chatId,
+                    promptId: deps.promptId,
+                    blockId: block.end.blockId,
+                    sectionId: block.end.sectionId,
+                    kind: "fence-parse",
+                    reason: fenceErr.kind,
+                };
+                deps.onApplyError(evt);
+                errors.push(evt);
+            }
+            const applied = applyEdits(current, parsed.edits);
+            for (const applyErr of applied.errors) {
+                const evt = {
+                    chatId: deps.chatId,
+                    promptId: deps.promptId,
+                    blockId: block.end.blockId,
+                    sectionId: block.end.sectionId,
+                    kind: "apply",
+                    reason: applyErr.reason,
+                    searchPrefix: searchPrefixOf(applyErr.search),
+                };
+                deps.onApplyError(evt);
+                errors.push(evt);
+            }
+            vfs.set(filename, applied.content);
+            return { path: filename, errors };
+        },
+        getVfs() {
+            return new Map(vfs);
+        },
+    };
+}
+export function createBlockAccumulator() {
+    const open = new Map();
+    return {
+        ingest(msg) {
+            if (isCodeBegin(msg)) {
+                open.set(msg.blockId, { begin: msg, lines: [] });
+                return undefined;
+            }
+            if (isCodeLine(msg)) {
+                open.get(msg.blockId)?.lines.push(msg);
+                return undefined;
+            }
+            if (isCodeEnd(msg)) {
+                const acc = open.get(msg.blockId);
+                if (!acc)
+                    return undefined;
+                open.delete(msg.blockId);
+                return { begin: acc.begin, lines: acc.lines, end: msg };
+            }
+            return undefined;
+        },
+    };
+}
+export function logApplyError(logger, evt) {
+    logger
+        .Debug()
+        .Any({
+        chatId: evt.chatId,
+        promptId: evt.promptId,
+        blockId: evt.blockId,
+        sectionId: evt.sectionId,
+        kind: evt.kind,
+        reason: evt.reason,
+        ...(evt.searchPrefix === undefined ? {} : { searchPrefix: evt.searchPrefix }),
+    })
+        .Msg("apply-error");
+}
 async function appendBlockEvent({ ctx, vctx, req, promptId, blockSeq, evt, emitMode = "store", }) {
     if (isBlockImage(evt)) {
         const imgEvt = evt;
@@ -156,6 +248,7 @@ export async function handlePromptContext({ vctx, req, resChat, promptId, blockS
     const code = [];
     const sections = [];
     const collectedMsgs = [...iCollectedMsgs];
+    const blockAcc = createBlockAccumulator();
     for (const msg of collectedMsgs) {
         if (!isBlockStreamMsg(msg)) {
             continue;
@@ -172,25 +265,9 @@ export async function handlePromptContext({ vctx, req, resChat, promptId, blockS
             sqlVal = sections[sections.length - 1];
         }
         sqlVal.blocks.push(msg);
-        if (isCodeBegin(msg)) {
-            code.push({ begin: msg, lines: [] });
-        }
-        else if (isCodeLine(msg)) {
-            if (code.length === 0) {
-                console.warn("Received code line without a preceding code begin:", msg);
-            }
-            else {
-                code[code.length - 1].lines.push(msg);
-            }
-        }
-        else if (isCodeEnd(msg)) {
-            if (code.length === 0) {
-                console.warn("Received code end without a preceding code begin:", msg);
-            }
-            else {
-                code[code.length - 1].end = msg;
-            }
-        }
+        const closed = blockAcc.ingest(msg);
+        if (closed)
+            code.push({ begin: closed.begin, lines: [...closed.lines], end: closed.end });
     }
     if (code.length > 0 && (resChat.mode === "chat" || isPromptFSStyle(resChat.mode))) {
         let resolvedFileSystem;
@@ -325,10 +402,13 @@ async function injectSystemPrompt(vctx, chatId, model) {
     }
     const conversationMessages = reconstructConversationMessages(allSectionMsgs);
     const { skills, title } = await loadActiveSettings(vctx, chatId);
+    const priorFs = await loadPriorFileSystem(vctx, chatId);
+    const isInitial = priorFs.size === 0;
     const systemPrompt = await exception2Result(async () => makeBaseSystemPrompt(await resolveEffectiveModel({ model }, {}), {
         skills,
         title,
         demoData: false,
+        variant: isInitial ? "initial" : "continuation",
         pkgBaseUrl: promptsPkgBaseUrl(vctx.params.pkgRepos.workspace),
         fetch: createPromptAssetFetch({ fetchAsset: vctx.fetchAsset }),
     }));
@@ -483,9 +563,10 @@ async function handlerLlmRequest({ scope, ctx, vctx, blockSeq, req, resChat, pro
         ...(isInitialTurn && req.mode === "chat" ? { verbosity: "low" } : {}),
         ...(req.mode === "img" ? { modalities: ["text", "image"] } : {}),
     };
+    const abort = new AbortController();
     const res = await scope
         .evalResult(async () => {
-        const res = await vctx.llmRequest(llmReq);
+        const res = await vctx.llmRequest(llmReq, { signal: abort.signal });
         if (!res.ok) {
             return Result.Err(`LLM request failed with status ${res.status} :${llmReq.model} : ${res.statusText}`);
         }
@@ -495,7 +576,7 @@ async function handlerLlmRequest({ scope, ctx, vctx, blockSeq, req, resChat, pro
         return Result.Ok(res);
     })
         .do();
-    return { res, blockSeq };
+    return { res, blockSeq, llmReq, abort };
 }
 async function handleProdiaImageRequest({ scope, ctx, vctx, req, promptId, blockSeq, resolvedModel, }) {
     const prodiaToken = vctx.prodiaToken;
@@ -697,27 +778,17 @@ async function handleEndMsg({ collectedMsgs, vctx, req, ctx, resChat, promptId,
     }
     return Result.Ok(blockSeq);
 }
-async function handleLlmResponse({ scope, vctx, req, ctx, res, resChat, promptId, blockSeq, }) {
+async function handleLlmResponse({ scope, vctx, req, ctx, res, resChat, promptId, blockSeq, llmReq, abort, }) {
     await scope
         .evalResult(async () => {
-        const pipeline = res
-            .body.pipeThrough(createStatsCollector(promptId, 1000))
-            .pipeThrough(createLineStream(promptId))
-            .pipeThrough(createDataStream(promptId))
-            .pipeThrough(createSseStream(promptId))
-            .pipeThrough(createDeltaStream(promptId, () => vctx.sthis.nextId(12).str))
-            .pipeThrough(createSectionsStream(promptId, () => vctx.sthis.nextId(12).str));
-        const reader = pipeline.getReader();
         let collectedMsgs;
-        let chatCtx;
         for (const conn of vctx.connections) {
             const tChatCtx = conn.chatIds.get(req.chatId);
             if (tChatCtx) {
-                chatCtx = tChatCtx;
-                const promptIdCtx = chatCtx.promptIds.get(promptId);
+                const promptIdCtx = tChatCtx.promptIds.get(promptId);
                 if (!promptIdCtx) {
                     collectedMsgs = [];
-                    chatCtx.promptIds.set(promptId, {
+                    tChatCtx.promptIds.set(promptId, {
                         blocks: collectedMsgs,
                         promptId,
                         type: "vibes.diy.section-event",
@@ -734,40 +805,301 @@ async function handleLlmResponse({ scope, vctx, req, ctx, res, resChat, promptId
         if (!collectedMsgs) {
             return Result.Err(`Chat context not found for chatId: ${req.chatId}`);
         }
+        const seedForResolver = await loadPriorFileSystem(vctx, req.chatId);
+        const resolverLogger = ensureLogger(vctx.sthis, "streamingResolver");
+        const recoveryLogger = ensureLogger(vctx.sthis, "applyRecovery");
+        const streamingResolver = createStreamingResolver({
+            chatId: req.chatId,
+            promptId,
+            seed: seedForResolver,
+            onApplyError: (evt) => logApplyError(resolverLogger, evt),
+        });
+        const blockAcc = createBlockAccumulator();
+        let recoveryCounter = { consecutiveFruitless: 0 };
+        let isRecoveryStream = false;
+        let currentRes = res;
+        let currentAbort = abort;
         while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            if (!isBlockEnd(value)) {
-                if (!isBlockStreamMsg(value)) {
+            let streamMadeProgress = false;
+            const partialBuffer = { text: "", safeCut: 0, lastReplaceFileLines: undefined };
+            const captureDeltas = new TransformStream({
+                transform(msg, controller) {
+                    if (isDeltaLine(msg))
+                        partialBuffer.text += msg.content;
+                    controller.enqueue(msg);
+                },
+            });
+            const pipeline = currentRes
+                .body.pipeThrough(createStatsCollector(promptId, 1000))
+                .pipeThrough(createLineStream(promptId))
+                .pipeThrough(createDataStream(promptId))
+                .pipeThrough(createSseStream(promptId))
+                .pipeThrough(createDeltaStream(promptId, () => vctx.sthis.nextId(12).str))
+                .pipeThrough(captureDeltas)
+                .pipeThrough(createSectionsStream(promptId, () => vctx.sthis.nextId(12).str));
+            const reader = pipeline.getReader();
+            let recoverHint = null;
+            let drainOnly = false;
+            readLoop: while (true) {
+                const rRead = await exception2Result(() => reader.read());
+                if (rRead.isErr()) {
+                    const intentional = drainOnly || currentAbort.signal.aborted;
+                    if (!intentional) {
+                        recoveryLogger
+                            .Info()
+                            .Any("event", {
+                            chatId: req.chatId,
+                            promptId,
+                            err: String(rRead.Err()),
+                        })
+                            .Msg("upstream-read-failed");
+                    }
+                    break readLoop;
+                }
+                const { done, value } = rRead.Ok();
+                if (done)
+                    break readLoop;
+                if (drainOnly)
                     continue;
+                if (!isBlockEnd(value)) {
+                    if (!isBlockStreamMsg(value))
+                        continue;
+                    const closed = blockAcc.ingest(value);
+                    const applyResult = closed ? streamingResolver.observeBlock(closed) : undefined;
+                    const isFailedCodeEnd = closed !== undefined && applyResult !== undefined && applyResult.errors.length > 0;
+                    if (isFailedCodeEnd) {
+                        const first = applyResult.errors[0];
+                        const truncateEvt = buildTruncatedEvent({
+                            closed,
+                            firstError: first,
+                            errorCount: applyResult.errors.length,
+                            promptId,
+                            blockSeq,
+                            now: new Date(),
+                        });
+                        collectedMsgs.push(truncateEvt);
+                        const r = await appendBlockEvent({
+                            ctx,
+                            vctx,
+                            req,
+                            promptId,
+                            blockSeq: blockSeq++,
+                            evt: truncateEvt,
+                            emitMode: "emit-only",
+                        });
+                        if (r.isErr()) {
+                            return Result.Err(r);
+                        }
+                        recoverHint = {
+                            partial: partialBuffer.text.slice(0, partialBuffer.safeCut),
+                            focusPath: applyResult.path,
+                            blockId: closed.end.blockId,
+                            sectionId: closed.end.sectionId,
+                            reason: first.reason,
+                            kind: first.kind,
+                            errorCount: applyResult.errors.length,
+                            lastReplaceFileLines: partialBuffer.lastReplaceFileLines,
+                        };
+                        currentAbort.abort();
+                        drainOnly = true;
+                        continue;
+                    }
+                    collectedMsgs.push(value);
+                    const r = await appendBlockEvent({
+                        ctx,
+                        vctx,
+                        req,
+                        promptId,
+                        blockSeq: blockSeq++,
+                        evt: value,
+                        emitMode: "emit-only",
+                    });
+                    if (r.isErr()) {
+                        return Result.Err(r);
+                    }
+                    if (closed !== undefined && applyResult !== undefined && applyResult.errors.length === 0) {
+                        partialBuffer.safeCut = partialBuffer.text.length;
+                        streamMadeProgress = true;
+                        const wasReplace = closed.lines.some((l) => l.line.startsWith("<<<<<<< SEARCH"));
+                        if (wasReplace) {
+                            const resolvedText = streamingResolver.getVfs().get(applyResult.path);
+                            partialBuffer.lastReplaceFileLines = resolvedText ? resolvedText.split("\n").length : undefined;
+                        }
+                        else {
+                            partialBuffer.lastReplaceFileLines = undefined;
+                        }
+                    }
                 }
-                collectedMsgs.push(value);
-                const r = await appendBlockEvent({
-                    ctx,
+                else {
+                    collectedMsgs.push(value);
+                    const x = await handleEndMsg({ collectedMsgs, vctx, req, ctx, resChat, promptId, value, blockSeq });
+                    if (x.isErr())
+                        return Result.Err(x);
+                    blockSeq = x.Ok();
+                    collectedMsgs.splice(0, collectedMsgs.length);
+                }
+            }
+            if (isRecoveryStream) {
+                recoveryCounter = updateRecoveryCounter(recoveryCounter, { madeProgress: streamMadeProgress });
+                recoveryLogger
+                    .Debug()
+                    .Any("event", {
+                    chatId: req.chatId,
+                    promptId,
+                    madeProgress: streamMadeProgress,
+                    consecutiveFruitless: recoveryCounter.consecutiveFruitless,
+                })
+                    .Msg("recovery-stream-end");
+            }
+            if (recoverHint === null) {
+                return Result.Ok();
+            }
+            if (!shouldAttemptRecovery(recoveryCounter)) {
+                recoveryLogger
+                    .Info()
+                    .Any("event", {
+                    chatId: req.chatId,
+                    promptId,
+                    blockId: recoverHint.blockId,
+                    consecutiveFruitless: recoveryCounter.consecutiveFruitless,
+                })
+                    .Msg("recovery-exhausted");
+                const exhaustedEnd = {
+                    type: "block.end",
+                    blockId: recoverHint.blockId,
+                    streamId: promptId,
+                    seq: blockSeq,
+                    blockNr: 0,
+                    timestamp: new Date(),
+                    stats: {
+                        toplevel: { lines: 0, bytes: 0 },
+                        code: { lines: 0, bytes: 0 },
+                        image: { lines: 0, bytes: 0 },
+                        total: { lines: 0, bytes: 0 },
+                    },
+                    usage: {
+                        given: [],
+                        calculated: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+                    },
+                };
+                collectedMsgs.push(exhaustedEnd);
+                const xEnd = await handleEndMsg({
+                    collectedMsgs,
                     vctx,
                     req,
+                    ctx,
+                    resChat,
                     promptId,
-                    blockSeq: blockSeq++,
-                    evt: value,
-                    emitMode: "emit-only",
+                    value: exhaustedEnd,
+                    blockSeq,
                 });
-                if (r.isErr()) {
-                    return Result.Err(r);
-                }
+                if (xEnd.isErr())
+                    return Result.Err(xEnd);
+                return Result.Ok();
             }
-            else {
-                collectedMsgs.push(value);
-                const x = await handleEndMsg({ collectedMsgs, vctx, req, ctx, resChat, promptId, value, blockSeq });
-                if (x.isErr()) {
-                    return Result.Err(x);
-                }
-                blockSeq = x.Ok();
-                collectedMsgs.splice(0, collectedMsgs.length);
+            const stitchMode = recoveryCounter.consecutiveFruitless === 2;
+            recoveryLogger
+                .Debug()
+                .Any("event", {
+                chatId: req.chatId,
+                promptId,
+                blockId: recoverHint.blockId,
+                sectionId: recoverHint.sectionId,
+                path: recoverHint.focusPath,
+                reason: recoverHint.reason,
+                kind: recoverHint.kind,
+                errorCount: recoverHint.errorCount,
+                consecutiveFruitless: recoveryCounter.consecutiveFruitless,
+                mode: stitchMode ? "stitch" : "continue",
+            })
+                .Msg("recovery-start");
+            const pkgBaseUrl = promptsPkgBaseUrl(vctx.params.pkgRepos.workspace);
+            const fetchOverride = createPromptAssetFetch({ fetchAsset: vctx.fetchAsset });
+            const addendum = await exception2Result(() => stitchMode ? getRecoveryStitchAddendum(pkgBaseUrl, fetchOverride) : getRecoveryAddendum(pkgBaseUrl, fetchOverride));
+            if (addendum.isErr()) {
+                recoveryLogger
+                    .Info()
+                    .Any("event", { chatId: req.chatId, promptId, err: String(addendum.Err()) })
+                    .Msg("recovery-addendum-failed");
+                return Result.Ok();
             }
+            const recReq = buildRecoveryRequest({
+                originalRequest: llmReq,
+                recoveryAddendum: addendum.Ok(),
+                vfs: streamingResolver.getVfs(),
+                focusPath: recoverHint.focusPath,
+                assistantPartial: stitchMode ? undefined : recoverHint.partial,
+                lastReplaceFileLines: stitchMode ? undefined : recoverHint.lastReplaceFileLines,
+            });
+            if (recReq.isErr()) {
+                recoveryLogger
+                    .Info()
+                    .Any("event", {
+                    chatId: req.chatId,
+                    promptId,
+                    err: String(recReq.Err()),
+                    originalMessageCount: llmReq.messages.length,
+                    originalRoles: llmReq.messages.map((m) => m.role),
+                })
+                    .Msg("recovery-build-failed");
+                return Result.Ok();
+            }
+            const recPayload = recReq.Ok();
+            const recMessageCount = recPayload.messages.length;
+            const recRoles = recPayload.messages.map((m) => m.role);
+            const recModel = recPayload.model;
+            const nextAbort = new AbortController();
+            const rNextRes = await exception2Result(() => vctx.llmRequest({ ...recPayload, headers: llmReq.headers }, { signal: nextAbort.signal }));
+            if (rNextRes.isErr()) {
+                recoveryLogger
+                    .Info()
+                    .Any("event", {
+                    chatId: req.chatId,
+                    promptId,
+                    err: String(rNextRes.Err()),
+                    model: recModel,
+                    messageCount: recMessageCount,
+                    roles: recRoles,
+                })
+                    .Msg("recovery-call-failed");
+                return Result.Ok();
+            }
+            const nextRes = rNextRes.Ok();
+            if (!nextRes.ok || !nextRes.body) {
+                const rBody = await exception2Result(() => nextRes.text());
+                const rawBody = rBody.isOk() ? rBody.Ok() : `<read-failed: ${String(rBody.Err())}>`;
+                const bodySnippet = rawBody.length > 2000 ? `${rawBody.slice(0, 2000)}…[+${rawBody.length - 2000}b]` : rawBody;
+                recoveryLogger
+                    .Info()
+                    .Any("event", {
+                    chatId: req.chatId,
+                    promptId,
+                    status: nextRes.status,
+                    statusText: nextRes.statusText,
+                    model: recModel,
+                    messageCount: recMessageCount,
+                    roles: recRoles,
+                    bodySnippet,
+                })
+                    .Msg("recovery-call-failed");
+                return Result.Ok();
+            }
+            recoveryLogger
+                .Debug()
+                .Any("event", {
+                chatId: req.chatId,
+                promptId,
+                partialBytes: recoverHint.partial.length,
+                focusPath: recoverHint.focusPath,
+                model: recModel,
+                messageCount: recMessageCount,
+                roles: recRoles,
+            })
+                .Msg("recovery-call-started");
+            currentRes = nextRes;
+            currentAbort = nextAbort;
+            isRecoveryStream = true;
         }
-        return Result.Ok();
     })
         .do();
     return blockSeq;
@@ -990,6 +1322,8 @@ export const promptChatSection = {
                     resChat,
                     promptId,
                     blockSeq: res.blockSeq,
+                    llmReq: res.llmReq,
+                    abort: res.abort,
                 });
                 return Result.Ok(finalBlockSeq);
             };