@jait/gateway 0.1.518 → 0.1.520

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)
@@ -1345,6 +1434,11 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
         let resultSegmentsJson;
         let contextFlowJson;
         let hitMaxRounds = false;
+        // Whether the agentic loop already persisted the assistant message via its
+        // onPersist callback. The post-loop fallback persists must be skipped when
+        // this is true to avoid writing a duplicate DB row (which scrambled message
+        // order on reload because the rows share createdAt down to the millisecond).
+        let loopPersisted = false;
         activeStreams.add(sessionId);
         // Reset streaming accumulator for this turn so reload snapshots start fresh
         sessionStreamingState.delete(sessionId);
@@ -1690,9 +1784,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();
@@ -2026,6 +2124,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 }
                 resultSegmentsJson = resultSegments.length > 0 ? JSON.stringify(resultSegments) : undefined;
                 hitMaxRounds = result.hitMaxRounds;
+                loopPersisted = result.persisted === true;
                 // Persist fingerprints so a Continue turn reuses them
                 sessionFingerprints.set(sessionId, result.fingerprints);
                 // Re-serialize contextFlow now that round metrics have been attached
@@ -2068,12 +2167,13 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             const wasCancelled = err instanceof Error && err.name === "AbortError";
             if (!wasCancelled)
                 app.log.error(err, `${providerLabel} streaming error`);
-            // Save partial content for real (non-cancel) errors
-            if (!wasCancelled && (fullContent || partialToolCalls.length > 0)) {
+            // Save partial content for real (non-cancel) errors — but only if the
+            // agentic loop didn't already persist this turn's assistant message.
+            if (!wasCancelled && !loopPersisted && (fullContent || partialToolCalls.length > 0)) {
                 const tcJson = partialToolCalls.length > 0 ? JSON.stringify(partialToolCalls) : undefined;
                 persistMessage(sessionId, "assistant", fullContent || "", tcJson, resultSegmentsJson, contextFlowJson);
             }
-            else if (!wasCancelled) {
+            else if (!wasCancelled && !loopPersisted) {
                 // No partial content — persist the error message itself so it's visible on reload.
                 const errMsg2 = err instanceof Error ? err.message : `Failed to reach ${providerLabel}`;
                 persistMessage(sessionId, "assistant", errMsg2, undefined, JSON.stringify([{ type: "error", content: errMsg2 }]), contextFlowJson);
@@ -2091,7 +2191,9 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
         }
         // Persist partial results BEFORE clearing stream state so that a reload
         // between these two steps loads the cancelled tool calls from the DB.
-        if (streamAbort.signal.aborted && (fullContent || partialToolCalls.length > 0)) {
+        // Skip when the agentic loop already persisted via onPersist (avoids a
+        // duplicate row that scrambled message order on reload).
+        if (streamAbort.signal.aborted && !loopPersisted && (fullContent || partialToolCalls.length > 0)) {
             const tcJson = partialToolCalls.length > 0 ? JSON.stringify(partialToolCalls) : undefined;
             persistMessage(sessionId, "assistant", fullContent || "", tcJson, resultSegmentsJson, contextFlowJson);
         }
@@ -2152,6 +2254,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);
@@ -2248,7 +2374,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) {
@@ -2290,13 +2416,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,
@@ -2326,56 +2457,22 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             "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;
@@ -2482,7 +2579,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) {