@jait/gateway 0.1.519 → 0.1.521

package/dist/routes/chat.js

@@ -6,7 +6,7 @@ import { RemoteCliProvider } from "../providers/remote-cli-provider.js";
 import { resolveProjectRoot } from "../tools/core/get-fs.js";
 import { existsSync } from "node:fs";
 import { messages as messagesTable } from "../db/schema.js";
-import { eq } from "drizzle-orm";
+import { eq, sql } from "drizzle-orm";
 import { uuidv7 } from "../db/uuidv7.js";
 import { requireAuth } from "../security/http-auth.js";
 import { signAuthToken } from "../security/http-auth.js";
@@ -541,6 +541,34 @@ function accumulateToolStart(sessionId, callId, tool, args, parentCallId) {
         acc.segments.push({ type: "toolGroup", callIds: [callId] });
     }
 }
+function accumulateToolApproval(sessionId, requestId, tool, args) {
+    const callId = `approval-${requestId}`;
+    const acc = getOrCreateAccumulator(sessionId);
+    const existing = acc.toolCalls.find(t => t.callId === callId);
+    if (!existing) {
+        acc.toolCalls.push({
+            callId,
+            tool,
+            args,
+            ok: true,
+            message: "Awaiting approval",
+            status: "pending",
+            approvalRequestId: requestId,
+            approvalState: "pending",
+            startedAt: Date.now(),
+        });
+    }
+    const last = acc.segments[acc.segments.length - 1];
+    if (last?.type === "toolGroup") {
+        if (!last.callIds.includes(callId)) {
+            acc.segments[acc.segments.length - 1] = { type: "toolGroup", callIds: [...last.callIds, callId] };
+        }
+    }
+    else {
+        acc.segments.push({ type: "toolGroup", callIds: [callId] });
+    }
+    return callId;
+}
 /** Record streaming output for a tool call */
 function accumulateToolOutput(sessionId, callId, content) {
     const acc = sessionStreamingState.get(sessionId);
@@ -623,9 +651,11 @@ function mapPersistedToolCallsForUI(toolCalls) {
         parentCallId: tc.parentCallId,
         tool: tc.tool,
         args: (typeof tc.args === "object" && tc.args !== null ? tc.args : {}),
-        status: tc.ok ? "success" : "error",
+        status: tc.status ?? (tc.ok ? "success" : "error"),
         ok: tc.ok,
         message: tc.message,
+        approvalRequestId: tc.approvalRequestId,
+        approvalState: tc.approvalState,
         output: tc.output,
         data: tc.data,
         startedAt: tc.startedAt,
@@ -716,6 +746,65 @@ function windowMessages(messages, limit, before) {
         hasMore: start > 0,
     };
 }
+function rowToUIMsg(sessionId, row, visibleIndex) {
+    const msg = {
+        id: `${sessionId}-${visibleIndex}`,
+        role: row.role,
+        content: typeof row.content === "string" ? row.content : String(row.content ?? ""),
+    };
+    if (row.toolCalls) {
+        try {
+            msg.toolCalls = JSON.parse(row.toolCalls);
+        }
+        catch { /* ignore */ }
+    }
+    if (row.segments) {
+        try {
+            msg.segments = JSON.parse(row.segments);
+        }
+        catch { /* ignore */ }
+    }
+    if (row.thinking) {
+        msg.thinking = row.thinking;
+    }
+    if (row.contextFlow) {
+        try {
+            const parsed = JSON.parse(row.contextFlow);
+            if (parsed && typeof parsed === "object" && Array.isArray(parsed.rounds)) {
+                msg.contextFlow = parsed;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return msg;
+}
+function persistedMessageWindow(db, sessionId, limit, before) {
+    const totalRow = db
+        .select({ count: sql `count(*)` })
+        .from(messagesTable)
+        .where(eq(messagesTable.sessionId, sessionId))
+        .get();
+    const total = Number(totalRow?.count ?? 0);
+    const end = typeof before === "number" && Number.isFinite(before) && before >= 0 && before < total
+        ? Math.floor(before)
+        : total;
+    const start = Math.max(end - limit, 0);
+    const rows = start < end
+        ? db
+            .select()
+            .from(messagesTable)
+            .where(eq(messagesTable.sessionId, sessionId))
+            .orderBy(messagesTable.createdAt, messagesTable.id)
+            .limit(end - start)
+            .offset(start)
+            .all()
+        : [];
+    return {
+        messages: rows.map((row, index) => rowToUIMsg(sessionId, row, start + index)),
+        total,
+        hasMore: start > 0,
+    };
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1015,7 +1104,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             .select()
             .from(messagesTable)
             .where(eq(messagesTable.sessionId, sessionId))
-            .orderBy(messagesTable.createdAt)
+            .orderBy(messagesTable.createdAt, messagesTable.id)
             .all();
         if (rows.length > 0) {
             sessionHistory.set(sessionId, [
@@ -1095,7 +1184,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 .select()
                 .from(messagesTable)
                 .where(eq(messagesTable.sessionId, sessionId))
-                .orderBy(messagesTable.createdAt)
+                .orderBy(messagesTable.createdAt, messagesTable.id)
                 .all();
             const lastAssistant = [...rows].reverse().find((row) => row.role === "assistant");
             if (!lastAssistant)
@@ -1253,6 +1342,9 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache",
             Connection: "keep-alive",
+            // Prevent reverse proxies (nginx etc.) from buffering the SSE stream,
+            // which would otherwise swallow chunks and let the connection time out.
+            "X-Accel-Buffering": "no",
             "Access-Control-Allow-Origin": reqOrigin,
             "Access-Control-Allow-Credentials": "true",
         });
@@ -1374,6 +1466,21 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 }
             }
         };
+        // ── SSE keepalive heartbeat ──
+        // While the agentic loop runs a long tool or waits for a slow LLM response,
+        // no SSE data events are emitted and the connection can go idle for tens of
+        // seconds. Browsers and reverse proxies then close the socket, surfacing as
+        // "fetch failed" on the frontend and dropping the in-progress assistant
+        // message. Emit an SSE comment (": keepalive\n\n") every 15s — comments are
+        // ignored by the EventSource/reader parser but keep the TCP connection alive.
+        const keepalive = setInterval(() => {
+            if (clientDisconnected) {
+                clearInterval(keepalive);
+                return;
+            }
+            safeWrite(`: keepalive\n\n`);
+        }, 15_000);
+        reply.raw.on("close", () => { clearInterval(keepalive); });
         const matchedSkillIds = new Set(matchSkills(content, promptCtx.skills ?? []));
         const matchedSkills = (promptCtx.skills ?? []).filter((skill) => matchedSkillIds.has(skill.id));
         const turnSkillToolCall = buildSyntheticSkillToolCall(matchedSkills);
@@ -1447,6 +1554,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                     cliProvider = providerRegistry.get(requestProvider) ?? null;
                 }
                 if (!cliProvider) {
+                    clearInterval(keepalive);
                     safeWrite(`data: ${JSON.stringify({ type: "error", message: `Unknown provider: ${requestProvider}` })}\n\n`);
                     reply.raw.end();
                     return;
@@ -1695,9 +1803,13 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                                 }
                                 break;
                             }
-                            case "tool.approval-required":
-                                safeWrite(`data: ${JSON.stringify({ type: "approval_required", tool: event.tool, args: event.args, requestId: event.requestId })}\n\n`);
+                            case "tool.approval-required": {
+                                const callId = accumulateToolApproval(sessionId, event.requestId, event.tool, event.args);
+                                const approvalEvent = { type: "approval_required", call_id: callId, request_id: event.requestId, tool: event.tool, args: event.args };
+                                safeWrite(`data: ${JSON.stringify(approvalEvent)}\n\n`);
+                                emitToSubscribers(sessionId, approvalEvent);
                                 break;
+                            }
                             case "message":
                                 if (event.role === "assistant" && event.content) {
                                     flushToolGroup();
@@ -2104,6 +2216,8 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             const tcJson = partialToolCalls.length > 0 ? JSON.stringify(partialToolCalls) : undefined;
             persistMessage(sessionId, "assistant", fullContent || "", tcJson, resultSegmentsJson, contextFlowJson);
         }
+        // Stop the SSE keepalive heartbeat now that the turn is finishing.
+        clearInterval(keepalive);
         activeStreams.delete(sessionId);
         sessionAbortControllers.delete(sessionId);
         sessionSteeringControllers.delete(sessionId);
@@ -2161,6 +2275,30 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
         }
         void drainQueuedChatMessages(sessionId);
     });
+    app.post("/api/sessions/:sessionId/approve", async (request, reply) => {
+        const authUser = await requireAuth(request, reply, config.jwtSecret);
+        if (!authUser)
+            return;
+        const { sessionId } = request.params;
+        const body = request.body;
+        const requestId = typeof body["requestId"] === "string" ? body["requestId"] : "";
+        const approved = body["approved"] !== false;
+        if (!requestId) {
+            return reply.status(400).send({ error: "VALIDATION_ERROR", details: "requestId is required" });
+        }
+        if (sessionService) {
+            const session = sessionService.getById(sessionId, authUser.id);
+            if (!session) {
+                return reply.status(404).send({ error: "NOT_FOUND", details: "Session not found" });
+            }
+        }
+        const activeCliSession = activeCliSessions.get(sessionId);
+        if (!activeCliSession) {
+            return reply.status(409).send({ error: "CONFLICT", details: "No active provider session for approval" });
+        }
+        await activeCliSession.provider.respondToApproval(activeCliSession.providerSessionId, requestId, approved);
+        return reply.status(200).send({ ok: true });
+    });
     // Cancel an active stream for a session
     app.post("/api/sessions/:sessionId/cancel", async (request, reply) => {
         const authUser = await requireAuth(request, reply, config.jwtSecret);
@@ -2257,7 +2395,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 .select()
                 .from(messagesTable)
                 .where(eq(messagesTable.sessionId, sessionId))
-                .orderBy(messagesTable.createdAt)
+                .orderBy(messagesTable.createdAt, messagesTable.id)
                 .all();
             const rowsToDelete = rows.slice(Math.max(0, target.historyIndex - 1));
             for (const row of rowsToDelete) {
@@ -2299,13 +2437,18 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             : typeof query?.before === "string"
                 ? Number.parseInt(query.before, 10)
                 : undefined;
-        hydrateSession(sessionId);
-        const history = sessionHistory.get(sessionId) ?? [];
-        const visible = buildVisibleHistoryMessages(sessionId, history);
-        const windowed = windowMessages(visible, limit, Number.isFinite(before) ? before : undefined);
+        const streaming = activeStreams.has(sessionId);
+        const windowed = db && !streaming
+            ? persistedMessageWindow(db, sessionId, limit, Number.isFinite(before) ? before : undefined)
+            : (() => {
+                hydrateSession(sessionId);
+                const history = sessionHistory.get(sessionId) ?? [];
+                const visible = buildVisibleHistoryMessages(sessionId, history, { includePendingAssistantToolCalls: streaming });
+                return windowMessages(visible, limit, Number.isFinite(before) ? before : undefined);
+            })();
         return {
             sessionId,
-            streaming: activeStreams.has(sessionId),
+            streaming,
             total: windowed.total,
             hasMore: windowed.hasMore,
             limit,
@@ -2332,59 +2475,26 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache",
             Connection: "keep-alive",
+            "X-Accel-Buffering": "no",
             "Access-Control-Allow-Origin": reqOrigin,
             "Access-Control-Allow-Credentials": "true",
         });
-        hydrateSession(sessionId);
-        const history = sessionHistory.get(sessionId) ?? [];
         const isStreaming = activeStreams.has(sessionId);
+        // Only the DB-windowed idle path can skip hydrating. Sessions without a DB
+        // (in-memory history) still need their completed messages loaded from the
+        // sessionHistory map, and streaming sessions need partial content too.
+        let history = [];
+        if (!db || isStreaming) {
+            hydrateSession(sessionId);
+            history = sessionHistory.get(sessionId) ?? [];
+        }
         // Build snapshot. While streaming, prefer in-memory history so partial assistant
         // content is visible immediately (DB persistence may lag until stream completion).
         let snapshotMessages;
         let total = 0;
         let hasMore = false;
         if (db && !isStreaming) {
-            const rows = db
-                .select()
-                .from(messagesTable)
-                .where(eq(messagesTable.sessionId, sessionId))
-                .orderBy(messagesTable.createdAt)
-                .all();
-            const allMessages = rows
-                .filter((r) => r.role === "user" || r.role === "assistant")
-                .map((r, i) => {
-                const msg = {
-                    id: `${sessionId}-${i}`,
-                    role: r.role,
-                    content: typeof r.content === "string" ? r.content : String(r.content ?? ""),
-                };
-                if (r.toolCalls) {
-                    try {
-                        msg.toolCalls = JSON.parse(r.toolCalls);
-                    }
-                    catch { /* ignore */ }
-                }
-                if (r.segments) {
-                    try {
-                        msg.segments = JSON.parse(r.segments);
-                    }
-                    catch { /* ignore */ }
-                }
-                if (r.thinking) {
-                    msg.thinking = r.thinking;
-                }
-                if (r.contextFlow) {
-                    try {
-                        const parsed = JSON.parse(r.contextFlow);
-                        if (parsed && typeof parsed === "object" && Array.isArray(parsed.rounds)) {
-                            msg.contextFlow = parsed;
-                        }
-                    }
-                    catch { /* ignore */ }
-                }
-                return msg;
-            });
-            const windowed = windowMessages(allMessages, limit);
+            const windowed = persistedMessageWindow(db, sessionId, limit);
             snapshotMessages = windowed.messages;
             total = windowed.total;
             hasMore = windowed.hasMore;
@@ -2415,10 +2525,13 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
         const snapshotSeq = sessionStreamSeq.get(sessionId) ?? 0;
         let closed = false;
         let unsubscribe = () => { };
+        let keepalive = null;
         const closeStream = () => {
             if (closed)
                 return;
             closed = true;
+            if (keepalive)
+                clearInterval(keepalive);
             unsubscribe();
             try {
                 reply.raw.end();
@@ -2428,6 +2541,18 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
         reply.raw.on("close", () => {
             closeStream();
         });
+        // Keep the SSE connection alive during idle periods (long tool runs / slow
+        // LLM responses) so browsers/proxies don't drop it with "fetch failed".
+        keepalive = setInterval(() => {
+            if (closed)
+                return;
+            try {
+                reply.raw.write(`: keepalive\n\n`);
+            }
+            catch {
+                closeStream();
+            }
+        }, 15_000);
         unsubscribe = subscribe(sessionId, snapshotSeq, (event) => {
             if (closed)
                 return;
@@ -2491,7 +2616,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 .select()
                 .from(messagesTable)
                 .where(eq(messagesTable.sessionId, sessionId))
-                .orderBy(messagesTable.createdAt)
+                .orderBy(messagesTable.createdAt, messagesTable.id)
                 .all();
             const lastAssistant = [...rows].reverse().find((r) => r.role === "assistant");
             if (lastAssistant) {