@vibes.diy/api-svc 4.4.2 → 4.5.4

package/public/prompt-chat-section.js

@@ -1,628 +1,32 @@
-import { Result, Option, EventoResult, exception2Result, chunkyAsync } from "@adviser/cement";
-import { storeAndAuditAsset } from "./store-and-audit-asset.js";
-import { convertImageEvtToFileRef } from "./convert-image-evt.js";
+import { Result, Option, EventoResult, exception2Result } from "@adviser/cement";
 import { scopey } from "@adviser/scopey";
-import { isReqCreationPromptChatSection, isReqPromptApplicationChatSection, isPromptFSStyle, isReqPromptFSChatSection, isReqPromptFSUpdateChatSection, isReqPromptImageChatSection, isReqPromptLLMChatSection, reqPromptChatSection, isReqPromptFSSetChatSection, parseArray, fileSystemItem, isVibeCodeBlock, } from "@vibes.diy/api-types";
-import { ensureLogger } from "@vibes.diy/identity";
+import { isReqCreationPromptChatSection, isReqPromptApplicationChatSection, isReqPromptFSChatSection, isReqPromptImageChatSection, isReqPromptLLMChatSection, reqPromptChatSection, } from "@vibes.diy/api-types";
 import { type } from "arktype";
-import { costCentsFromUsage, prodiaCostCents } from "../billing.js";
 import { checkAuth } from "../check-auth.js";
 import { unwrapMsgBase, wrapMsgBase } from "../unwrap-msg-base.js";
 import { assertChatShardIdentity } from "../shard-gate.js";
-import { withHeartbeat } from "./stream-heartbeat.js";
 import { and, desc, eq } from "drizzle-orm/sql/expressions";
-import { createStatsCollector, createLineStream, createDataStream, createSseStream, createDeltaStream, createSectionsStream, isBlockEnd, isDeltaLine, FileSystemRef, isBlockStreamMsg, isBlockImage, } from "@vibes.diy/call-ai-v2";
-import { getRecoveryAddendum, getRecoveryStitchAddendum } 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";
-import { loadVersionTimeline, resolveVfsFromFileSystem } from "../intern/version-timeline.js";
-import { langForFilename } from "../intern/ensure-push-seeded-chat.js";
 import { resolveSlotConfig } from "../intern/slot-assembler.js";
 import { preAllocate } from "../intern/pre-allocate.js";
 import { dryRunHandleIsForeign } from "../intern/ensure-chat-id.js";
 import { createPromptAssetFetch, promptsPkgBaseUrl } from "../intern/prompt-asset-fetch.js";
 import { resolveCodeBlocksToFileSystem, createStreamingResolver, createBlockAccumulator, logApplyError, } from "../intern/prompt-streaming.js";
 import { reconstructConversationMessages, assemblePromptPayload, persistCodegenThemeMarker, } from "../intern/prompt-assembly.js";
-import { stripVibesFileBlocks } from "../intern/inflate-file-attachments.js";
 import { bumpAppRecency } from "../intern/bump-app-recency.js";
-import { acquireChatPersistGate, waitChatPersistIdle } from "../intern/chat-persist-gate.js";
-import { loadModels } from "./list-models.js";
+import { waitChatPersistIdle } from "../intern/chat-persist-gate.js";
+import { appendBlockEvent, handlerLlmRequest } from "./llm-dispatch.js";
+import { handleLlmResponse } from "./stream-assembly.js";
+import { handleProdiaImageRequest } from "./image-gen.js";
+import { handleFSPrompt } from "./fs-prompt.js";
 function clientWsSend(ctx) {
     return ctx.send.provider;
 }
 export { createPromptAssetFetch, promptsPkgBaseUrl };
 export { resolveCodeBlocksToFileSystem, createStreamingResolver, createBlockAccumulator, logApplyError };
-const TRANSIENT_LLM_STATUSES = new Set([429, 502, 503, 504]);
-const PRIMARY_RETRY_DELAY_MS = 100;
-const FALLBACK_RETRY_DELAY_MS = 250;
-const MAX_RETRY_AFTER_MS = 10_000;
-const MAX_ATTEMPT_BODY_SNIPPET_CHARS = 2000;
-const DISPATCH_FIRST_TOKEN_TIMEOUT_MS = 45_000;
-const DISPATCH_TOTAL_BUDGET_MS = 120_000;
-function envPositiveInt(vctx, key, fallback) {
-    const raw = vctx.sthis.env.get(key);
-    if (typeof raw !== "string")
-        return fallback;
-    const n = Number.parseInt(raw, 10);
-    return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-function formatAttemptFailure(failure) {
-    const prefix = `${failure.label} ${failure.model}`;
-    switch (failure.kind) {
-        case "http-status":
-        case "missing-body": {
-            const statusText = failure.statusText.length > 0 ? ` ${failure.statusText}` : "";
-            const errorText = failure.kind === "missing-body" ? `: ${failure.error}` : "";
-            const bodyText = failure.kind === "http-status" && typeof failure.bodySnippet === "string" && failure.bodySnippet.length > 0
-                ? `: ${failure.bodySnippet}`
-                : "";
-            return `${prefix} failed with status ${failure.status}${statusText}${errorText}${bodyText}`;
-        }
-        case "exception":
-            return `${prefix} failed with error ${failure.error}`;
-        case "timeout":
-            return `${prefix} timed out after ${failure.elapsedMs}ms with no response`;
-    }
-}
-function formatLlmAttemptFailures(failures) {
-    return `LLM request failed after ${failures.length} attempt${failures.length === 1 ? "" : "s"}: ${failures
-        .map(formatAttemptFailure)
-        .join("; ")}`;
-}
-function parseRetryAfterMs(headers) {
-    const raw = headers.get("retry-after");
-    if (raw === null)
-        return;
-    const seconds = Number(raw);
-    if (Number.isFinite(seconds) && seconds >= 0)
-        return seconds * 1000;
-    const retryAt = Date.parse(raw);
-    if (Number.isFinite(retryAt))
-        return Math.max(0, retryAt - Date.now());
-}
-function delayForAttempt(failure, defaultDelayMs) {
-    const retryAfterMs = failure.kind === "http-status" ? failure.retryAfterMs : undefined;
-    return Math.min(retryAfterMs ?? defaultDelayMs, MAX_RETRY_AFTER_MS);
-}
-async function waitMs(ms) {
-    await new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-function boundSnippet(text) {
-    return text.length > MAX_ATTEMPT_BODY_SNIPPET_CHARS
-        ? `${text.slice(0, MAX_ATTEMPT_BODY_SNIPPET_CHARS)}...[+${text.length - MAX_ATTEMPT_BODY_SNIPPET_CHARS}b]`
-        : text;
-}
-async function readFailureBody(res) {
-    if (res.body === null)
-        return { snippet: "", full: "" };
-    const rText = await exception2Result(() => res.text());
-    const full = rText.isOk() ? rText.Ok() : `<read-failed: ${String(rText.Err())}>`;
-    return { snippet: boundSnippet(full), full };
-}
-const DIAGNOSTIC_HEADER_NAMES = ["cf-ray", "cf-ew-via", "server", "retry-after", "x-generation-id", "content-type"];
-function pickDiagnosticHeaders(headers) {
-    const out = {};
-    for (const name of DIAGNOSTIC_HEADER_NAMES) {
-        const value = headers.get(name);
-        if (value !== null)
-            out[name] = value;
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-const OPENROUTER_META_FIELDS = ["requested", "strategy", "region", "summary", "attempt", "is_byok"];
-const providerErrorBody = type({
-    "error?": {
-        "code?": "unknown",
-        "message?": "unknown",
-        "metadata?": {
-            "provider_name?": "unknown",
-            "raw?": "unknown",
-        },
-    },
-    "openrouter_metadata?": {
-        "requested?": "unknown",
-        "strategy?": "unknown",
-        "region?": "unknown",
-        "summary?": "unknown",
-        "attempt?": "unknown",
-        "is_byok?": "unknown",
-    },
-});
-function extractProviderErrorFields(bodyFull) {
-    const rParsed = exception2Result(() => providerErrorBody(JSON.parse(bodyFull)));
-    if (rParsed.isErr())
-        return {};
-    const parsed = rParsed.Ok();
-    if (parsed instanceof type.errors)
-        return {};
-    const out = {};
-    const code = parsed.error?.code;
-    if (typeof code === "string" || typeof code === "number")
-        out.errorCode = code;
-    if (typeof parsed.error?.message === "string")
-        out.errorMessage = parsed.error.message;
-    const providerName = parsed.error?.metadata?.provider_name;
-    if (typeof providerName === "string")
-        out.providerName = providerName;
-    const raw = parsed.error?.metadata?.raw;
-    if (typeof raw === "string")
-        out.rawSnippet = boundSnippet(raw);
-    else if (raw !== undefined)
-        out.rawSnippet = boundSnippet(JSON.stringify(raw));
-    const orMeta = parsed.openrouter_metadata;
-    if (orMeta !== undefined) {
-        const picked = {};
-        for (const field of OPENROUTER_META_FIELDS) {
-            if (orMeta[field] !== undefined)
-                picked[field] = orMeta[field];
-        }
-        if (Object.keys(picked).length > 0)
-            out.openrouterMeta = picked;
-    }
-    return out;
-}
-const INVALID_MODEL_STATUSES = new Set([400, 404]);
-const INVALID_MODEL_MESSAGE_RE = /not a valid model|invalid model|unknown model|no endpoints found for|model\b.{0,120}\b(not found|does not exist|no longer (available|supported)|deprecated|retired)/i;
-function isInvalidModelError(status, provider) {
-    if (!INVALID_MODEL_STATUSES.has(status))
-        return false;
-    return typeof provider.errorMessage === "string" && INVALID_MODEL_MESSAGE_RE.test(provider.errorMessage);
-}
-function extractEdgeError(bodySnippet, rawSnippet, headers) {
-    const haystacks = [bodySnippet, rawSnippet].filter((s) => typeof s === "string" && s.length > 0);
-    let code;
-    for (const hay of haystacks) {
-        const match = hay.match(/error code:\s*(\d{3,4})/i) ?? hay.match(/\bError\s+(\d{3,4})\b/);
-        if (match !== null) {
-            code = match[1];
-            break;
-        }
-    }
-    if (code === undefined)
-        return {};
-    const server = headers.get("server") ?? "";
-    const cloudflareMarker = headers.get("cf-ray") !== null ||
-        headers.get("cf-ew-via") !== null ||
-        /cloudflare/i.test(server) ||
-        haystacks.some((hay) => /cloudflare/i.test(hay));
-    const edgeErrorVendor = cloudflareMarker ? "cloudflare" : "unknown";
-    const edgeErrorFamily = edgeErrorVendor === "cloudflare" && /^1\d{3}$/.test(code) ? "cloudflare-1xxx" : "unknown";
-    return { edgeErrorCode: code, edgeErrorVendor, edgeErrorFamily };
-}
-function logLlmAttemptFailure(args) {
-    const { vctx, diag, label, model, elapsedMs, details } = args;
-    vctx.logger
-        .Warn()
-        .Any("event", {
-        chatId: diag.chatId,
-        promptId: diag.promptId,
-        phase: diag.phase,
-        mode: diag.mode,
-        label,
-        model,
-        elapsedMs,
-        ...details,
-    })
-        .Msg("llm-request-attempt-failed");
-}
-async function findFallbackModel(vctx, mode, failedModel) {
-    if (mode !== "codegen" && mode !== "runtime") {
-        return Result.Err(`Mode ${mode} does not support LLM fallback`);
-    }
-    const rModels = await loadModels(vctx);
-    if (rModels.isErr()) {
-        vctx.logger.Warn().Err(rModels).Msg("llm-fallback-model-load-failed");
-        return Result.Err(`Failed to load fallback model catalog: ${String(rModels.Err())}`);
-    }
-    for (const model of rModels.Ok().models) {
-        if (model.id !== failedModel && Array.isArray(model.fallbackFor) && model.fallbackFor.includes(mode)) {
-            return Result.Ok(model.id);
-        }
-    }
-    return Result.Err(`No fallback model configured for ${mode} after ${failedModel}`);
-}
-async function attemptLlmRequest(args) {
-    const { vctx, diag, llmReq, label, firstTokenTimeoutMs } = args;
-    const abort = new AbortController();
-    const startedAt = Date.now();
-    let timedOut = false;
-    const timer = setTimeout(() => {
-        timedOut = true;
-        abort.abort();
-    }, firstTokenTimeoutMs);
-    const rRes = await exception2Result(() => vctx.llmRequest(llmReq, { signal: abort.signal }));
-    clearTimeout(timer);
-    const elapsedMs = Date.now() - startedAt;
-    if (rRes.isErr()) {
-        abort.abort();
-        if (timedOut) {
-            logLlmAttemptFailure({
-                vctx,
-                diag,
-                label,
-                model: llmReq.model,
-                elapsedMs,
-                details: { kind: "timeout", retryable: true, timeoutMs: firstTokenTimeoutMs },
-            });
-            return {
-                ok: false,
-                abort,
-                failure: {
-                    kind: "timeout",
-                    label,
-                    model: llmReq.model,
-                    elapsedMs,
-                    retryable: true,
-                },
-            };
-        }
-        const error = String(rRes.Err());
-        logLlmAttemptFailure({
-            vctx,
-            diag,
-            label,
-            model: llmReq.model,
-            elapsedMs,
-            details: { kind: "exception", retryable: false, error },
-        });
-        return {
-            ok: false,
-            abort,
-            failure: {
-                kind: "exception",
-                label,
-                model: llmReq.model,
-                error,
-                retryable: false,
-            },
-        };
-    }
-    const res = rRes.Ok();
-    if (res.ok && res.body !== null) {
-        return { ok: true, res, abort };
-    }
-    if (res.ok) {
-        abort.abort();
-        logLlmAttemptFailure({
-            vctx,
-            diag,
-            label,
-            model: llmReq.model,
-            elapsedMs,
-            details: {
-                kind: "missing-body",
-                status: res.status,
-                statusText: res.statusText,
-                retryable: false,
-                error: "response body missing",
-            },
-        });
-        return {
-            ok: false,
-            abort,
-            failure: {
-                kind: "missing-body",
-                label,
-                model: llmReq.model,
-                status: res.status,
-                statusText: res.statusText,
-                error: "response body missing",
-                retryable: false,
-            },
-        };
-    }
-    const { snippet: bodySnippet, full: bodyFull } = await readFailureBody(res);
-    const retryAfterMs = parseRetryAfterMs(res.headers);
-    abort.abort();
-    const retryable = TRANSIENT_LLM_STATUSES.has(res.status);
-    const provider = extractProviderErrorFields(bodyFull);
-    const invalidModel = isInvalidModelError(res.status, provider);
-    const edge = extractEdgeError(bodySnippet, provider.rawSnippet, res.headers);
-    const headers = pickDiagnosticHeaders(res.headers);
-    logLlmAttemptFailure({
-        vctx,
-        diag,
-        label,
-        model: llmReq.model,
-        elapsedMs,
-        details: {
-            kind: "http-status",
-            status: res.status,
-            statusText: res.statusText,
-            retryable,
-            ...(invalidModel ? { invalidModel } : {}),
-            ...(typeof retryAfterMs === "number" ? { retryAfterMs } : {}),
-            ...(headers ? { headers } : {}),
-            ...(bodySnippet.length > 0 ? { bodySnippet } : {}),
-            ...provider,
-            ...edge,
-        },
-    });
-    const failure = {
-        kind: "http-status",
-        label,
-        model: llmReq.model,
-        status: res.status,
-        statusText: res.statusText,
-        retryable,
-        ...(invalidModel ? { invalidModel } : {}),
-        ...(bodySnippet.length > 0 ? { bodySnippet } : {}),
-        ...(typeof retryAfterMs === "number" ? { retryAfterMs } : {}),
-    };
-    return {
-        ok: false,
-        abort,
-        failure,
-    };
-}
-async function dispatchLlmRequestWithFallback(args) {
-    const attempts = [];
-    const diag = {
-        chatId: args.chatId,
-        promptId: args.promptId,
-        phase: args.phase,
-        mode: args.mode,
-    };
-    const firstTokenTimeoutMs = envPositiveInt(args.vctx, "DISPATCH_FIRST_TOKEN_TIMEOUT_MS", DISPATCH_FIRST_TOKEN_TIMEOUT_MS);
-    const totalBudgetMs = envPositiveInt(args.vctx, "DISPATCH_TOTAL_BUDGET_MS", DISPATCH_TOTAL_BUDGET_MS);
-    const dispatchDeadline = Date.now() + totalBudgetMs;
-    const budgetRemainingMs = () => Math.max(0, dispatchDeadline - Date.now());
-    const attemptTimeoutMs = () => Math.min(firstTokenTimeoutMs, budgetRemainingMs());
-    const backoffMs = (failure, defaultDelayMs) => Math.min(delayForAttempt(failure, defaultDelayMs), budgetRemainingMs());
-    const budgetExhausted = () => {
-        const abort = new AbortController();
-        abort.abort();
-        const note = `LLM dispatch exceeded ${totalBudgetMs}ms budget before a response`;
-        const error = attempts.length > 0 ? `${formatLlmAttemptFailures(attempts)}; ${note}` : note;
-        args.vctx.logger
-            .Warn()
-            .Any("event", { chatId: args.chatId, promptId: args.promptId, phase: args.phase, mode: args.mode, attempts: attempts.length })
-            .Msg("llm-dispatch-budget-exhausted");
-        return { ok: false, llmReq: args.llmReq, abort, attempts, error };
-    };
-    let lastPrimary;
-    for (const label of ["primary", "primary-retry"]) {
-        if (lastPrimary) {
-            await waitMs(backoffMs(lastPrimary.failure, PRIMARY_RETRY_DELAY_MS));
-        }
-        if (Date.now() >= dispatchDeadline)
-            return budgetExhausted();
-        const attempt = await attemptLlmRequest({
-            vctx: args.vctx,
-            diag,
-            llmReq: args.llmReq,
-            label,
-            firstTokenTimeoutMs: attemptTimeoutMs(),
-        });
-        if (attempt.ok)
-            return { ok: true, res: attempt.res, llmReq: args.llmReq, abort: attempt.abort, attempts };
-        attempts.push(attempt.failure);
-        if (attempt.failure.retryable === false) {
-            if (attempt.failure.kind === "http-status" && attempt.failure.invalidModel === true) {
-                lastPrimary = attempt;
-                break;
-            }
-            return { ok: false, llmReq: args.llmReq, abort: attempt.abort, attempts, error: formatLlmAttemptFailures(attempts) };
-        }
-        lastPrimary = attempt;
-    }
-    const failedPrimary = lastPrimary;
-    const rFallbackModel = await findFallbackModel(args.vctx, args.mode, args.llmReq.model);
-    if (rFallbackModel.isErr()) {
-        const error = `${formatLlmAttemptFailures(attempts)}; ${String(rFallbackModel.Err())}`;
-        return { ok: false, llmReq: args.llmReq, abort: failedPrimary.abort, attempts, error };
-    }
-    const fallbackModel = rFallbackModel.Ok();
-    const fallbackReq = { ...args.llmReq, model: fallbackModel };
-    await waitMs(backoffMs(failedPrimary.failure, FALLBACK_RETRY_DELAY_MS));
-    if (Date.now() >= dispatchDeadline)
-        return budgetExhausted();
-    const fallback = await attemptLlmRequest({
-        vctx: args.vctx,
-        diag,
-        llmReq: fallbackReq,
-        label: "fallback",
-        firstTokenTimeoutMs: attemptTimeoutMs(),
-    });
-    if (fallback.ok) {
-        args.vctx.logger
-            .Info()
-            .Any("event", {
-            mode: args.mode,
-            fromModel: args.llmReq.model,
-            toModel: fallbackModel,
-        })
-            .Msg("llm-fallback-succeeded");
-        return { ok: true, res: fallback.res, llmReq: fallbackReq, abort: fallback.abort, attempts };
-    }
-    attempts.push(fallback.failure);
-    return { ok: false, llmReq: fallbackReq, abort: fallback.abort, attempts, error: formatLlmAttemptFailures(attempts) };
-}
-async function appendBlockEvent({ ctx, vctx, req, promptId, blockSeq, evt, emitMode = "store", resChat, }) {
-    let processedEvt = evt;
-    if (isBlockImage(evt) && evt.url && resChat) {
-        const rConv = await convertImageEvtToFileRef(vctx, {
-            evt,
-            userId: req._auth.verifiedAuth.claims.userId,
-            ownerHandle: resChat.ownerHandle,
-            appSlug: resChat.appSlug,
-        });
-        if (rConv.isOk()) {
-            processedEvt = rConv.Ok();
-        }
-        else {
-            vctx.logger.Error().Err(rConv).Msg("[block.image] convert failed");
-        }
-    }
-    const now = new Date();
-    const msgBase = wrapMsgBase(ctx.validated, {
-        payload: {
-            type: "vibes.diy.section-event",
-            chatId: req.chatId,
-            promptId,
-            blockSeq,
-            blocks: [processedEvt],
-            timestamp: now,
-        },
-        tid: req.outerTid,
-        src: "promptChatSection",
-    });
-    if (emitMode !== "store-only") {
-        for (const conn of vctx.connections) {
-            const chatCtx = conn.chatIds.get(req.chatId);
-            if (chatCtx) {
-                for (const tid of chatCtx.tids) {
-                    await conn.send(ctx, { ...msgBase, tid });
-                }
-            }
-        }
-    }
-    if (emitMode === "store" || emitMode === "store-only") {
-        const rUpdate = await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.chatSections).values({
-            chatId: req.chatId,
-            promptId,
-            blockSeq,
-            blocks: [processedEvt],
-            created: now.toISOString(),
-        }));
-        if (rUpdate.isErr()) {
-            return Result.Err(rUpdate);
-        }
-    }
-    return Result.Ok();
-}
-export async function handlePromptContext({ vctx, req, resChat, promptId, blockSeq, value, collectedMsgs: iCollectedMsgs, blockChunks = 100, fileSystem, model, codegenTheme, onFsRef, }) {
-    let fsRef = Option.None();
-    const code = [];
-    const sections = [];
-    const collectedMsgs = [...iCollectedMsgs];
-    const blockAcc = createBlockAccumulator();
-    for (const msg of collectedMsgs) {
-        if (!isBlockStreamMsg(msg)) {
-            continue;
-        }
-        let sqlVal = sections[sections.length - 1];
-        if (sections.length === 0 || sqlVal.blocks.length >= blockChunks) {
-            sections.push({
-                chatId: req.chatId,
-                promptId,
-                blockSeq: blockSeq++,
-                blocks: [],
-                created: msg.timestamp.toISOString(),
-            });
-            sqlVal = sections[sections.length - 1];
-        }
-        sqlVal.blocks.push(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 === "codegen" || isPromptFSStyle(resChat.mode))) {
-        let resolvedFileSystem;
-        if (fileSystem) {
-            resolvedFileSystem = fileSystem;
-        }
-        else {
-            const timelineResult = await loadVersionTimeline(vctx, req.chatId);
-            if (timelineResult.isErr())
-                return Result.Err(timelineResult);
-            const timeline = timelineResult.Ok();
-            const seed = timeline.length > 0 ? timeline[timeline.length - 1].vfs : new Map();
-            resolvedFileSystem = resolveCodeBlocksToFileSystem(code, seed);
-        }
-        const rFs = await ensureAppSlugItem(vctx, {
-            type: "vibes.diy.req-ensure-app-slug",
-            mode: "dev",
-            runId: promptId,
-            appSlug: resChat.appSlug,
-            ownerHandle: resChat.ownerHandle,
-            fileSystem: resolvedFileSystem,
-            auth: req.auth,
-            _auth: req._auth,
-        });
-        if (rFs.isErr()) {
-            console.error("Failed to ensure app slug item for code blocks:", rFs.Err());
-            return Result.Err(rFs);
-        }
-        const tFsRef = type(FileSystemRef).onDeepUndeclaredKey("delete")(rFs.Ok());
-        if (tFsRef instanceof type.errors) {
-            return Result.Err(`Failed to parse FileSystemRef: ${tFsRef.summary}`);
-        }
-        fsRef = Option.Some(tFsRef);
-        if (onFsRef) {
-            const rReveal = await exception2Result(() => onFsRef(tFsRef));
-            if (rReveal.isErr()) {
-                vctx.logger.Warn().Err(rReveal).Str("promptId", promptId).Msg("reveal-emit-failed");
-            }
-        }
-    }
-    value.fsRef = fsRef.toValue();
-    const rSql = await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.promptContexts).values({
-        userId: req._auth.verifiedAuth.claims.userId,
-        chatId: req.chatId,
-        promptId,
-        fsId: fsRef.IsSome() ? fsRef.unwrap().fsId : undefined,
-        nethash: vctx.netHash(),
-        promptTokens: value.usage.calculated.prompt_tokens,
-        completionTokens: value.usage.calculated.completion_tokens,
-        totalTokens: value.usage.calculated.total_tokens,
-        ref: {
-            type: "prompt.usage.sql",
-            usage: value.usage,
-            fsRef: fsRef.toValue(),
-            ...(model !== undefined && model !== "" ? { model } : {}),
-        },
-        created: new Date().toISOString(),
-    }));
-    if (rSql.isErr()) {
-        return Result.Err(rSql);
-    }
-    const costCents = costCentsFromUsage(value.usage);
-    const billingP = (async () => {
-        if (costCents <= 0)
-            return;
-        const rTrack = await vctx.billing.trackUsage({
-            userId: req._auth.verifiedAuth.claims.userId,
-            costCents,
-            promptId,
-            ...(model !== undefined && model !== "" ? { model } : {}),
-            mode: resChat.mode,
-        });
-        if (rTrack.isErr()) {
-            vctx.logger.Warn().Err(rTrack).Str("promptId", promptId).Msg("billing-track-failed");
-        }
-    })();
-    const markerP = (async () => {
-        if (!(resChat.mode === "codegen" && fsRef.IsSome()))
-            return;
-        const rMark = await exception2Result(() => persistCodegenThemeMarker(vctx, {
-            userId: req._auth.verifiedAuth.claims.userId,
-            ownerHandle: resChat.ownerHandle,
-            appSlug: resChat.appSlug,
-            theme: codegenTheme,
-        }));
-        if (rMark.isErr()) {
-            vctx.logger.Warn().Err(rMark).Str("chatId", req.chatId).Msg("persistCodegenThemeMarker failed");
-        }
-    })();
-    await Promise.all([
-        billingP,
-        markerP,
-        chunkyAsync({
-            input: sections,
-            splitCondition: (secChunk) => secChunk.length >= 20,
-            commit: async (secChunk) => {
-                await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.chatSections).values(secChunk));
-            },
-        }),
-    ]);
-    iCollectedMsgs.splice(0, collectedMsgs.length);
-    return Result.Ok({ blockSeq, fsRef });
-}
 export { reconstructConversationMessages, assemblePromptPayload, persistCodegenThemeMarker };
+export { handlePromptContext } from "./llm-dispatch.js";
+export { handleFSPrompt };
 function firstUserText(messages) {
     const firstUser = messages.find((m) => m.role === "user");
     if (!firstUser)
@@ -685,1008 +89,6 @@ async function getResChatFromMode(vctx, req, orig) {
     const resChat = { ...iResChat, mode: orig.mode };
     return Result.Ok(resChat);
 }
-async function handlerLlmRequest({ scope, ctx, vctx, blockSeq, req, resChat, promptId, preAssembled, }) {
-    const modelId = await scope
-        .evalResult(async () => {
-        const r = await getModelDefaults(vctx, { appSlug: resChat.appSlug, ownerHandle: resChat.ownerHandle });
-        if (r.isErr()) {
-            return Result.Err(r);
-        }
-        switch (req.mode) {
-            case "codegen":
-                return Result.Ok(req.prompt.model ?? r.Ok().codegen.model.id);
-            case "runtime":
-                return Result.Ok(req.prompt.model ?? r.Ok().runtime.model.id);
-            case "img":
-                return Result.Ok(req.prompt.model ?? r.Ok().img.model.id);
-            default:
-                return Result.Err(`Unknown prompt mode: ${req.mode}`);
-        }
-    })
-        .do();
-    const withSystemPrompt = await scope
-        .evalResult(async () => {
-        let withSystemPrompt = Result.Ok({
-            model: modelId,
-            messages: [],
-        });
-        if (preAssembled !== undefined) {
-            withSystemPrompt = Result.Ok(preAssembled);
-        }
-        else if (req.mode === "runtime" || req.mode === "img") {
-            let messages = stripVibesFileBlocks(req.prompt.messages);
-            if (req.mode === "img") {
-                const imgReq = req;
-                if (imgReq.inputImageBase64) {
-                    const lastUserIdx = (() => {
-                        for (let i = messages.length - 1; i >= 0; i--) {
-                            if (messages[i].role === "user")
-                                return i;
-                        }
-                        return -1;
-                    })();
-                    if (lastUserIdx >= 0) {
-                        const target = messages[lastUserIdx];
-                        messages = [
-                            ...messages.slice(0, lastUserIdx),
-                            {
-                                ...target,
-                                content: [...target.content, { type: "image_url", image_url: { url: imgReq.inputImageBase64 } }],
-                            },
-                            ...messages.slice(lastUserIdx + 1),
-                        ];
-                    }
-                }
-            }
-            withSystemPrompt = Result.Ok({
-                model: req.prompt.model ?? modelId,
-                messages,
-            });
-        }
-        return withSystemPrompt;
-    })
-        .do();
-    const isInitialTurn = withSystemPrompt.messages.filter((m) => m.role === "user").length <= 1;
-    const llmReq = {
-        ...{
-            ...req.prompt,
-            messages: withSystemPrompt.messages,
-        },
-        ...vctx.params.llm.enforced,
-        model: withSystemPrompt.model,
-        headers: vctx.params.llm.headers,
-        stream: true,
-        ...(isInitialTurn && req.mode === "codegen" ? { verbosity: "low" } : {}),
-        ...(req.mode === "img" ? { modalities: ["text", "image"] } : {}),
-    };
-    await scope
-        .evalResult(async () => {
-        const r = await appendBlockEvent({
-            ctx,
-            vctx,
-            req,
-            promptId,
-            blockSeq: blockSeq,
-            evt: {
-                type: "prompt.req",
-                streamId: promptId,
-                chatId: req.chatId,
-                seq: blockSeq,
-                request: { ...req.prompt, model: modelId },
-                timestamp: new Date(),
-            },
-        });
-        blockSeq++;
-        return r;
-    })
-        .do();
-    if (vctx.billing.enforceEnabled) {
-        await scope
-            .evalResult(async () => {
-            const rCheck = await vctx.billing.checkCredits({ userId: req._auth.verifiedAuth.claims.userId });
-            if (rCheck.isErr()) {
-                vctx.logger.Warn().Err(rCheck).Str("chatId", req.chatId).Msg("billing-check-failed-open");
-                return Result.Ok(undefined);
-            }
-            if (rCheck.Ok().allowed === false) {
-                return Result.Err("credits-exhausted: you have used your included AI credits — upgrade to continue");
-            }
-            return Result.Ok(undefined);
-        })
-            .do();
-    }
-    const dispatchStartedAt = Date.now();
-    vctx.logger.Info().Any("event", { chatId: req.chatId, promptId, mode: req.mode, model: modelId }).Msg("llm-dispatch-start");
-    const dispatch = await dispatchLlmRequestWithFallback({
-        vctx,
-        mode: req.mode,
-        llmReq,
-        chatId: req.chatId,
-        promptId,
-        phase: "initial",
-    });
-    vctx.logger
-        .Info()
-        .Any("event", {
-        chatId: req.chatId,
-        promptId,
-        mode: req.mode,
-        ok: dispatch.ok,
-        model: dispatch.llmReq.model,
-        attempts: dispatch.attempts.length,
-        elapsedMs: Date.now() - dispatchStartedAt,
-    })
-        .Msg("llm-dispatch-settled");
-    const res = await scope
-        .evalResult(async () => {
-        return dispatch.ok ? Result.Ok(dispatch.res) : Result.Err(dispatch.error);
-    })
-        .do();
-    const finalModel = dispatch.llmReq.model;
-    if (dispatch.ok && finalModel !== undefined && finalModel !== modelId) {
-        await scope
-            .evalResult(async () => {
-            const r = await appendBlockEvent({
-                ctx,
-                vctx,
-                req,
-                promptId,
-                blockSeq,
-                evt: {
-                    type: "prompt.model-resolved",
-                    streamId: promptId,
-                    chatId: req.chatId,
-                    seq: blockSeq,
-                    model: finalModel,
-                    timestamp: new Date(),
-                },
-            });
-            blockSeq++;
-            return r;
-        })
-            .do();
-    }
-    return { res, blockSeq, llmReq: dispatch.llmReq, abort: dispatch.abort };
-}
-async function handleProdiaImageRequest({ scope, ctx, vctx, req, promptId, blockSeq, resolvedModel, resChat, }) {
-    const prodiaToken = vctx.prodiaToken;
-    if (!prodiaToken) {
-        return Result.Err("PRODIA_TOKEN not configured");
-    }
-    const prodiaStem = resolvedModel.startsWith("prodia/") ? resolvedModel.slice("prodia/".length) : "";
-    if (!prodiaStem) {
-        return Result.Err(`Invalid Prodia model id: ${resolvedModel}`);
-    }
-    const userMessages = req.prompt.messages.filter((m) => m.role === "user");
-    const lastUserMsg = userMessages[userMessages.length - 1];
-    const firstTextPart = lastUserMsg?.content?.find((c) => c.type === "text");
-    const promptText = firstTextPart?.type === "text" ? firstTextPart.text : "";
-    if (!promptText) {
-        return Result.Err("No prompt text found in user messages");
-    }
-    const inputImageDataUrl = req.inputImageBase64;
-    await scope
-        .evalResult(async () => {
-        const r = await appendBlockEvent({
-            ctx,
-            vctx,
-            req,
-            promptId,
-            blockSeq,
-            evt: {
-                type: "prompt.req",
-                streamId: promptId,
-                chatId: req.chatId,
-                seq: blockSeq,
-                request: req.prompt,
-                timestamp: new Date(),
-            },
-        });
-        blockSeq++;
-        return r;
-    })
-        .do();
-    let prodiaRes;
-    if (inputImageDataUrl) {
-        const base64Data = inputImageDataUrl.split(",")[1];
-        const binaryString = atob(base64Data);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        const formData = new FormData();
-        formData.append("job", new Blob([JSON.stringify({ type: `inference.${prodiaStem}.img2img.v1`, config: { prompt: promptText } })], {
-            type: "application/json",
-        }), "job.json");
-        formData.append("input", new Blob([bytes], { type: "image/jpeg" }), "input.jpg");
-        prodiaRes = await vctx.inferenceFetch("https://inference.prodia.com/v2/job", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${prodiaToken}`,
-                Accept: "image/png",
-            },
-            body: formData,
-        });
-    }
-    else {
-        prodiaRes = await vctx.inferenceFetch("https://inference.prodia.com/v2/job", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${prodiaToken}`,
-                Accept: "image/png",
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                type: `inference.${prodiaStem}.txt2img.v1`,
-                config: { prompt: promptText },
-            }),
-        });
-    }
-    if (!prodiaRes.ok) {
-        const errorText = await prodiaRes.text().catch(() => "");
-        return Result.Err(`Prodia request failed: ${prodiaRes.status} ${prodiaRes.statusText} ${errorText}`);
-    }
-    if (!prodiaRes.body) {
-        return Result.Err("Prodia response has no body");
-    }
-    const rStored = await storeAndAuditAsset(vctx, {
-        bytes: prodiaRes.body,
-        userId: req._auth.verifiedAuth.claims.userId,
-        ownerHandle: resChat.ownerHandle,
-        appSlug: resChat.appSlug,
-        mimeType: "image/png",
-    });
-    if (rStored.isErr()) {
-        return Result.Err(`Failed to store Prodia image: ${rStored.Err().message}`);
-    }
-    const imageCostCents = prodiaCostCents(prodiaStem);
-    const zeroTokens = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-    const rPromptCtx = await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.promptContexts).values({
-        userId: req._auth.verifiedAuth.claims.userId,
-        chatId: req.chatId,
-        promptId,
-        nethash: vctx.netHash(),
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0,
-        ref: {
-            type: "prompt.usage.sql",
-            usage: {
-                given: [{ ...zeroTokens, cost: imageCostCents / 100 }],
-                calculated: zeroTokens,
-            },
-            model: resolvedModel,
-        },
-        created: new Date().toISOString(),
-    }));
-    if (rPromptCtx.isErr()) {
-        vctx.logger.Warn().Err(rPromptCtx).Str("promptId", promptId).Msg("image-prompt-context-persist-failed");
-    }
-    if (imageCostCents > 0) {
-        const rTrack = await vctx.billing.trackUsage({
-            userId: req._auth.verifiedAuth.claims.userId,
-            costCents: imageCostCents,
-            promptId,
-            model: resolvedModel,
-            mode: "image",
-        });
-        if (rTrack.isErr()) {
-            vctx.logger.Warn().Err(rTrack).Str("promptId", promptId).Msg("billing-track-failed");
-        }
-    }
-    const stored = rStored.Ok();
-    const fileMimeType = stored.mimeType ?? "image/png";
-    const blockId = vctx.sthis.nextId(12).str;
-    const now = new Date();
-    await appendBlockEvent({
-        ctx,
-        vctx,
-        req,
-        promptId,
-        blockSeq: blockSeq++,
-        evt: {
-            type: "block.begin",
-            blockId,
-            streamId: promptId,
-            seq: blockSeq,
-            blockNr: 0,
-            timestamp: now,
-        },
-    });
-    await appendBlockEvent({
-        ctx,
-        vctx,
-        req,
-        promptId,
-        blockSeq: blockSeq++,
-        evt: {
-            type: "block.image",
-            sectionId: vctx.sthis.nextId(12).str,
-            uploadId: stored.uploadId,
-            cid: stored.cid,
-            mimeType: fileMimeType,
-            size: stored.size,
-            blockId,
-            streamId: promptId,
-            seq: blockSeq,
-            blockNr: 1,
-            timestamp: now,
-            stats: { lines: 0, bytes: stored.size, cnt: 1 },
-        },
-    });
-    const zeroStats = { lines: 0, bytes: 0 };
-    const imageStats = { lines: 0, bytes: stored.size, cnt: 1 };
-    await appendBlockEvent({
-        ctx,
-        vctx,
-        req,
-        promptId,
-        blockSeq: blockSeq++,
-        evt: {
-            type: "block.end",
-            blockId,
-            streamId: promptId,
-            seq: blockSeq,
-            blockNr: 2,
-            timestamp: now,
-            stats: {
-                toplevel: zeroStats,
-                code: zeroStats,
-                image: imageStats,
-                total: imageStats,
-            },
-            usage: {
-                given: [],
-                calculated: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-            },
-        },
-        emitMode: "emit-only",
-    });
-    const promptContextSql = {
-        type: "prompt.usage.sql",
-        usage: {
-            given: [],
-            calculated: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-        },
-    };
-    await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.chatSections).values({
-        chatId: req.chatId,
-        promptId,
-        blockSeq: blockSeq++,
-        blocks: [promptContextSql],
-        created: now.toISOString(),
-    }));
-    for (const conn of vctx.connections) {
-        const chatCtx = conn.chatIds.get(req.chatId);
-        const promptIdCtx = chatCtx?.promptIds.get(promptId);
-        if (promptIdCtx && chatCtx) {
-            chatCtx.promptIds.delete(promptId);
-        }
-    }
-    return Result.Ok(blockSeq);
-}
-async function handleEndMsg({ collectedMsgs, vctx, req, ctx, resChat, promptId, value, blockSeq, fileSystem, terminal, model, codegenTheme, }) {
-    terminal.releasePersistGate ??= acquireChatPersistGate(vctx.connections, req.chatId);
-    const endSeq = blockSeq++;
-    const rEnd = await appendBlockEvent({
-        ctx,
-        vctx,
-        req,
-        promptId,
-        blockSeq: endSeq,
-        evt: { type: "prompt.block-end", streamId: promptId, chatId: req.chatId, seq: endSeq, timestamp: new Date() },
-        emitMode: "emit-only",
-    });
-    if (rEnd.isErr()) {
-        return Result.Err(rEnd);
-    }
-    terminal.promptBlockEndEmitted = true;
-    const revealSeq = blockSeq++;
-    const r = await handlePromptContext({
-        vctx,
-        req,
-        promptId,
-        resChat,
-        value,
-        blockSeq,
-        collectedMsgs,
-        fileSystem,
-        model,
-        codegenTheme,
-        onFsRef: async (fsRefVal) => {
-            const rReveal = await appendBlockEvent({
-                ctx,
-                vctx,
-                req,
-                promptId,
-                blockSeq: revealSeq,
-                evt: {
-                    type: "prompt.fs-persisted",
-                    streamId: promptId,
-                    chatId: req.chatId,
-                    seq: revealSeq,
-                    timestamp: new Date(),
-                    fsRef: fsRefVal,
-                },
-                emitMode: "emit-only",
-            });
-            if (rReveal.isErr()) {
-                vctx.logger.Warn().Err(rReveal).Str("promptId", promptId).Msg("reveal-emit-failed");
-            }
-        },
-    });
-    if (r.isErr()) {
-        return Result.Err(r);
-    }
-    blockSeq = r.Ok().blockSeq;
-    const rEvt = await appendBlockEvent({
-        ctx,
-        vctx,
-        req,
-        promptId,
-        blockSeq: blockSeq++,
-        evt: { ...value, fsRef: r.Ok().fsRef.toValue() },
-        emitMode: "emit-only",
-    });
-    for (const conn of vctx.connections) {
-        const chatCtx = conn.chatIds.get(req.chatId);
-        const promptIdCtx = chatCtx?.promptIds.get(promptId);
-        if (promptIdCtx && chatCtx) {
-            chatCtx.promptIds.delete(promptId);
-        }
-    }
-    if (rEvt.isErr()) {
-        return Result.Err(rEvt);
-    }
-    return Result.Ok(blockSeq);
-}
-async function handleLlmResponse({ scope, vctx, req, ctx, res, resChat, promptId, blockSeq, llmReq, abort, terminal, codegenTheme, }) {
-    await scope
-        .evalResult(async () => {
-        let collectedMsgs;
-        for (const conn of vctx.connections) {
-            const tChatCtx = conn.chatIds.get(req.chatId);
-            if (tChatCtx) {
-                const promptIdCtx = tChatCtx.promptIds.get(promptId);
-                if (!promptIdCtx) {
-                    collectedMsgs = [];
-                    tChatCtx.promptIds.set(promptId, {
-                        blocks: collectedMsgs,
-                        promptId,
-                        type: "vibes.diy.section-event",
-                        chatId: req.chatId,
-                        blockSeq: 0,
-                        timestamp: new Date(),
-                    });
-                }
-                else {
-                    collectedMsgs = promptIdCtx.blocks;
-                }
-            }
-        }
-        if (!collectedMsgs) {
-            collectedMsgs = [];
-        }
-        const seedTimelineResult = await loadVersionTimeline(vctx, req.chatId);
-        if (seedTimelineResult.isErr())
-            return Result.Err(seedTimelineResult);
-        const seedTimeline = seedTimelineResult.Ok();
-        const seedForResolver = seedTimeline.length > 0 ? seedTimeline[seedTimeline.length - 1].vfs : new Map();
-        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 turnRawText = "";
-        let rawEmitted = false;
-        const emitTurnRaw = async () => {
-            if (rawEmitted || turnRawText === "")
-                return Result.Ok();
-            rawEmitted = true;
-            const r = await appendBlockEvent({
-                ctx,
-                vctx,
-                req,
-                promptId,
-                blockSeq,
-                evt: {
-                    type: "prompt.raw",
-                    streamId: promptId,
-                    chatId: req.chatId,
-                    seq: blockSeq,
-                    text: turnRawText,
-                    timestamp: new Date(),
-                },
-                resChat,
-            });
-            blockSeq++;
-            return r;
-        };
-        let currentRes = res;
-        let currentAbort = abort;
-        const HEARTBEAT_MS = 20_000;
-        while (true) {
-            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(() => withHeartbeat(() => reader.read(), {
-                    intervalMs: HEARTBEAT_MS,
-                    beat: () => {
-                        ctx.send
-                            .send(ctx, { type: "vibes.diy.res-progress", stage: "generating" })
-                            .catch((e) => {
-                            recoveryLogger
-                                .Warn()
-                                .Any("event", { chatId: req.chatId, promptId, err: String(e) })
-                                .Msg("heartbeat-emit-failed");
-                        });
-                    },
-                }));
-                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",
-                        resChat,
-                    });
-                    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;
-                        }
-                    }
-                }
-                else {
-                    collectedMsgs.push(value);
-                    const x = await handleEndMsg({
-                        collectedMsgs,
-                        vctx,
-                        req,
-                        ctx,
-                        resChat,
-                        promptId,
-                        value,
-                        blockSeq,
-                        terminal,
-                        model: llmReq.model,
-                        codegenTheme,
-                    });
-                    if (x.isErr())
-                        return Result.Err(x);
-                    blockSeq = x.Ok();
-                    collectedMsgs.splice(0, collectedMsgs.length);
-                }
-            }
-            turnRawText += recoverHint === null ? partialBuffer.text : recoverHint.partial;
-            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) {
-                const rRaw = await emitTurnRaw();
-                if (rRaw.isErr())
-                    return Result.Err(rRaw);
-                return Result.Ok();
-            }
-            if (!shouldAttemptRecovery(recoveryCounter)) {
-                recoveryLogger
-                    .Info()
-                    .Any("event", {
-                    chatId: req.chatId,
-                    promptId,
-                    blockId: recoverHint.blockId,
-                    consecutiveFruitless: recoveryCounter.consecutiveFruitless,
-                })
-                    .Msg("recovery-exhausted");
-                const rRaw = await emitTurnRaw();
-                if (rRaw.isErr())
-                    return Result.Err(rRaw);
-                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,
-                    value: exhaustedEnd,
-                    blockSeq,
-                    terminal,
-                    model: llmReq.model,
-                    codegenTheme,
-                });
-                if (xEnd.isErr())
-                    return Result.Err(xEnd);
-                return Result.Ok();
-            }
-            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 recLlmReq = {
-                ...recPayload,
-                headers: llmReq.headers,
-                model: llmReq.model,
-            };
-            const recDispatch = await dispatchLlmRequestWithFallback({
-                vctx,
-                mode: req.mode,
-                llmReq: recLlmReq,
-                chatId: req.chatId,
-                promptId,
-                phase: "recovery",
-            });
-            const recModel = recDispatch.llmReq.model;
-            if (recDispatch.ok === false) {
-                recoveryLogger
-                    .Info()
-                    .Any("event", {
-                    chatId: req.chatId,
-                    promptId,
-                    err: recDispatch.error,
-                    model: recModel,
-                    messageCount: recMessageCount,
-                    roles: recRoles,
-                })
-                    .Msg("recovery-call-failed");
-                return Result.Ok();
-            }
-            const nextRes = recDispatch.res;
-            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 = recDispatch.abort;
-            isRecoveryStream = true;
-        }
-    })
-        .do();
-    return blockSeq;
-}
-export async function handleFSPrompt({ scope, vctx, resChat, req, ctx, promptId, terminal, }) {
-    let fileSystem;
-    if (isReqPromptFSSetChatSection(req)) {
-        fileSystem = req.fsSet;
-    }
-    else if (isReqPromptFSUpdateChatSection(req)) {
-        let baseItems;
-        if (req.refFsId) {
-            const refApp = await vctx.sql.db
-                .select({ fileSystem: vctx.sql.tables.apps.fileSystem })
-                .from(vctx.sql.tables.apps)
-                .where(and(eq(vctx.sql.tables.apps.fsId, req.refFsId), eq(vctx.sql.tables.apps.ownerHandle, resChat.ownerHandle), eq(vctx.sql.tables.apps.appSlug, resChat.appSlug)))
-                .orderBy(desc(vctx.sql.tables.apps.releaseSeq))
-                .limit(1)
-                .then((r) => r[0]);
-            if (!refApp) {
-                throw new Error(`fs-update refFsId ${req.refFsId} is not a release of ${resChat.ownerHandle}/${resChat.appSlug}`);
-            }
-            baseItems = refApp.fileSystem;
-        }
-        else {
-            const lastestPrompt = await vctx.sql.db
-                .select()
-                .from(vctx.sql.tables.promptContexts)
-                .innerJoin(vctx.sql.tables.apps, eq(vctx.sql.tables.apps.fsId, vctx.sql.tables.promptContexts.fsId))
-                .where(eq(vctx.sql.tables.promptContexts.chatId, req.chatId))
-                .orderBy(desc(vctx.sql.tables.promptContexts.created))
-                .limit(1)
-                .then((r) => r[0]);
-            baseItems = lastestPrompt?.Apps.fileSystem;
-        }
-        const refFS = [];
-        if (baseItems !== undefined) {
-            const vfs = await resolveVfsFromFileSystem(vctx, parseArray(baseItems, fileSystemItem));
-            for (const [filename, content] of vfs) {
-                if (filename.startsWith("/~~calculated~~/"))
-                    continue;
-                refFS.push({ type: "code-block", filename, lang: langForFilename(filename), content });
-            }
-        }
-        const mapFS = refFS.reduce((acc, file) => {
-            acc.set(file.filename, file);
-            return acc;
-        }, new Map());
-        req.fsUpdate.update.forEach((update) => {
-            mapFS.set(update.filename, update);
-        });
-        req.fsUpdate.remove?.forEach((item) => {
-            mapFS.delete(item.filename);
-        });
-        fileSystem = Array.from(mapFS.values());
-    }
-    const rEndMsg = await scope
-        .evalResult(async () => {
-        const sectionId = vctx.sthis.nextId(12).str;
-        let blockNr = 0;
-        const blockId = vctx.sthis.nextId(12).str;
-        let blockSeq = 0;
-        let bytes = 0;
-        const collectedMsgs = [
-            {
-                type: "block.begin",
-                blockId,
-                streamId: promptId,
-                seq: blockSeq++,
-                blockNr: blockNr++,
-                timestamp: new Date(),
-            },
-            ...fileSystem.flatMap((file) => {
-                if (!isVibeCodeBlock(file)) {
-                    return [];
-                }
-                return [
-                    {
-                        type: "block.code.begin",
-                        sectionId,
-                        lang: file.lang,
-                        blockId: blockId,
-                        streamId: promptId,
-                        seq: blockSeq++,
-                        blockNr,
-                        timestamp: new Date(),
-                    },
-                    ...file.content.split("\n").map((line, lineNr) => {
-                        bytes += line.length + 1;
-                        return {
-                            type: "block.code.line",
-                            sectionId,
-                            blockId,
-                            line,
-                            streamId: promptId,
-                            seq: blockSeq++,
-                            timestamp: new Date(),
-                            lang: file.lang,
-                            blockNr,
-                            lineNr,
-                        };
-                    }),
-                    {
-                        type: "block.code.end",
-                        sectionId,
-                        blockId,
-                        streamId: promptId,
-                        seq: blockSeq++,
-                        timestamp: new Date(),
-                        lang: file.lang,
-                        blockNr,
-                        stats: { lines: file.content.split("\n").length, bytes },
-                    },
-                ];
-            }),
-        ];
-        const value = {
-            type: "block.end",
-            stats: {
-                toplevel: { lines: 0, bytes: 0 },
-                code: { lines: blockSeq, bytes },
-                image: { lines: 0, bytes: 0 },
-                total: { lines: blockSeq, bytes },
-            },
-            usage: {
-                given: [],
-                calculated: {
-                    prompt_tokens: 0,
-                    completion_tokens: 0,
-                    total_tokens: 0,
-                },
-            },
-            blockId: blockId,
-            streamId: promptId,
-            seq: blockSeq++,
-            blockNr: blockNr,
-            timestamp: new Date(),
-        };
-        collectedMsgs.push(value);
-        for (const msg of collectedMsgs) {
-            if (!isBlockEnd(msg)) {
-                await appendBlockEvent({
-                    ctx,
-                    vctx,
-                    req,
-                    promptId,
-                    blockSeq: blockSeq++,
-                    evt: msg,
-                    emitMode: "emit-only",
-                });
-            }
-        }
-        return handleEndMsg({
-            collectedMsgs,
-            vctx,
-            req,
-            ctx,
-            resChat,
-            promptId,
-            value,
-            blockSeq,
-            fileSystem,
-            terminal,
-        });
-    })
-        .do();
-    return Result.Ok(rEndMsg);
-}
 export const promptChatSection = {
     hash: "prompt-chat-section-handler",
     validate: unwrapMsgBase(async (msg) => {
@@ -1756,6 +158,7 @@ export const promptChatSection = {
                 }),
                 focusPath: orig.focusPath,
                 attachScreenshot: orig.dryRun !== true,
+                degradeAttachments: orig.dryRun === true,
                 ...(activeSettingsOverride ? { activeSettingsOverride } : {}),
             });
             if (rAssembled.isErr())