waypoi 0.0.0

package/dist/src/routes/sessions.js

@@ -0,0 +1,450 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSessionRoutes = registerSessionRoutes;
+const sessionRepository_1 = require("../storage/sessionRepository");
+const imageCache_1 = require("../storage/imageCache");
+const files_1 = require("../storage/files");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const router_1 = require("../routing/router");
+const repositories_1 = require("../storage/repositories");
+/**
+ * Sessions Routes
+ *
+ * REST API for managing chat sessions in the playground.
+ *
+ * Endpoints:
+ *   GET    /admin/sessions           - List all sessions
+ *   POST   /admin/sessions           - Create a new session
+ *   GET    /admin/sessions/:id       - Get session by ID
+ *   PUT    /admin/sessions/:id       - Update session metadata
+ *   DELETE /admin/sessions/:id       - Delete a session
+ *   POST   /admin/sessions/:id/messages - Add a message to session
+ *   PATCH  /admin/sessions/:id/messages/:msgIndex - Append to message (streaming)
+ *
+ *   GET    /admin/images/:hash       - Get cached image by hash
+ *   POST   /admin/images             - Store image in cache
+ *   GET    /admin/images/stats       - Get image cache stats
+ *   DELETE /admin/images             - Clear image cache
+ */
+async function registerSessionRoutes(app) {
+    const paths = (0, files_1.resolveStoragePaths)();
+    await (0, imageCache_1.ensureMediaCacheReady)(paths);
+    app.log.info({ mediaRoot: path_1.default.join(paths.baseDir, "media") }, "Media cache initialized");
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Session CRUD
+    // ─────────────────────────────────────────────────────────────────────────────
+    app.get("/admin/sessions", async (_req, reply) => {
+        try {
+            const sessions = await (0, sessionRepository_1.listSessions)(paths);
+            return reply.send({
+                object: "list",
+                data: sessions.map((s) => ({
+                    id: s.id,
+                    name: s.name,
+                    model: s.model,
+                    storageVersion: s.storageVersion,
+                    titleStatus: s.titleStatus,
+                    titleUpdatedAt: s.titleUpdatedAt,
+                    messageCount: s.messages.length,
+                    createdAt: s.createdAt,
+                    updatedAt: s.updatedAt,
+                })),
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to list sessions");
+            return reply.status(500).send({
+                error: { message: "Failed to list sessions", type: "internal_error" },
+            });
+        }
+    });
+    app.post("/admin/sessions", async (req, reply) => {
+        try {
+            const { name, model } = req.body || {};
+            const session = await (0, sessionRepository_1.createSession)(paths, { name, model });
+            return reply.status(201).send(toApiSession(session));
+        }
+        catch (error) {
+            app.log.error(error, "Failed to create session");
+            return reply.status(500).send({
+                error: { message: "Failed to create session", type: "internal_error" },
+            });
+        }
+    });
+    app.post("/admin/sessions/:id/auto-title", async (req, reply) => {
+        try {
+            const session = await (0, sessionRepository_1.getSession)(paths, req.params.id);
+            if (!session) {
+                return reply.status(404).send({
+                    error: { message: "Session not found", type: "not_found" },
+                });
+            }
+            const seedText = req.body?.seedText?.trim() || extractSeedTextFromSession(session.messages);
+            if (!seedText) {
+                return reply.status(400).send({
+                    error: { message: "seedText is required for auto-title", type: "invalid_request" },
+                });
+            }
+            const model = req.body?.model ||
+                session.model ||
+                (await (0, repositories_1.pickBestModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["text"] }, "llm"));
+            let generated = false;
+            let title = fallbackTitleFromSeed(seedText);
+            if (model) {
+                try {
+                    title = await generateTitleFromModel(paths, model, seedText);
+                    generated = true;
+                }
+                catch (error) {
+                    app.log.warn(error, "Auto-title generation failed, using fallback title");
+                }
+            }
+            const updated = await (0, sessionRepository_1.updateSession)(paths, req.params.id, {
+                name: title,
+                titleStatus: generated ? "generated" : "failed",
+                titleUpdatedAt: new Date(),
+            });
+            if (!updated) {
+                return reply.status(404).send({
+                    error: { message: "Session not found", type: "not_found" },
+                });
+            }
+            return reply.send({
+                id: updated.id,
+                name: updated.name,
+                titleStatus: updated.titleStatus,
+                titleUpdatedAt: updated.titleUpdatedAt,
+                generated,
+                model,
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to auto-title session");
+            return reply.status(500).send({
+                error: { message: "Failed to auto-title session", type: "internal_error" },
+            });
+        }
+    });
+    app.get("/admin/sessions/:id", async (req, reply) => {
+        try {
+            const session = await (0, sessionRepository_1.getSession)(paths, req.params.id);
+            if (!session) {
+                return reply.status(404).send({
+                    error: { message: "Session not found", type: "not_found" },
+                });
+            }
+            return reply.send(toApiSession(session));
+        }
+        catch (error) {
+            app.log.error(error, "Failed to get session");
+            return reply.status(500).send({
+                error: { message: "Failed to get session", type: "internal_error" },
+            });
+        }
+    });
+    app.put("/admin/sessions/:id", async (req, reply) => {
+        try {
+            const updates = {};
+            if (req.body?.name !== undefined)
+                updates.name = req.body.name;
+            if (req.body?.model !== undefined)
+                updates.model = req.body.model;
+            const session = await (0, sessionRepository_1.updateSession)(paths, req.params.id, updates);
+            if (!session) {
+                return reply.status(404).send({
+                    error: { message: "Session not found", type: "not_found" },
+                });
+            }
+            return reply.send(toApiSession(session));
+        }
+        catch (error) {
+            app.log.error(error, "Failed to update session");
+            return reply.status(500).send({
+                error: { message: "Failed to update session", type: "internal_error" },
+            });
+        }
+    });
+    app.delete("/admin/sessions/:id", async (req, reply) => {
+        try {
+            const deleted = await (0, sessionRepository_1.deleteSession)(paths, req.params.id);
+            if (!deleted) {
+                return reply.status(404).send({
+                    error: { message: "Session not found", type: "not_found" },
+                });
+            }
+            return reply.status(204).send();
+        }
+        catch (error) {
+            app.log.error(error, "Failed to delete session");
+            return reply.status(500).send({
+                error: { message: "Failed to delete session", type: "internal_error" },
+            });
+        }
+    });
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Message management
+    // ─────────────────────────────────────────────────────────────────────────────
+    app.post("/admin/sessions/:id/messages", async (req, reply) => {
+        try {
+            const message = await (0, sessionRepository_1.addMessage)(paths, req.params.id, normalizeIncomingMessage(req.body));
+            if (!message) {
+                return reply.status(404).send({
+                    error: { message: "Session not found", type: "not_found" },
+                });
+            }
+            return reply.status(201).send({
+                messageId: message.id,
+                createdAt: message.createdAt,
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to add message");
+            return reply.status(500).send({
+                error: { message: "Failed to add message", type: "internal_error" },
+            });
+        }
+    });
+    app.patch("/admin/sessions/:id/messages/:messageId", async (req, reply) => {
+        try {
+            const success = await (0, sessionRepository_1.appendMessageContent)(paths, req.params.id, req.params.messageId, req.body?.content || "");
+            if (!success) {
+                return reply.status(404).send({
+                    error: { message: "Session or message not found", type: "not_found" },
+                });
+            }
+            return reply.send({ success: true });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to append to message");
+            return reply.status(500).send({
+                error: { message: "Failed to append to message", type: "internal_error" },
+            });
+        }
+    });
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Media cache (/admin/media) with image alias compatibility (/admin/images)
+    // ─────────────────────────────────────────────────────────────────────────────
+    registerMediaCacheRoutes("/admin/media");
+    registerMediaCacheRoutes("/admin/images");
+    function registerMediaCacheRoutes(prefix) {
+        app.get(`${prefix}/stats`, async (_req, reply) => {
+            try {
+                const stats = await (0, imageCache_1.getCacheStats)(paths);
+                return reply.send(stats);
+            }
+            catch (error) {
+                app.log.error(error, "Failed to get media cache stats");
+                return reply.status(500).send({
+                    error: { message: "Failed to get cache stats", type: "internal_error" },
+                });
+            }
+        });
+        app.get(`${prefix}/:hash`, async (req, reply) => {
+            try {
+                const filePath = await (0, imageCache_1.getMediaPath)(paths, req.params.hash);
+                const entry = await (0, imageCache_1.getMediaEntry)(paths, req.params.hash);
+                if (!filePath || !entry) {
+                    return reply.status(404).send({
+                        error: { message: "Media not found", type: "not_found" },
+                    });
+                }
+                const buffer = await fs_1.promises.readFile(filePath);
+                return reply
+                    .header("Content-Type", entry.mimeType || guessMimeType(filePath))
+                    .header("Cache-Control", "public, max-age=31536000, immutable")
+                    .send(buffer);
+            }
+            catch (error) {
+                app.log.error(error, "Failed to get media");
+                return reply.status(500).send({
+                    error: { message: "Failed to get media", type: "internal_error" },
+                });
+            }
+        });
+        app.post(`${prefix}`, async (req, reply) => {
+            try {
+                if (!req.body?.data) {
+                    return reply.status(400).send({
+                        error: { message: "Missing media data", type: "invalid_request" },
+                    });
+                }
+                const result = await (0, imageCache_1.storeMedia)(paths, req.body.data, {
+                    model: req.body.model,
+                    mimeType: req.body.mimeType,
+                });
+                return reply.status(201).send({
+                    hash: result.hash,
+                    mimeType: result.mimeType,
+                    url: `${prefix}/${result.hash}`,
+                    evicted: result.evicted,
+                });
+            }
+            catch (error) {
+                app.log.error(error, "Failed to store media");
+                return reply.status(500).send({
+                    error: { message: "Failed to store media", type: "internal_error" },
+                });
+            }
+        });
+        app.delete(`${prefix}`, async (_req, reply) => {
+            try {
+                const deleted = await (0, imageCache_1.clearCache)(paths);
+                return reply.send({ deleted });
+            }
+            catch (error) {
+                app.log.error(error, "Failed to clear media cache");
+                return reply.status(500).send({
+                    error: { message: "Failed to clear cache", type: "internal_error" },
+                });
+            }
+        });
+    }
+}
+function normalizeIncomingMessage(body) {
+    return {
+        role: body.role ?? "user",
+        content: body.content ?? "",
+        name: body.name,
+        tool_calls: body.tool_calls,
+        tool_call_id: body.tool_call_id,
+        images: body.images,
+        model: body.model,
+    };
+}
+function toApiSession(session) {
+    return {
+        ...session,
+        messages: session.messages.map((message) => ({
+            ...message,
+            timestamp: message.createdAt,
+        })),
+    };
+}
+function guessMimeType(filePath) {
+    const ext = path_1.default.extname(filePath).slice(1).toLowerCase();
+    const mimeTypes = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        webp: "image/webp",
+        wav: "audio/wav",
+        mp3: "audio/mpeg",
+        ogg: "audio/ogg",
+        webm: "audio/webm",
+        m4a: "audio/mp4",
+    };
+    return mimeTypes[ext] ?? "application/octet-stream";
+}
+function extractSeedTextFromSession(messages) {
+    const firstUserMessage = messages.find((message) => message.role === "user");
+    if (!firstUserMessage) {
+        return "";
+    }
+    return textFromContent(firstUserMessage.content);
+}
+function textFromContent(content) {
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (part.type === "text") {
+            parts.push(part.text);
+        }
+    }
+    return parts.join(" ").trim();
+}
+function fallbackTitleFromSeed(seed) {
+    const cleaned = sanitizeTitle(seed);
+    if (!cleaned) {
+        return "New Session";
+    }
+    const words = cleaned.split(/\s+/).slice(0, 7).join(" ");
+    return words.length > 60 ? words.slice(0, 60).trim() : words;
+}
+async function generateTitleFromModel(paths, model, seedText) {
+    const prompt = [
+        "Generate a short title for this chat.",
+        "Rules: 3-7 words, sentence case, no quotes, no punctuation at end.",
+        "Return only the title text.",
+        `Chat seed: ${seedText}`,
+    ].join("\n");
+    const payload = {
+        model,
+        stream: false,
+        temperature: 0,
+        max_tokens: 32,
+        messages: [
+            {
+                role: "system",
+                content: "You write concise conversation titles.",
+            },
+            {
+                role: "user",
+                content: prompt,
+            },
+        ],
+    };
+    const outcome = await (0, router_1.routeRequest)(paths, model, "/v1/chat/completions", payload, {}, AbortSignal.timeout(15_000), {
+        requiredInput: ["text"],
+        requiredOutput: ["text"],
+    });
+    const payloadJson = await readJsonBody(outcome.attempt.response.body);
+    const text = extractAssistantText(payloadJson);
+    const sanitized = sanitizeTitle(text);
+    if (!sanitized) {
+        throw new Error("Model did not return a valid title");
+    }
+    return sanitized;
+}
+async function readJsonBody(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    return JSON.parse(text);
+}
+function extractAssistantText(payload) {
+    if (!payload || typeof payload !== "object") {
+        return "";
+    }
+    const choices = payload.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return "";
+    }
+    const content = choices[0]?.message?.content;
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (part && typeof part === "object" && typeof part.text === "string") {
+            parts.push(part.text);
+        }
+    }
+    return parts.join(" ");
+}
+function sanitizeTitle(input) {
+    const normalized = input
+        .replace(/[\r\n]+/g, " ")
+        .replace(/["'`]+/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    const trimmed = normalized.replace(/[.,;:!?]+$/g, "").trim();
+    if (!trimmed) {
+        return "";
+    }
+    return trimmed.length > 60 ? trimmed.slice(0, 60).trim() : trimmed;
+}