@vibes.diy/api-svc 14.0.21 → 14.0.23

package/public/prompt-chat-section.js

@@ -24,16 +24,20 @@ import { bumpAppRecency } from "../intern/bump-app-recency.js";
 import { waitChatPersistIdle } from "../intern/chat-persist-gate.js";
 import { peekInFlightTurns } from "../intern/in-flight-turns.js";
 import { acquireTurnBuildLock, peekBuildLockEntry, releaseTurnBuildLock } from "../intern/codegen-build-lock.js";
-import { agentAwaitBuildEnabled, agentFirstTurnEnabled, agentLaneEnabled } from "../intern/agent-lane-flag.js";
+import { agentAwaitBuildEnabled, agentFirstTurnEnabled, agentLaneEnabled, agentSessionEnabled } from "../intern/agent-lane-flag.js";
+import { deliverAgentSession } from "../intern/agent-session-runtime.js";
+import { runEditVibeTool } from "../intern/agent-build-tools.js";
 import { claimFirstTurnMint, claimMintJob } from "../intern/mint-job-store.js";
 import { codegenTurnLane, legacyVariantHint, routeAgentTurn } from "../intern/agent-router.js";
 import { assembleAgentPayload } from "../intern/agent-assembly.js";
 import { createAgentBelt } from "../intern/agent-belt.js";
-import { createAgentTurnStream } from "../intern/agent-turn.js";
+import { createAgentTurnStream, agentTotalBudgetMs } from "../intern/agent-turn.js";
 import { createAgentBuildDispatcher } from "../intern/agent-dispatcher.js";
 import { decideAgentWake, fireAgentWakeTurn, readAgentWakeBudget, renderAgentWakeNote, renderBuildSettledSentence, } from "../intern/agent-wake.js";
 import { createPendingBuildLandings, renderBuildLandingNote, settleTurnTerminal } from "../intern/turn-terminal.js";
-import { resolveAgentActor } from "../intern/agent-actor.js";
+import { resolveAgentActor, resolveChatApp } from "../intern/agent-actor.js";
+import { langForFilename } from "../intern/ensure-push-seeded-chat.js";
+import { promptDispatchContext } from "../intern/prompt-dispatch-context.js";
 import { dispatchLlmRequestWithFallback } from "./llm-dispatch.js";
 import { scheduleUrlResearch } from "../intern/url-research-queue.js";
 import { createProviderSseStream } from "../intern/provider-sse.js";
@@ -42,6 +46,7 @@ import { emitWorkTurnStatus } from "../intern/work-turn-status.js";
 import { closeTurn, extendOpenTurnDeadline, OPEN_TURN_AWAIT_BUILD_EXTENSION_MS, shouldCloseTurnRecord, } from "../intern/open-turn-store.js";
 import { maxPersistedBlockSeq } from "../intern/persisted-block-seq.js";
 import { appendBlockEvent, currentUserMessageText, handlerLlmRequest } from "./llm-dispatch.js";
+import { createAgentEvidenceWriter, nextAgentSessionMessages } from "../intern/agent-evidence.js";
 import { handleLlmResponse, } from "./stream-assembly.js";
 import { handleProdiaImageRequest } from "./image-gen.js";
 import { handleFSPrompt } from "./fs-prompt.js";
@@ -187,6 +192,8 @@ export const promptChatSection = {
         }
         let preAssembled;
         let agentAssembled;
+        let agentSession;
+        let agentEvidence;
         let agentFirstTurnMint = false;
         if (isReqCreationPromptChatSection(orig)) {
             if (agentWakeTurn === false && !orig.prompt.messages.some((m) => m.role === "user")) {
@@ -284,10 +291,157 @@ export const promptChatSection = {
                     ...(agentWakeNote === undefined ? {} : { wakeNote: agentWakeNote }),
                     ...(buildInFlight === undefined ? {} : { buildInFlight: { promptId: buildInFlight.promptId } }),
                     ...(agentFirstTurnMint ? { noAppYet: true } : {}),
+                    ...(agentSessionEnabled(vctx) && agentFirstTurnMint === false ? { session: true } : {}),
                 });
                 if (rAgent.isErr())
                     return Result.Err(rAgent);
                 agentAssembled = { model: rAgent.Ok().model, messages: rAgent.Ok().messages };
+                if (agentSessionEnabled(vctx) && agentFirstTurnMint === false) {
+                    const rawIncoming = orig.prompt.messages.filter(isUserChatMessage);
+                    const newMessageCount = orig.prompt.messages.filter(isChatMessage).length;
+                    const incoming = newMessageCount === 0 ? [] : rAgent.Ok().messages.slice(-newMessageCount).filter(isUserChatMessage);
+                    const delivered = incoming.length === 0 && agentWakeTurn
+                        ? [
+                            {
+                                role: "user",
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: agentWakeNote ??
+                                            "[session resumed] Continue from your persisted context and pending results. Inspect outcomes before retrying interrupted tools.",
+                                    },
+                                ],
+                            },
+                        ]
+                        : incoming;
+                    const acquired = await deliverAgentSession(vctx, {
+                        chatId: req.chatId,
+                        userId: req._auth.verifiedAuth.claims.userId,
+                        ownerHandle: resChat.ownerHandle,
+                        appSlug: resChat.appSlug,
+                    }, { id: ctx.validated.tid, messages: delivered });
+                    if (acquired.isErr())
+                        return Result.Err(acquired.Err());
+                    const { live, created } = acquired.Ok();
+                    if (created === false) {
+                        const receiptId = vctx.sthis.nextId(12).str;
+                        const receiptEvidence = createAgentEvidenceWriter({
+                            chatId: req.chatId,
+                            promptId: receiptId,
+                            sessionId: live.promptId,
+                            append: (evt, blockSeq) => appendBlockEvent({ ctx, vctx, req, promptId: receiptId, blockSeq, evt }),
+                        });
+                        const linked = await receiptEvidence({ kind: "active" });
+                        if (linked.isErr())
+                            return Result.Err(linked.Err());
+                        await ctx.send.send(ctx, wrapMsgBase(ctx.validated, {
+                            payload: {
+                                type: "vibes.diy.res-prompt-chat-section",
+                                chatId: req.chatId,
+                                ownerHandle: resChat.ownerHandle,
+                                appSlug: resChat.appSlug,
+                                promptId: receiptId,
+                                outerTid: req.outerTid,
+                                mode: req.mode,
+                            },
+                            tid: ctx.validated.tid,
+                            src: "agentSession",
+                        }));
+                        const echo = await appendBlockEvent({
+                            ctx,
+                            vctx,
+                            req,
+                            promptId: receiptId,
+                            blockSeq: 0,
+                            evt: {
+                                type: "prompt.req",
+                                streamId: receiptId,
+                                chatId: req.chatId,
+                                seq: 0,
+                                request: { messages: rawIncoming },
+                                timestamp: new Date(),
+                            },
+                        });
+                        if (echo.isErr())
+                            return Result.Err(echo.Err());
+                        const terminal = await appendBlockEvent({
+                            ctx,
+                            vctx,
+                            req,
+                            promptId: receiptId,
+                            blockSeq: 1,
+                            evt: {
+                                type: "block.end",
+                                streamId: receiptId,
+                                blockId: receiptId,
+                                blockNr: 0,
+                                seq: 1,
+                                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 } },
+                            },
+                        });
+                        if (terminal.isErr())
+                            return Result.Err(terminal.Err());
+                        const ended = await appendBlockEvent({
+                            ctx,
+                            vctx,
+                            req,
+                            promptId: receiptId,
+                            blockSeq: 2,
+                            evt: { type: "prompt.block-end", streamId: receiptId, chatId: req.chatId, seq: 2, timestamp: new Date() },
+                        });
+                        if (ended.isErr())
+                            return Result.Err(ended.Err());
+                        return Result.Ok(EventoResult.Continue);
+                    }
+                    agentSession = live;
+                    agentEvidence = createAgentEvidenceWriter({
+                        chatId: req.chatId,
+                        promptId: live.promptId,
+                        sessionId: live.promptId,
+                        append: (evt, blockSeq) => appendBlockEvent({ ctx, vctx, req, promptId: live.promptId, blockSeq, evt }),
+                    });
+                    const active = await agentEvidence({
+                        kind: "active",
+                        ...(live.supersedes === undefined ? {} : { supersedes: live.supersedes }),
+                    });
+                    if (active.isErr()) {
+                        live.close();
+                        return Result.Err(active.Err());
+                    }
+                    if (live.session.messages().length === 0) {
+                        const initial = agentAssembled.messages.slice(0, agentAssembled.messages.length - newMessageCount - (agentWakeNote === undefined ? 0 : 1));
+                        const saved = await live.session.checkpoint(initial);
+                        if (saved.isErr()) {
+                            live.close();
+                            return Result.Err(saved.Err());
+                        }
+                    }
+                    const events = await nextAgentSessionMessages(live.session, agentEvidence);
+                    if (events.isErr()) {
+                        live.close();
+                        return Result.Err(events.Err());
+                    }
+                    agentAssembled = {
+                        ...agentAssembled,
+                        messages: [
+                            ...agentAssembled.messages.filter((message) => message.role === "system"),
+                            ...live.session.messages().filter((message) => message.role !== "system"),
+                            ...(events.Ok() ?? []),
+                        ],
+                    };
+                    const saved = await live.session.checkpoint(agentAssembled.messages);
+                    if (saved.isErr()) {
+                        live.close();
+                        return Result.Err(saved.Err());
+                    }
+                }
             }
             else {
                 const rAssembled = await assemblePromptPayload(vctx, {
@@ -420,6 +574,7 @@ export const promptChatSection = {
         else if (agentAssembled !== undefined && isReqPromptLLMChatSection(orig)) {
             const agentPayload = agentAssembled;
             prompSectionAction = async (scope, blockSeq) => {
+                const liveSession = agentSession;
                 const rActor = await resolveAgentActor(vctx, {
                     userId: req._auth.verifiedAuth.claims.userId,
                     scope: { ownerHandle: resChat.ownerHandle, appSlug: resChat.appSlug },
@@ -432,11 +587,13 @@ export const promptChatSection = {
                     appSlug: resChat.appSlug,
                     editBaseFsId: undefined,
                 });
+                if (liveSession !== undefined && rVfs.isErr())
+                    return Result.Err(rVfs.Err());
                 if (rVfs.isErr()) {
                     vctx.logger.Warn().Err(rVfs).Str("chatId", req.chatId).Msg("agent-turn-vfs-load-failed");
                 }
-                const vfs = rVfs.isOk() ? rVfs.Ok() : new Map();
-                const pendingBuilds = agentAwaitBuildEnabled(vctx)
+                const vfs = new Map(rVfs.isOk() ? rVfs.Ok() : []);
+                const pendingBuilds = agentSessionEnabled(vctx) === false && agentAwaitBuildEnabled(vctx)
                     ? createPendingBuildLandings({
                         scope: vctx.connections,
                         renderLanding: (outcome) => renderBuildLandingNote(renderBuildSettledSentence(outcome)),
@@ -466,8 +623,8 @@ export const promptChatSection = {
                                 outerTid: req.outerTid,
                                 chatId: req.chatId,
                                 budget: missed.budget,
-                                note: renderAgentWakeNote(landing.outcome),
-                                handle: (wakeCtx) => promptChatSection.handle(wakeCtx),
+                                note: renderAgentWakeNote(landing.outcome, agentSessionEnabled(vctx)),
+                                handle: (wakeCtx) => promptChatSection.handle(promptDispatchContext(ctx, wakeCtx.validated)),
                             });
                         },
                         onRegister: (target) => {
@@ -493,8 +650,9 @@ export const promptChatSection = {
                     auth: orig.auth,
                     outerTid: req.outerTid,
                     handle: (dispatchCtx) => promptChatSection.handle(dispatchCtx),
-                    wakeBudget: agentWakeBudget,
+                    wakeBudget: liveSession === undefined ? agentWakeBudget : 0,
                     ...(pendingBuilds === undefined ? {} : { onPendingBuild: (t) => pendingBuilds.register(t) }),
+                    ...(agentSession === undefined ? {} : { onPendingBuild: (t) => agentSession?.watch(t.promptId) }),
                     ...(agentFirstTurnMint
                         ? { firstTurn: { chatId: req.chatId, ...(submittedAt === undefined ? {} : { submittedAt }) } }
                         : {}),
@@ -516,6 +674,8 @@ export const promptChatSection = {
                         : {}),
                     ...(agentFetchUrlContext === undefined ? {} : { fetchUrl: agentFetchUrlContext }),
                     dispatcher,
+                    ...(liveSession === undefined ? {} : { queueEdit: (input) => liveSession.queue(input) }),
+                    ...(liveSession === undefined ? {} : { fileSession: liveSession }),
                     onStyleApplied: async (applied) => {
                         await appendBlockEvent({
                             ctx,
@@ -542,6 +702,92 @@ export const promptChatSection = {
                             .Msg("agent-turn-dispatched-build");
                     },
                 });
+                if (agentSession !== undefined) {
+                    await agentSession.bind((input) => runEditVibeTool(vctx, {
+                        actor: rActor.Ok(),
+                        chatId: req.chatId,
+                        input,
+                        dispatcher,
+                    }), async (commit) => {
+                        const currentActor = await resolveAgentActor(vctx, {
+                            userId: rActor.Ok().userId,
+                            requestedHandle: rActor.Ok().ownerHandle,
+                            scope: rActor.Ok().scope,
+                        });
+                        if (currentActor.isErr())
+                            return Result.Err(currentActor.Err());
+                        const scoped = await resolveChatApp(vctx, currentActor.Ok(), req.chatId);
+                        if (scoped.isErr())
+                            return Result.Err(scoped.Err());
+                        const commitId = vctx.sthis.nextId(12).str;
+                        const lock = acquireTurnBuildLock({
+                            vctx,
+                            chatId: req.chatId,
+                            promptId: commitId,
+                            movesFilesystem: true,
+                            wakesOnTerminal: false,
+                        });
+                        if (lock.acquired === false)
+                            return Result.Err("A build is running; the staged commit could not acquire the write lane.");
+                        const committed = { promptBlockEndEmitted: false };
+                        const saved = await exception2Result(() => handleFSPrompt({
+                            scope,
+                            vctx,
+                            ctx,
+                            promptId: commitId,
+                            blockSeq: 0,
+                            terminal: committed,
+                            beginDirect: true,
+                            resChat: { ...resChat, mode: "fs-update" },
+                            req: {
+                                type: "vibes.diy.req-prompt-chat-section",
+                                mode: "fs-update",
+                                auth: orig.auth,
+                                _auth: req._auth,
+                                chatId: req.chatId,
+                                outerTid: req.outerTid,
+                                agentFileCommit: commit,
+                                fsUpdate: {
+                                    update: commit.changes.map((file) => ({
+                                        type: "code-block",
+                                        filename: file.path,
+                                        content: file.contents,
+                                        lang: langForFilename(file.path),
+                                    })),
+                                    remove: [],
+                                },
+                            },
+                        })).finally(() => {
+                            committed.releasePersistGate?.();
+                            releaseTurnBuildLock(vctx, req.chatId, commitId);
+                        });
+                        if (saved.isErr()) {
+                            const last = await maxPersistedBlockSeq(vctx.sql, { chatId: req.chatId, promptId: commitId });
+                            if (last.isErr())
+                                return Result.Err(last.Err());
+                            const seq = (last.Ok() ?? -1) + 1;
+                            await appendBlockEvent({
+                                ctx,
+                                vctx,
+                                req,
+                                promptId: commitId,
+                                blockSeq: seq,
+                                evt: {
+                                    type: "prompt.error",
+                                    streamId: commitId,
+                                    chatId: req.chatId,
+                                    seq,
+                                    timestamp: new Date(),
+                                    error: saved.Err().message,
+                                },
+                            });
+                            return Result.Err(saved.Err());
+                        }
+                        if (committed.fsRef === undefined)
+                            return Result.Err("The commit did not persist a version.");
+                        return Result.Ok({ ok: true, saved: true, fsRef: committed.fsRef, paths: commit.changes.map((file) => file.path) });
+                    });
+                }
                 const res = await handlerLlmRequest({
                     ctx,
                     blockSeq,
@@ -553,6 +799,13 @@ export const promptChatSection = {
                     preAssembled: { ...agentPayload, isInitialTurn: false },
                     serverTools: belt.definitions,
                 });
+                const evidence = agentEvidence ??
+                    createAgentEvidenceWriter({
+                        chatId: req.chatId,
+                        promptId,
+                        ...(liveSession === undefined ? {} : { sessionId: liveSession.promptId }),
+                        append: (evt, blockSeq) => appendBlockEvent({ ctx, vctx, req, promptId, blockSeq, evt }),
+                    });
                 let providerStream;
                 const rSse = createProviderSseStream(res.res, promptId);
                 if (rSse.isErr()) {
@@ -569,8 +822,43 @@ export const promptChatSection = {
                         request: res.llmReq,
                         stream: rSse.Ok(),
                         abort: res.abort,
+                        onToolEvidence: ({ kind, call, text }) => evidence({ kind, callId: call.id, name: call.name, text }),
                         ...(pendingBuilds === undefined ? {} : { pending: pendingBuilds.pending }),
+                        ...(liveSession === undefined
+                            ? {}
+                            : {
+                                session: {
+                                    checkpoint: async (messages) => {
+                                        const saved = await liveSession.session.checkpoint(messages);
+                                        if (saved.isErr())
+                                            return saved;
+                                        const extended = await extendOpenTurnDeadline(vctx.sql, {
+                                            chatId: req.chatId,
+                                            promptId,
+                                            deadlineAtMs: Date.now() + agentTotalBudgetMs(vctx) + OPEN_TURN_AWAIT_BUILD_EXTENSION_MS,
+                                        });
+                                        if (extended.isErr())
+                                            return Result.Err(extended.Err());
+                                        return Result.Ok();
+                                    },
+                                    next: () => nextAgentSessionMessages(liveSession.session, evidence),
+                                    dispatchBudgetMs: agentTotalBudgetMs(vctx),
+                                },
+                            }),
                         dispatch: async ({ request, budget }) => {
+                            if (agentSession !== undefined) {
+                                const latest = await loadWorkVfs(vctx, {
+                                    chatId: req.chatId,
+                                    ownerHandle: resChat.ownerHandle,
+                                    appSlug: resChat.appSlug,
+                                    editBaseFsId: undefined,
+                                });
+                                if (latest.isErr())
+                                    return Result.Err(latest.Err());
+                                vfs.clear();
+                                for (const [path, content] of latest.Ok())
+                                    vfs.set(path, content);
+                            }
                             const dispatch = await dispatchLlmRequestWithFallback({
                                 vctx,
                                 mode: req.mode,
@@ -784,7 +1072,7 @@ export const promptChatSection = {
         if (rBump.isErr()) {
             vctx.logger.Warn().Err(rBump).Msg("bumpAppRecency failed");
         }
-        const promptId = vctx.sthis.nextId(96 / 8).str;
+        const promptId = agentSession?.promptId ?? vctx.sthis.nextId(96 / 8).str;
         const movesFilesystem = isSourceChangingMode(req.mode) && discuss === false && agentAssembled === undefined;
         const wakesOnTerminal = decideAgentWake({
             agentLane,
@@ -814,6 +1102,7 @@ export const promptChatSection = {
             src: "promptChatSection",
         })));
         if (rAck.isErr()) {
+            agentSession?.close();
             releaseTurnBuildLock(vctx, req.chatId, promptId);
             return Result.Err(rAck);
         }
@@ -916,6 +1205,7 @@ export const promptChatSection = {
                         });
                     }
                     peekInFlightTurns(req.chatId)?.delete(promptId);
+                    agentSession?.close();
                     releaseTurnBuildLock(vctx, req.chatId, promptId);
                     terminal.releasePersistGate?.();
                     const landingOutcome = {
@@ -931,7 +1221,7 @@ export const promptChatSection = {
                         agentLane,
                         agentDispatched: agentDispatchedBuild,
                         movedFilesystem: movesFilesystem,
-                        budget: agentWakeBudget,
+                        budget: agentSessionEnabled(vctx) ? 1 : agentWakeBudget,
                     });
                     if (consumed === true) {
                         vctx.logger
@@ -951,8 +1241,8 @@ export const promptChatSection = {
                             note: renderAgentWakeNote({
                                 outcome: turnErrored ? "error" : terminal.settled?.applied === true ? "applied" : "no-code",
                                 ...(terminal.touchedPaths === undefined ? {} : { touchedPaths: terminal.touchedPaths }),
-                            }),
-                            handle: (wakeCtx) => promptChatSection.handle(wakeCtx),
+                            }, agentSessionEnabled(vctx)),
+                            handle: (wakeCtx) => promptChatSection.handle(promptDispatchContext(ctx, wakeCtx.validated)),
                         });
                     }
                     else {