@vibes.diy/api-svc 14.3.16 → 14.3.17

package/public/llm-dispatch.js

@@ -1,1159 +1,6 @@
-import { persistGuestUsage } from "../intern/guest-build-usage.js";
-import { Result, Option, exception2Result, chunkyAsync } from "@adviser/cement";
-import { convertImageEvtToFileRef } from "./convert-image-evt.js";
-import { canonicalModelUsage, isDraftOwnerHandle, isPromptFSStyle, isReqPromptFSUpdateChatSection, buildUrlResearchJob, isResError, } from "@vibes.diy/api-types";
-import { type } from "arktype";
-import { and, eq } from "drizzle-orm/sql/expressions";
-import { publishApp } from "./publish-app.js";
-import { costCentsFromUsage } from "../billing.js";
-import { wrapMsgBase } from "../unwrap-msg-base.js";
-import { isChatMessage, isUserChatMessage, FileSystemRef, isBlockStreamMsg, isBlockImage, isForcedToolChoice, } from "@vibes.diy/call-ai-v2";
-import { applyImgGenDocWrite } from "./img-doc-write.js";
-import { clientRefStamp } from "../intern/client-attribution.js";
-import { postMakerFact } from "../intern/post-maker-fact.js";
-import { ensureAppSlugItem } from "./ensure-app-slug-item.js";
-import { getModelDefaults } from "../intern/get-model-defaults.js";
-import { loadVersionTimeline, resolveEditBaseSeed } from "../intern/version-timeline.js";
-import { resolveCodeBlocks, resolveCodeBlockChangedPaths, createBlockAccumulator, } from "../intern/prompt-streaming.js";
-import { persistCodegenThemeMarker, persistCodegenVarietyMarker } from "../intern/prompt-assembly.js";
-import { stripVibesFileBlocks } from "../intern/inflate-file-attachments.js";
-import { loadModels } from "./list-models.js";
-import { messagesCarryImages, modelSupportsImageInput } from "../intern/model-vision.js";
-import { createLlmToolLoopBudget } from "../intern/llm-tool-loop.js";
-import { activateUrlCandidates } from "../intern/url-activation.js";
-import { reconcileResearchPointer } from "../intern/persist-url-research.js";
-import { claimDraftState } from "../intern/draft-chat-store.js";
-import { settleLightMintAtProvisionalAddress, settleMintJobIfLive } from "../intern/mint-job-store.js";
-import { openTurn } from "../intern/open-turn-store.js";
-import { fanOutSectionToChat, publishChatAppClaimed } from "../intern/section-fan-out.js";
-import { captureImgGenOutcome, classifyImgGenError } from "../analytics.js";
-import { delayForAttempt, extractEdgeError, extractProviderErrorFields, formatLlmAttemptFailures, isInvalidModelError, parseRetryAfterMs, pickDiagnosticHeaders, readFailureBody, waitMs, } from "./provider-errors.js";
-const TRANSIENT_LLM_STATUSES = new Set([429, 502, 503, 504]);
-const PRIMARY_RETRY_DELAY_MS = 100;
-const FALLBACK_RETRY_DELAY_MS = 250;
-const DISPATCH_FIRST_TOKEN_TIMEOUT_MS = 45_000;
-export const DISPATCH_TOTAL_BUDGET_MS = 120_000;
-const DISPATCH_MAX_ATTEMPTS = 3;
-export function currentUserMessageText(messages) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message !== undefined && isUserChatMessage(message)) {
-            return message.content
-                .map((part) => (part.type === "text" ? part.text : ""))
-                .join("")
-                .trim();
-        }
-    }
-    return "";
-}
-function systemMessageText(messages) {
-    const partsText = (message) => {
-        if (message.content === null)
-            return "";
-        if (typeof message.content === "string")
-            return message.content;
-        return message.content.map((part) => (part.type === "text" ? part.text : "")).join("");
-    };
-    const system = messages.find((m) => m.role === "system");
-    if (system === undefined)
-        return "";
-    const context = messages.find(isAppContextMessage);
-    return context === undefined ? partsText(system) : `${partsText(system)}\n${partsText(context)}`;
-}
-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;
-}
-export function createLlmDispatchBudget(vctx) {
-    return createLlmToolLoopBudget({
-        totalBudgetMs: envPositiveInt(vctx, "DISPATCH_TOTAL_BUDGET_MS", DISPATCH_TOTAL_BUDGET_MS),
-        maxAttempts: DISPATCH_MAX_ATTEMPTS,
-    });
-}
-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");
-}
-export function pickFallbackModel(args) {
-    const { models, mode, failedModel, requireImageInput } = args;
-    if (mode !== "codegen" && mode !== "runtime") {
-        return Result.Err(`Mode ${mode} does not support LLM fallback`);
-    }
-    for (const model of models) {
-        if (model.id === failedModel || Array.isArray(model.fallbackFor) === false || model.fallbackFor.includes(mode) === false) {
-            continue;
-        }
-        if (requireImageInput === true && modelSupportsImageInput(models, model.id) === false)
-            continue;
-        return Result.Ok(model.id);
-    }
-    return Result.Err(requireImageInput === true
-        ? `No image-capable fallback model configured for ${mode} after ${failedModel}`
-        : `No fallback model configured for ${mode} after ${failedModel}`);
-}
-export async function findFallbackModel(args) {
-    const { vctx, mode, failedModel, requireImageInput } = args;
-    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())}`);
-    }
-    return pickFallbackModel({ models: rModels.Ok().models, mode, failedModel, requireImageInput });
-}
-export 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,
-    };
-}
-export 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 budget = args.budget ?? createLlmDispatchBudget(args.vctx);
-    const dispatchDeadline = budget.deadlineAt;
-    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 budget exhausted before a response (attempts ${budget.attemptsUsed}/${budget.maxAttempts})`;
-        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 || budget.attemptsUsed >= budget.maxAttempts)
-            return budgetExhausted();
-        budget.attemptsUsed++;
-        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;
-    if (Date.now() >= dispatchDeadline || budget.attemptsUsed >= budget.maxAttempts)
-        return budgetExhausted();
-    const rFallbackModel = await findFallbackModel({
-        vctx: args.vctx,
-        mode: args.mode,
-        failedModel: args.llmReq.model,
-        requireImageInput: messagesCarryImages(args.llmReq.messages),
-    });
-    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 || budget.attemptsUsed >= budget.maxAttempts)
-        return budgetExhausted();
-    budget.attemptsUsed++;
-    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) };
-}
-const imgDocWrittenReqs = new WeakSet();
-function lastUserText(messages) {
-    const users = messages.filter(isUserChatMessage);
-    const last = users[users.length - 1];
-    if (last === undefined)
-        return "";
-    return last.content.map((part) => (part.type === "text" ? part.text : "")).join("");
-}
-export async function appendBlockEvent({ ctx, vctx, req, promptId, blockSeq, evt, emitMode = "store", resChat, initiator, }) {
-    if (isBlockImage(evt) && req._auth.type === "VerifiedGuestBuildAuth")
-        return Result.Err("guest-build-images-refused");
-    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 img = processedEvt;
-        if (req.mode === "img" &&
-            isBlockImage(processedEvt) &&
-            img.uploadId &&
-            img.mimeType &&
-            typeof img.size === "number" &&
-            !imgDocWrittenReqs.has(req)) {
-            const imgReq = req;
-            const imgTarget = imgReq.imgTarget;
-            if (imgTarget) {
-                imgDocWrittenReqs.add(req);
-                const wrote = await applyImgGenDocWrite(vctx, {
-                    userId: imgReq._auth.verifiedAuth.claims.userId,
-                    ownerHandle: resChat.ownerHandle,
-                    appSlug: resChat.appSlug,
-                    target: imgTarget,
-                    fileMeta: { uploadId: img.uploadId, mimeType: img.mimeType, size: img.size },
-                    promptText: lastUserText(imgReq.prompt.messages),
-                    model: imgReq.prompt.model,
-                });
-                if (wrote) {
-                    processedEvt = { ...img, docWritten: true };
-                }
-                else {
-                    imgDocWrittenReqs.delete(req);
-                }
-            }
-        }
-    }
-    const now = new Date();
-    const msgBase = wrapMsgBase(ctx.validated, {
-        payload: {
-            type: "vibes.diy.section-event",
-            chatId: req.chatId,
-            promptId,
-            blockSeq,
-            blocks: [processedEvt],
-            timestamp: now,
-            ...(initiator === undefined ? {} : { initiator }),
-        },
-        tid: req.outerTid,
-        src: "promptChatSection",
-    });
-    if (emitMode !== "store-only") {
-        await fanOutSectionToChat({
-            connections: vctx.connections,
-            chatId: req.chatId,
-            sendCtx: ctx,
-            msgBase,
-            logger: vctx.logger,
-        });
-    }
-    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 autoPublishOnPersist(vctx, args) {
-    const rMint = await exception2Result(async () => {
-        const hb = vctx.sql.tables.handleBinding;
-        const ownerRow = await vctx.sql.db
-            .select({ userId: hb.userId })
-            .from(hb)
-            .where(eq(hb.handle, args.ownerHandle))
-            .limit(1)
-            .then((r) => r[0]);
-        if (ownerRow === undefined || ownerRow.userId !== args.callerUserId) {
-            vctx.logger
-                .Debug()
-                .Any("event", { ownerHandle: args.ownerHandle, appSlug: args.appSlug, promptId: args.promptId })
-                .Msg("auto-publish-mint-skipped-not-owner");
-            return;
-        }
-        const rPublish = await publishApp(vctx, {
-            type: "vibes.diy.req-publish-app",
-            auth: args.auth,
-            ownerHandle: args.ownerHandle,
-            appSlug: args.appSlug,
-            fsId: args.fsId,
-            auto: true,
-        }, ownerRow.userId);
-        if (rPublish.isErr()) {
-            throw rPublish.Err();
-        }
-    });
-    if (rMint.isErr()) {
-        vctx.logger
-            .Warn()
-            .Err(rMint)
-            .Any("event", { ownerHandle: args.ownerHandle, appSlug: args.appSlug, fsId: args.fsId, promptId: args.promptId })
-            .Msg("auto-publish-mint-failed");
-    }
-}
-async function persistChatSections(vctx, sections) {
-    let result = Result.Ok(undefined);
-    await chunkyAsync({
-        input: sections,
-        splitCondition: (secChunk) => secChunk.length >= 20,
-        commit: async (secChunk) => {
-            const rChunk = await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.chatSections).values(secChunk));
-            if (rChunk.isErr())
-                result = Result.Err(rChunk);
-        },
-    });
-    return result;
-}
-export async function handlePromptContext({ vctx, req, resChat, promptId, blockSeq, value, collectedMsgs: iCollectedMsgs, proseOnly, blockChunks = 100, fileSystem, model, byok, researchRequested, codegenTheme, codegenVariety, editBaseFsId, initiator, agentDispatched, carried, onFsRef, frontendDraft, persistSections = (sections) => persistChatSections(vctx, sections), ctx, step, researchModel, }) {
-    let fsRef = Option.None();
-    let deferredPersist;
-    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 });
-    }
-    const promptContextValues = () => ({
-        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",
-            ...(frontendDraft === true ? { frontendDraft: true } : {}),
-            usage: value.usage,
-            fsRef: fsRef.toValue(),
-            ...(model !== undefined && model !== "" ? { model } : {}),
-            ...(step === undefined ? {} : { step }),
-            ...(researchModel === undefined || researchModel === "" ? {} : { researchModel }),
-            ...(byok === true ? { byok: true } : {}),
-            ...(initiator === "platform" ? { initiator: "platform" } : {}),
-            ...(agentDispatched === true ? { agentDispatched: true } : {}),
-            ...clientRefStamp(vctx),
-        },
-        created: new Date().toISOString(),
-    });
-    let draftReplayPersisted = false;
-    let ownerHandleForPersist = resChat.ownerHandle;
-    let appSlugForPersist = resChat.appSlug;
-    if (code.length > 0 && (resChat.mode === "codegen" || isPromptFSStyle(resChat.mode))) {
-        if (isDraftOwnerHandle(ownerHandleForPersist)) {
-            const rSections = await persistSections(sections);
-            if (rSections.isErr())
-                return Result.Err(rSections);
-            const rContext = await exception2Result(() => req._auth.type === "VerifiedGuestBuildAuth"
-                ? persistGuestUsage(vctx, promptContextValues())
-                : vctx.sql.db.insert(vctx.sql.tables.promptContexts).values(promptContextValues()));
-            if (rContext.isErr())
-                return Result.Err(rContext);
-            draftReplayPersisted = true;
-            const rPark = await claimDraftState(vctx, req.chatId, ["unowned", "turn-parked"], "turn-parked");
-            if (rPark.isErr())
-                return Result.Err(rPark);
-            if (rPark.Ok()) {
-                vctx.logger
-                    .Info()
-                    .Any("event", { userId: req._auth.verifiedAuth.claims.userId, chatId: req.chatId, promptId })
-                    .Msg("draft-persist-deferred-awaiting-handle");
-                deferredPersist = "awaiting-handle";
-            }
-            else {
-                const rLive = await readChatAddress(vctx, req.chatId);
-                if (rLive.isErr())
-                    return Result.Err(rLive);
-                const live = rLive.Ok();
-                if (live === undefined || isDraftOwnerHandle(live.ownerHandle)) {
-                    return Result.Err(`draft chat ${req.chatId} lost the park claim but still has no owner handle`);
-                }
-                ownerHandleForPersist = live.ownerHandle;
-                appSlugForPersist = live.appSlug;
-            }
-        }
-        else {
-            const rLive = await readChatAddress(vctx, req.chatId);
-            if (rLive.isErr())
-                return Result.Err(rLive);
-            const live = rLive.Ok();
-            if (live !== undefined && isDraftOwnerHandle(live.ownerHandle) === false) {
-                if (live.ownerHandle !== ownerHandleForPersist || live.appSlug !== appSlugForPersist) {
-                    vctx.logger
-                        .Info()
-                        .Any("event", {
-                        chatId: req.chatId,
-                        promptId,
-                        from: { ownerHandle: ownerHandleForPersist, appSlug: appSlugForPersist },
-                        to: live,
-                    })
-                        .Msg("persist-address-refreshed-mid-turn");
-                }
-                ownerHandleForPersist = live.ownerHandle;
-                appSlugForPersist = live.appSlug;
-            }
-        }
-    }
-    if (deferredPersist === undefined &&
-        proseOnly !== true &&
-        code.length > 0 &&
-        (resChat.mode === "codegen" || isPromptFSStyle(resChat.mode))) {
-        if (req._auth.type === "VerifiedGuestBuildAuth" || req.auth === undefined)
-            return Result.Err("guest-build-cannot-publish");
-        let resolvedFileSystem;
-        let changedPathsFromBlocks;
-        let carriedItems = carried ?? [];
-        if (fileSystem) {
-            resolvedFileSystem = fileSystem;
-            changedPathsFromBlocks = resolveCodeBlockChangedPaths(code);
-        }
-        else {
-            const timelineResult = await loadVersionTimeline(vctx, req.chatId);
-            if (timelineResult.isErr())
-                return Result.Err(timelineResult);
-            const timeline = timelineResult.Ok();
-            const chainHeadFsId = timeline.length > 0 ? timeline[timeline.length - 1].fsId : undefined;
-            const chainHeadVfs = chainHeadFsId !== undefined ? timeline[timeline.length - 1].vfs : new Map();
-            const base = await resolveEditBaseSeed(vctx, {
-                editBaseFsId,
-                chainHeadFsId,
-                chainHeadVfs,
-                chainHeadCarried: chainHeadFsId !== undefined ? timeline[timeline.length - 1].carried : [],
-                ownerHandle: ownerHandleForPersist,
-                appSlug: appSlugForPersist,
-            });
-            carriedItems = base.carried;
-            const resolved = resolveCodeBlocks(code, base.vfs);
-            resolvedFileSystem = resolved.files;
-            changedPathsFromBlocks = resolved.changedPaths;
-        }
-        {
-            const sources = resolvedFileSystem
-                .filter((file) => file.type === "code-block")
-                .filter((file) => file.filename.startsWith("/~~") === false);
-            if (agentDispatched === true && code.some((block) => block.begin.path?.includes("~~") === true))
-                return Result.Err("Generated code cannot overwrite derived runtime artifacts.");
-            const changedPaths = new Set(isReqPromptFSUpdateChatSection(req) && req.agentFileCommit !== undefined
-                ? req.agentFileCommit.changes.map((file) => file.path)
-                : changedPathsFromBlocks);
-            const changes = sources
-                .filter((file) => changedPaths.has(file.filename))
-                .map((file) => ({ path: file.filename, contents: file.content }));
-            if (agentDispatched === true || changes.length > 0) {
-                const checked = await validateAgentFiles(vctx, {
-                    vfs: new Map(sources.map((file) => [file.filename, file.content])),
-                    changes,
-                    ownerHandle: ownerHandleForPersist,
-                });
-                if (checked.isErr())
-                    return Result.Err(checked.Err());
-            }
-        }
-        const rFs = await ensureAppSlugItem(vctx, {
-            type: "vibes.diy.req-ensure-app-slug",
-            mode: "dev",
-            runId: promptId,
-            appSlug: appSlugForPersist,
-            ownerHandle: ownerHandleForPersist,
-            fileSystem: resolvedFileSystem,
-            auth: req.auth,
-            _auth: req._auth,
-        }, { carried: carriedItems });
-        if (rFs.isErr()) {
-            console.error("Failed to ensure app slug item for code blocks:", rFs.Err());
-            return Result.Err(rFs);
-        }
-        const ensured = rFs.Ok();
-        if (isResError(ensured)) {
-            return Result.Err(`${ensured.error.message} [${ensured.error.code}]`);
-        }
-        const tFsRef = type(FileSystemRef).onDeepUndeclaredKey("delete")(ensured);
-        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(async () => {
-        const values = promptContextValues();
-        if (draftReplayPersisted === false) {
-            if (req._auth.type === "VerifiedGuestBuildAuth") {
-                const persisted = await persistGuestUsage(vctx, values);
-                if (persisted.isErr())
-                    return persisted;
-            }
-            else
-                await vctx.sql.db.insert(vctx.sql.tables.promptContexts).values(values);
-        }
-        else if (deferredPersist === undefined) {
-            await vctx.sql.db
-                .update(vctx.sql.tables.promptContexts)
-                .set({ fsId: values.fsId, ref: values.ref })
-                .where(eq(vctx.sql.tables.promptContexts.promptId, promptId));
-            const terminalSection = sections.find((section) => section.blocks.includes(value));
-            if (terminalSection !== undefined && fsRef.IsSome()) {
-                const t = vctx.sql.tables.chatSections;
-                await vctx.sql.db
-                    .update(t)
-                    .set({ blocks: terminalSection.blocks })
-                    .where(and(eq(t.chatId, req.chatId), eq(t.promptId, promptId), eq(t.blockSeq, terminalSection.blockSeq)));
-            }
-        }
-    });
-    if (rSql.isErr()) {
-        return Result.Err(rSql);
-    }
-    const costCents = costCentsFromUsage(value.usage);
-    const billingP = (async () => {
-        if (costCents <= 0 || req._auth.type === "VerifiedGuestBuildAuth")
-            return;
-        if (byok === true)
-            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: ownerHandleForPersist,
-            appSlug: appSlugForPersist,
-            theme: codegenTheme,
-        }));
-        if (rMark.isErr()) {
-            vctx.logger.Warn().Err(rMark).Str("chatId", req.chatId).Msg("persistCodegenThemeMarker failed");
-        }
-        const rVariety = await exception2Result(() => persistCodegenVarietyMarker(vctx, {
-            userId: req._auth.verifiedAuth.claims.userId,
-            ownerHandle: ownerHandleForPersist,
-            appSlug: appSlugForPersist,
-            variety: codegenVariety,
-        }));
-        if (rVariety.isErr()) {
-            vctx.logger.Warn().Err(rVariety).Str("chatId", req.chatId).Msg("persistCodegenVarietyMarker failed");
-        }
-    })();
-    await Promise.all([billingP, markerP, draftReplayPersisted ? Promise.resolve(Result.Ok(undefined)) : persistSections(sections)]);
-    if (resChat.mode === "codegen") {
-        const rSettle = await exception2Result(() => settleMintJobIfLive(vctx, {
-            chatId: req.chatId,
-            ownerHandle: ownerHandleForPersist,
-            appSlug: appSlugForPersist,
-            logModule: "handlePromptContext",
-        }));
-        if (rSettle.isErr()) {
-            vctx.logger.Warn().Err(rSettle).Str("chatId", req.chatId).Str("promptId", promptId).Msg("mint-job-settle-rejected");
-        }
-        if (fsRef.IsSome()) {
-            const rLight = await exception2Result(() => settleLightMintAtProvisionalAddress(vctx, {
-                chatId: req.chatId,
-                ownerHandle: ownerHandleForPersist,
-                appSlug: appSlugForPersist,
-                logModule: "handlePromptContext",
-            }));
-            if (rLight.isErr()) {
-                vctx.logger.Warn().Err(rLight).Str("chatId", req.chatId).Str("promptId", promptId).Msg("light-mint-settle-rejected");
-            }
-            else if (rLight.Ok() && ctx !== undefined) {
-                await publishChatAppClaimed({
-                    connections: vctx.connections,
-                    chatId: req.chatId,
-                    ownerHandle: ownerHandleForPersist,
-                    appSlug: appSlugForPersist,
-                    sendCtx: ctx,
-                    validated: ctx.validated,
-                    logger: vctx.logger,
-                });
-            }
-        }
-    }
-    if (researchRequested === true) {
-        const reconciliation = reconcileResearchPointer(vctx, {
-            userId: req._auth.verifiedAuth.claims.userId,
-            chatId: req.chatId,
-            promptId,
-        }).then((rResearch) => {
-            if (rResearch.isErr()) {
-                vctx.logger.Warn().Err(rResearch).Str("promptId", promptId).Msg("reconcile-url-research-pointer-failed");
-            }
-        }, (error) => {
-            vctx.logger
-                .Warn()
-                .Any("event", { chatId: req.chatId, promptId, error: String(error) })
-                .Msg("reconcile-url-research-pointer-rejected");
-        });
-        const waitUntil = vctx.waitUntil;
-        if (waitUntil !== undefined) {
-            const registered = exception2Result(() => waitUntil(reconciliation));
-            if (registered.isErr()) {
-                vctx.logger.Warn().Err(registered).Str("promptId", promptId).Msg("reconcile-url-research-pointer-wait-until-failed");
-            }
-        }
-        else {
-            await reconciliation;
-        }
-    }
-    if (fsRef.IsSome() && initiator !== "platform" && req._auth.type === "VerifiedAuthResult" && req.auth !== undefined) {
-        const mintTask = autoPublishOnPersist(vctx, {
-            ownerHandle: ownerHandleForPersist,
-            appSlug: appSlugForPersist,
-            fsId: fsRef.Unwrap().fsId,
-            callerUserId: req._auth.verifiedAuth.claims.userId,
-            auth: req.auth,
-            promptId,
-        }).catch((error) => {
-            vctx.logger
-                .Warn()
-                .Any("event", { chatId: req.chatId, promptId, error: String(error) })
-                .Msg("auto-publish-mint-rejected");
-        });
-        const waitUntil = vctx.waitUntil;
-        if (waitUntil !== undefined) {
-            const registered = exception2Result(() => waitUntil(mintTask));
-            if (registered.isErr()) {
-                vctx.logger.Warn().Err(registered).Str("promptId", promptId).Msg("auto-publish-mint-wait-until-failed");
-            }
-        }
-        else {
-            await mintTask;
-        }
-    }
-    iCollectedMsgs.splice(0, collectedMsgs.length);
-    return Result.Ok({ blockSeq, fsRef, ...(deferredPersist === undefined ? {} : { deferredPersist }) });
-}
-async function readChatAddress(vctx, chatId) {
-    const t = vctx.sql.tables.chatContexts;
-    const r = await exception2Result(() => vctx.sql.db
-        .select({ ownerHandle: t.ownerHandle, appSlug: t.appSlug })
-        .from(t)
-        .where(eq(t.chatId, chatId))
-        .limit(1)
-        .then((rows) => rows[0]));
-    if (r.isErr())
-        return Result.Err(r);
-    const row = r.Ok();
-    return Result.Ok(row === undefined ? undefined : { ownerHandle: row.ownerHandle, appSlug: row.appSlug });
-}
-export function mergeServerTools(outgoing, serverTools) {
-    if (serverTools === undefined || serverTools.length === 0)
-        return {};
-    const clientTools = Array.isArray(outgoing.tools) ? outgoing.tools : [];
-    const byName = new Map();
-    for (const tool of clientTools) {
-        if (byName.has(tool.function.name) === false)
-            byName.set(tool.function.name, tool);
-    }
-    for (const tool of serverTools) {
-        byName.set(tool.function.name, tool);
-    }
-    return {
-        tools: [...byName.values()],
-        ...(isForcedToolChoice(outgoing.tool_choice) ? {} : { tool_choice: "auto" }),
-    };
-}
-async function runtimeImageInputGate(vctx, messages, modelId) {
-    if (messagesCarryImages(messages) === false)
-        return Result.Ok(undefined);
-    const rModels = await loadModels(vctx);
-    if (rModels.isErr()) {
-        return Result.Err(`callAI cannot send an image: the model catalog could not be read (${rModels.Err().message}), so image support for ${modelId} is unknown`);
-    }
-    if (modelSupportsImageInput(rModels.Ok().models, modelId) === false) {
-        return Result.Err(`callAI cannot send an image: the model ${modelId} does not accept image input`);
-    }
-    return Result.Ok(undefined);
-}
-export async function handlerLlmRequest({ scope, ctx, vctx, blockSeq, req, resChat, promptId, preAssembled, serverTools, initiator, agentDispatched, platformInitiated, modelUsage, }) {
-    const resolved = await scope
-        .evalResult(async () => {
-        const r = await getModelDefaults(vctx, { appSlug: resChat.appSlug, ownerHandle: resChat.ownerHandle });
-        if (r.isErr()) {
-            return Result.Err(r);
-        }
-        let param;
-        switch (req.mode) {
-            case "codegen":
-                param = modelUsage === "agent" ? r.Ok().agent : r.Ok().codegen;
-                break;
-            case "runtime":
-                param = r.Ok().runtime;
-                break;
-            case "img":
-                param = r.Ok().img;
-                break;
-            default:
-                return Result.Err(`Unknown prompt mode: ${req.mode}`);
-        }
-        const storedApiKey = param.apiKey !== undefined && param.apiKey !== "" ? param.apiKey : undefined;
-        const perCallApiKey = req.apiKey !== undefined && req.apiKey !== "" ? req.apiKey : undefined;
-        const byokApiKey = perCallApiKey ?? storedApiKey;
-        return Result.Ok({
-            modelId: req.prompt.model ?? param.model.id,
-            ...(byokApiKey !== undefined ? { byokApiKey } : {}),
-        });
-    })
-        .do();
-    const modelId = resolved.modelId;
-    const byokApiKey = resolved.byokApiKey;
-    if (req.mode === "runtime" && preAssembled === undefined) {
-        await scope.evalResult(() => runtimeImageInputGate(vctx, req.prompt.messages.filter(isChatMessage), modelId)).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.filter(isChatMessage));
-            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 = preAssembled?.isInitialTurn ?? withSystemPrompt.messages.filter((m) => m.role === "user").length <= 1;
-    const { apiKey: _clientApiKey, tools: clientTools, tool_choice: clientToolChoice, ...promptSansClientKey } = req.prompt;
-    if (req.mode !== "codegen") {
-        if (clientTools !== undefined)
-            promptSansClientKey.tools = clientTools;
-        if (clientToolChoice !== undefined)
-            promptSansClientKey.tool_choice = clientToolChoice;
-    }
-    const activatedUrls = req.mode === "codegen"
-        ? activateUrlCandidates({
-            currentUserText: currentUserMessageText(req.prompt.messages.filter(isChatMessage)),
-            enrichedPrompt: preAssembled?.enrichedPrompt,
-            isInitialTurn,
-        })
-        : [];
-    const llmReq = {
-        ...{
-            ...promptSansClientKey,
-            messages: withSystemPrompt.messages,
-        },
-        model: withSystemPrompt.model,
-        headers: vctx.params.llm.headers,
-        ...(byokApiKey !== undefined ? { apiKey: byokApiKey } : {}),
-        stream: true,
-        ...(isInitialTurn && req.mode === "codegen" ? { verbosity: "low" } : {}),
-        ...(req.mode === "img" ? { modalities: ["text", "image"] } : {}),
-        ...mergeServerTools(promptSansClientKey, serverTools),
-    };
-    await scope
-        .evalResult(async () => {
-        const r = await appendBlockEvent({
-            ctx,
-            vctx,
-            req,
-            promptId,
-            blockSeq: blockSeq,
-            evt: {
-                type: "prompt.req",
-                ...(req.mode === "codegen" && req.source === "suggestion" ? { source: "suggestion" } : {}),
-                streamId: promptId,
-                chatId: req.chatId,
-                seq: blockSeq,
-                request: { ...promptSansClientKey, model: modelId },
-                timestamp: new Date(),
-                ...(agentDispatched === true ? { agentDispatched: true } : {}),
-                ...(platformInitiated === true ? { platformInitiated: true } : {}),
-            },
-            ...(initiator === undefined ? {} : { initiator }),
-        });
-        blockSeq++;
-        return r;
-    })
-        .do();
-    if (canonicalModelUsage(req.mode) === "codegen") {
-        const rOpen = await openTurn(vctx.sql, {
-            chatId: req.chatId,
-            promptId,
-            userId: req._auth.verifiedAuth.claims.userId,
-            ownerHandle: resChat.ownerHandle,
-            appSlug: resChat.appSlug,
-            kind: isInitialTurn ? "first-build" : "codegen",
-            ...(vctx.doInstance === undefined ? {} : { objectId: vctx.doInstance.objectId, instanceId: vctx.doInstance.instanceId }),
-        });
-        if (rOpen.isErr()) {
-            vctx.logger.Warn().Err(rOpen).Any("event", { chatId: req.chatId, promptId }).Msg("open-turn-record-failed");
-        }
-    }
-    if (req.mode === "codegen" && preAssembled !== undefined) {
-        const systemText = systemMessageText(preAssembled.messages);
-        if (systemText !== "") {
-            await scope
-                .evalResult(async () => {
-                const r = await appendBlockEvent({
-                    ctx,
-                    vctx,
-                    req,
-                    promptId,
-                    blockSeq: blockSeq,
-                    evt: {
-                        type: "prompt.system-prompt",
-                        streamId: promptId,
-                        chatId: req.chatId,
-                        seq: blockSeq,
-                        text: systemText,
-                        timestamp: new Date(),
-                    },
-                    emitMode: "emit-only",
-                });
-                blockSeq++;
-                return r;
-            })
-                .do();
-        }
-    }
-    if (vctx.billing.enforceEnabled && byokApiKey === undefined) {
-        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) {
-                postMakerFact(vctx, {
-                    eventId: `wall:${req.chatId}:${new Date().toISOString().slice(0, 10)}`,
-                    userId: req._auth.verifiedAuth.claims.userId,
-                    at: new Date().toISOString(),
-                    kind: "paywall-hit",
-                }, "credit-wall");
-                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");
-    if (req.mode === "img") {
-        const lastFailure = dispatch.ok ? undefined : dispatch.attempts[dispatch.attempts.length - 1];
-        const status = lastFailure !== undefined && (lastFailure.kind === "http-status" || lastFailure.kind === "missing-body")
-            ? lastFailure.status
-            : undefined;
-        captureImgGenOutcome(vctx, {
-            outcome: dispatch.ok ? "succeeded" : "failed",
-            userId: req._auth.verifiedAuth.claims.userId,
-            ownerHandle: resChat.ownerHandle,
-            appSlug: resChat.appSlug,
-            model: dispatch.llmReq.model ?? modelId,
-            ...(dispatch.ok
-                ? {}
-                : { errorClass: classifyImgGenError(dispatch.error, status), ...(status === undefined ? {} : { status }) }),
-        });
-    }
-    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();
-    }
-    const currentUserText = currentUserMessageText(req.prompt.messages.filter(isChatMessage));
-    const urlResearchJob = buildUrlResearchJob({
-        mode: req.mode,
-        isInitialTurn,
-        userId: req._auth.verifiedAuth.claims.userId,
-        chatId: req.chatId,
-        promptId,
-        ownerHandle: resChat.ownerHandle,
-        appSlug: resChat.appSlug,
-        currentUserText,
-        activatedUrls,
-        model: dispatch.llmReq.model ?? modelId,
-    });
-    return {
-        res,
-        blockSeq,
-        llmReq: dispatch.llmReq,
-        abort: dispatch.abort,
-        ...(urlResearchJob === undefined ? {} : { urlResearchJob }),
-    };
-}
-import { validateAgentFiles } from "../intern/agent-file-validation.js";
-import { isAppContextMessage } from "../intern/agent-request-frame.js";
+export { DISPATCH_TOTAL_BUDGET_MS, pickFallbackModel, dispatchLlmRequestWithFallback, } from "./llm-dispatch-fallback.js";
+export { announceModelResolved, appendBlockEvent } from "./append-block-event.js";
+export { autoPublishOnPersist } from "./auto-publish-on-persist.js";
+export { handlePromptContext } from "./handle-prompt-context.js";
+export { currentUserMessageText, mergeServerTools, handlerLlmRequest } from "./handler-llm-request.js";
 //# sourceMappingURL=llm-dispatch.js.map