@vibes.diy/api-svc 2.0.0-dev-cli-i → 2.0.0-dev-cli-l

package/public/prompt-chat-section.js

@@ -1,12 +1,12 @@
 import { Result, Option, EventoResult, exception2Result, chunkyAsync, BuildURI, pathOps, URI, } from "@adviser/cement";
 import { scopey } from "@adviser/scopey";
-import { isReqCreationPromptChatSection, isReqPromptApplicationChatSection, parseArrayWarning, PromptAndBlockMsgs, reqPromptChatSection, } from "@vibes.diy/api-types";
+import { isReqCreationPromptChatSection, isReqPromptApplicationChatSection, isReqPromptFSChatSection, isReqPromptFSUpdateChatSection, isReqPromptImageChatSection, isReqPromptLLMChatSection, parseArrayWarning, PromptAndBlockMsgs, reqPromptChatSection, isPromptReq, isReqPromptFSSetChatSection, parseArray, vibeFile, isVibeCodeBlock, } from "@vibes.diy/api-types";
 import { ensureLogger } from "@fireproof/core-runtime";
 import { type } from "arktype";
 import { checkAuth } from "../check-auth.js";
 import { unwrapMsgBase, wrapMsgBase } from "../unwrap-msg-base.js";
-import { and, eq } from "drizzle-orm/sql/expressions";
-import { createStatsCollector, createLineStream, createDataStream, createSseStream, createDeltaStream, createSectionsStream, isBlockEnd, isCodeBegin, isCodeEnd, isCodeLine, isPromptReq, FileSystemRef, isBlockStreamMsg, } from "@vibes.diy/call-ai-v2";
+import { and, desc, eq } from "drizzle-orm/sql/expressions";
+import { createStatsCollector, createLineStream, createDataStream, createSseStream, createDeltaStream, createSectionsStream, isBlockEnd, isCodeBegin, isCodeEnd, isCodeLine, FileSystemRef, isBlockStreamMsg, } from "@vibes.diy/call-ai-v2";
 import { makeBaseSystemPrompt, resolveEffectiveModel } from "@vibes.diy/prompts";
 import { ensureAppSlugItem } from "./ensure-app-slug-item.js";
 import { getModelDefaults } from "../intern/get-model-defaults.js";
@@ -232,6 +232,340 @@ async function injectSystemPrompt(vctx, chatId, model) {
         ],
     });
 }
+async function getResChatFromMode(vctx, req, orig) {
+    const iResChat = await vctx.sql.db
+        .select()
+        .from(vctx.sql.tables.chatContexts)
+        .where(and(eq(vctx.sql.tables.chatContexts.userId, req._auth.verifiedAuth.claims.userId), eq(vctx.sql.tables.chatContexts.chatId, req.chatId)))
+        .limit(1)
+        .then((r) => r[0]);
+    if (!iResChat) {
+        if (isReqCreationPromptChatSection(orig)) {
+            return Result.Err(`Creation Chat ID ${req.chatId} not found`);
+        }
+        else if (isReqPromptApplicationChatSection(orig)) {
+            return Result.Err(`Application Chat ID ${req.chatId} not found`);
+        }
+        else if (isReqPromptImageChatSection(orig)) {
+            return Result.Err(`Image Chat ID ${req.chatId} not found`);
+        }
+    }
+    const resChat = { ...iResChat, mode: orig.mode };
+    return Result.Ok(resChat);
+}
+async function handlerLlmRequest({ scope, ctx, vctx, blockSeq, req, resChat, promptId, }) {
+    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,
+                timestamp: new Date(),
+            },
+        });
+        blockSeq++;
+        return r;
+    })
+        .do();
+    const modelId = await scope
+        .evalResult(async () => {
+        const r = await getModelDefaults(vctx, { appSlug: resChat.appSlug, userSlug: resChat.userSlug });
+        if (r.isErr()) {
+            return Result.Err(r);
+        }
+        switch (req.mode) {
+            case "chat":
+                return Result.Ok(req.prompt.model ?? r.Ok().chat.model.id);
+            case "app":
+                return Result.Ok(req.prompt.model ?? r.Ok().app.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 (req.mode === "chat") {
+            withSystemPrompt = await injectSystemPrompt(vctx, req.chatId, req.prompt.model ?? modelId);
+        }
+        else if (req.mode === "app") {
+            withSystemPrompt = Result.Ok({
+                model: req.prompt.model ?? modelId,
+                messages: req.prompt.messages,
+            });
+        }
+        return withSystemPrompt;
+    })
+        .do();
+    const llmReq = {
+        ...{
+            ...req.prompt,
+            messages: withSystemPrompt.messages,
+        },
+        ...vctx.params.llm.enforced,
+        model: withSystemPrompt.model,
+        headers: vctx.params.llm.headers,
+        logprobs: true,
+        stream: true,
+    };
+    const res = await scope
+        .evalResult(async () => {
+        console.log(promptId, "Sending LLM request:", llmReq.model);
+        const res = await vctx.llmRequest(llmReq);
+        if (!res.ok) {
+            return Result.Err(`LLM request failed with status ${res.status} :${llmReq.model} : ${res.statusText}`);
+        }
+        if (!res.body) {
+            return Result.Err(`LLM request returned no body`);
+        }
+        return Result.Ok(res);
+    })
+        .do();
+    return { res, blockSeq };
+}
+async function handleEndMsg({ collectedMsgs, vctx, req, ctx, resChat, promptId, value, blockSeq, }) {
+    const r = await handlePromptContext({ vctx, req, promptId, resChat, value, blockSeq, collectedMsgs });
+    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, }) {
+    await scope
+        .evalResult(async () => {
+        const pipeline = res
+            .body.pipeThrough(createStatsCollector(promptId, 1000))
+            .pipeThrough(createLineStream(promptId))
+            .pipeThrough(createDataStream(promptId))
+            .pipeThrough(createSseStream(promptId))
+            .pipeThrough(createDeltaStream(promptId, () => vctx.sthis.nextId(12).str))
+            .pipeThrough(createSectionsStream(promptId, () => vctx.sthis.nextId(12).str));
+        const reader = pipeline.getReader();
+        let collectedMsgs;
+        let chatCtx;
+        for (const conn of vctx.connections) {
+            const tChatCtx = conn.chatIds.get(req.chatId);
+            if (tChatCtx) {
+                chatCtx = tChatCtx;
+                const promptIdCtx = chatCtx.promptIds.get(promptId);
+                if (!promptIdCtx) {
+                    collectedMsgs = [];
+                    chatCtx.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) {
+            return Result.Err(`Chat context not found for chatId: ${req.chatId}`);
+        }
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (!isBlockEnd(value)) {
+                if (!isBlockStreamMsg(value)) {
+                    continue;
+                }
+                collectedMsgs.push(value);
+                const r = await appendBlockEvent({
+                    ctx,
+                    vctx,
+                    req,
+                    promptId,
+                    blockSeq: blockSeq++,
+                    evt: value,
+                    emitMode: "emit-only",
+                });
+                if (r.isErr()) {
+                    return Result.Err(r);
+                }
+            }
+            else {
+                collectedMsgs.push(value);
+                const x = await handleEndMsg({ collectedMsgs, vctx, req, ctx, resChat, promptId, value, blockSeq });
+                if (x.isErr()) {
+                    return Result.Err(x);
+                }
+                collectedMsgs.splice(0, collectedMsgs.length);
+            }
+        }
+        return Result.Ok();
+    })
+        .do();
+    return blockSeq;
+}
+export async function handleFSPrompt({ scope, vctx, resChat, req, ctx, promptId, }) {
+    let fileSystem;
+    if (isReqPromptFSSetChatSection(req)) {
+        fileSystem = req.fsSet;
+    }
+    else if (isReqPromptFSUpdateChatSection(req)) {
+        const refFS = [];
+        if (!req.refFsId) {
+            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(and(eq(vctx.sql.tables.promptContexts.chatId, req.chatId), eq(vctx.sql.tables.promptContexts.promptId, promptId)))
+                .orderBy(desc(vctx.sql.tables.promptContexts.created))
+                .limit(1)
+                .then((r) => r[0]);
+            if (lastestPrompt) {
+                refFS.push(...parseArray(lastestPrompt.Apps.fileSystem, vibeFile));
+            }
+        }
+        const mapFS = refFS.reduce((acc, file) => {
+            acc.set(file.filename, file);
+            return acc;
+        }, {});
+        req.fsUpdate.update.forEach((update) => {
+            mapFS.set(update.filename, update);
+        });
+        req.fsUpdate.remove?.forEach((item) => {
+            mapFS.delete(item.filename);
+        });
+        fileSystem = Array.from(mapFS.values());
+    }
+    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,
+                    },
+                ];
+            }),
+        ];
+        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);
+        return handleEndMsg({
+            collectedMsgs,
+            vctx,
+            req,
+            ctx,
+            resChat,
+            promptId,
+            value,
+            blockSeq,
+        });
+    })
+        .do();
+    return Result.Ok();
+}
 export const promptChatSection = {
     hash: "prompt-chat-section-handler",
     validate: unwrapMsgBase(async (msg) => {
@@ -248,33 +582,51 @@ export const promptChatSection = {
         const req = ctx.validated.payload;
         const orig = ctx.enRequest.payload;
         const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
-        let resChat;
-        if (isReqCreationPromptChatSection(orig)) {
-            const iResChat = await vctx.sql.db
-                .select()
-                .from(vctx.sql.tables.chatContexts)
-                .where(and(eq(vctx.sql.tables.chatContexts.chatId, req.chatId), eq(vctx.sql.tables.chatContexts.userId, req._auth.verifiedAuth.claims.userId)))
-                .limit(1)
-                .then((r) => r[0]);
-            if (!iResChat) {
-                return Result.Err(`Creation Chat ID ${req.chatId} not found`);
-            }
-            resChat = { ...iResChat, mode: "chat" };
+        const rResChat = await getResChatFromMode(vctx, req, orig);
+        if (rResChat.isErr()) {
+            return Result.Err(rResChat);
         }
-        if (isReqPromptApplicationChatSection(orig)) {
-            const iResChat = await vctx.sql.db
-                .select()
-                .from(vctx.sql.tables.applicationChats)
-                .where(and(eq(vctx.sql.tables.applicationChats.userId, req._auth.verifiedAuth.claims.userId), eq(vctx.sql.tables.applicationChats.chatId, req.chatId)))
-                .limit(1)
-                .then((r) => r[0]);
-            if (!iResChat) {
-                return Result.Err(`Application Chat ID ${req.chatId} not found`);
-            }
-            resChat = { ...iResChat, mode: "app" };
+        const resChat = rResChat.Ok();
+        let prompSectionAction;
+        if (isReqPromptLLMChatSection(orig)) {
+            prompSectionAction = async (scope, blockSeq) => {
+                const res = await handlerLlmRequest({
+                    ctx,
+                    blockSeq,
+                    scope,
+                    vctx,
+                    req: req,
+                    resChat,
+                    promptId,
+                });
+                await handleLlmResponse({
+                    scope,
+                    vctx,
+                    req: req,
+                    ctx,
+                    res: res.res,
+                    resChat,
+                    promptId,
+                    blockSeq: res.blockSeq,
+                });
+                return Result.Ok();
+            };
+        }
+        if (isReqPromptFSChatSection(orig)) {
+            prompSectionAction = async (scope, blockSeq) => {
+                return handleFSPrompt({
+                    scope,
+                    vctx,
+                    req: req,
+                    ctx,
+                    resChat,
+                    promptId,
+                    blockSeq,
+                });
+            };
         }
-        if (!resChat) {
-            return Result.Err(`Chat ID ${req.chatId} not found: ${req.mode}: ${isReqCreationPromptChatSection(orig) ? "creation" : isReqPromptApplicationChatSection(orig) ? "application" : "unknown"}`);
+        if (!prompSectionAction) {
+            return Result.Err(`Unsupported prompt chat section mode: ${orig.mode}`);
         }
         const promptId = vctx.sthis.nextId(96 / 8).str;
         await ctx.send.send(ctx, wrapMsgBase(ctx.validated, {
@@ -350,175 +702,7 @@ export const promptChatSection = {
                 }
             })
                 .do();
-            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,
-                        timestamp: new Date(),
-                    },
-                });
-                blockSeq++;
-                return r;
-            })
-                .do();
-            const modelId = await scope
-                .evalResult(async () => {
-                const r = await getModelDefaults(vctx, { appSlug: resChat.appSlug, userSlug: resChat.userSlug });
-                if (r.isErr()) {
-                    return Result.Err(r);
-                }
-                switch (req.mode) {
-                    case "chat":
-                        return Result.Ok(req.prompt.model ?? r.Ok().chat.model.id);
-                    case "app":
-                        return Result.Ok(req.prompt.model ?? r.Ok().app.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 (req.mode === "chat") {
-                    withSystemPrompt = await injectSystemPrompt(vctx, req.chatId, req.prompt.model ?? modelId);
-                }
-                else if (req.mode === "app") {
-                    withSystemPrompt = Result.Ok({
-                        model: req.prompt.model ?? modelId,
-                        messages: req.prompt.messages,
-                    });
-                }
-                return withSystemPrompt;
-            })
-                .do();
-            const llmReq = {
-                ...{
-                    ...req.prompt,
-                    messages: withSystemPrompt.messages,
-                },
-                ...vctx.params.llm.enforced,
-                model: withSystemPrompt.model,
-                headers: vctx.params.llm.headers,
-                logprobs: true,
-                stream: true,
-            };
-            const res = await scope
-                .evalResult(async () => {
-                console.log(promptId, "Sending LLM request:", llmReq.model);
-                const res = await vctx.llmRequest(llmReq);
-                if (!res.ok) {
-                    return Result.Err(`LLM request failed with status ${res.status} :${llmReq.model} : ${res.statusText}`);
-                }
-                if (!res.body) {
-                    return Result.Err(`LLM request returned no body`);
-                }
-                return Result.Ok(res);
-            })
-                .do();
-            await scope
-                .evalResult(async () => {
-                const pipeline = res
-                    .body.pipeThrough(createStatsCollector(promptId, 1000))
-                    .pipeThrough(createLineStream(promptId))
-                    .pipeThrough(createDataStream(promptId))
-                    .pipeThrough(createSseStream(promptId))
-                    .pipeThrough(createDeltaStream(promptId, () => vctx.sthis.nextId(12).str))
-                    .pipeThrough(createSectionsStream(promptId, () => vctx.sthis.nextId(12).str));
-                const reader = pipeline.getReader();
-                let collectedMsgs;
-                let chatCtx;
-                for (const conn of vctx.connections) {
-                    const tChatCtx = conn.chatIds.get(req.chatId);
-                    if (tChatCtx) {
-                        chatCtx = tChatCtx;
-                        const promptIdCtx = chatCtx.promptIds.get(promptId);
-                        if (!promptIdCtx) {
-                            collectedMsgs = [];
-                            chatCtx.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) {
-                    return Result.Err(`Chat context not found for chatId: ${req.chatId}`);
-                }
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
-                    }
-                    if (!isBlockEnd(value)) {
-                        if (!isBlockStreamMsg(value)) {
-                            continue;
-                        }
-                        collectedMsgs.push(value);
-                        const r = await appendBlockEvent({
-                            ctx,
-                            vctx,
-                            req,
-                            promptId,
-                            blockSeq: blockSeq++,
-                            evt: value,
-                            emitMode: "emit-only",
-                        });
-                        if (r.isErr()) {
-                            return Result.Err(r);
-                        }
-                    }
-                    else {
-                        collectedMsgs.push(value);
-                        const r = await handlePromptContext({ vctx, req, promptId, resChat, value, blockSeq, collectedMsgs });
-                        if (r.isErr()) {
-                            return Result.Err(r);
-                        }
-                        const promptIdCtx = chatCtx.promptIds.get(promptId);
-                        if (promptIdCtx) {
-                            chatCtx.promptIds.delete(promptId);
-                        }
-                        blockSeq = r.Ok().blockSeq;
-                        const rEvt = await appendBlockEvent({
-                            ctx,
-                            vctx,
-                            req,
-                            promptId,
-                            blockSeq: blockSeq++,
-                            evt: { ...value, fsRef: r.Ok().fsRef.toValue() },
-                            emitMode: "emit-only",
-                        });
-                        if (rEvt.isErr()) {
-                            return Result.Err(rEvt);
-                        }
-                        collectedMsgs.splice(0, collectedMsgs.length);
-                    }
-                }
-                return Result.Ok();
-            })
-                .do();
+            await prompSectionAction(scope, blockSeq);
         });
         return Result.Ok(EventoResult.Continue);
     }),