@junctionpanel/server 0.1.33 → 0.1.35

package/dist/server/server/agent/providers/gemini-agent.js

@@ -1,9 +1,10 @@
 import * as acp from "@agentclientprotocol/sdk";
 import { execSync, spawn, spawnSync } from "node:child_process";
-import { readdir, readFile } from "node:fs/promises";
+import { access, readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { Readable as NodeReadable, Writable as NodeWritable } from "node:stream";
+import { setTimeout as delay } from "node:timers/promises";
 import { z } from "zod";
 import { applyProviderEnv, isProviderCommandAvailable, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputSchema, ToolSearchInputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, } from "./tool-call-detail-primitives.js";
@@ -13,6 +14,8 @@ const GEMINI_MODES = ["default", "auto_edit", "yolo", "plan"];
 const GEMINI_GLOBAL_DIR = path.join(homedir(), ".gemini");
 const GEMINI_TMP_DIR = path.join(GEMINI_GLOBAL_DIR, "tmp");
 const GEMINI_HISTORY_FALLBACK_IDLE_MS = 1000;
+const GEMINI_RECORDED_SESSION_POLL_INTERVAL_MS = 100;
+const GEMINI_RECORDED_SESSION_DISCOVERY_TIMEOUT_MS = 200;
 const GEMINI_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -98,6 +101,22 @@ const GeminiRecordedThoughtSchema = z
     text: z.string().optional(),
 })
     .passthrough();
+const GeminiRecordedTokensSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}, z
+    .object({
+    input: z.number().nonnegative().optional(),
+    output: z.number().nonnegative().optional(),
+    cached: z.number().nonnegative().optional(),
+    thoughts: z.number().nonnegative().optional(),
+    tool: z.number().nonnegative().optional(),
+    total: z.number().nonnegative().optional(),
+})
+    .passthrough()
+    .optional());
 const GeminiRecordedToolCallSchema = z
     .object({
     id: z.string().optional(),
@@ -112,10 +131,13 @@ const GeminiRecordedMessageSchema = z
     .object({
     id: z.string().optional(),
     type: z.string(),
+    timestamp: z.string().optional(),
     content: z.unknown().optional(),
     displayContent: z.unknown().optional(),
     thoughts: z.array(GeminiRecordedThoughtSchema).optional(),
     toolCalls: z.array(GeminiRecordedToolCallSchema).optional(),
+    tokens: GeminiRecordedTokensSchema.optional(),
+    model: z.string().optional(),
 })
     .passthrough();
 const GeminiRecordedSessionSchema = z
@@ -463,20 +485,22 @@ function toGeminiModelDefinitions() {
 async function readGeminiSessionFile(filePath) {
     try {
         const raw = await readFile(filePath, "utf8");
-        const parsed = JSON.parse(raw);
-        const session = GeminiRecordedSessionSchema.safeParse(parsed);
-        if (!session.success) {
-            return null;
-        }
-        if (session.data.kind === "subagent") {
-            return null;
-        }
-        return session.data;
+        return parseGeminiRecordedSession(JSON.parse(raw));
     }
     catch {
         return null;
     }
 }
+export function parseGeminiRecordedSession(raw) {
+    const session = GeminiRecordedSessionSchema.safeParse(raw);
+    if (!session.success) {
+        return null;
+    }
+    if (session.data.kind === "subagent") {
+        return null;
+    }
+    return session.data;
+}
 function extractRecordedContentText(content) {
     if (typeof content === "string") {
         return content;
@@ -529,8 +553,22 @@ function extractRecordedThoughtText(thought) {
 }
 export function buildGeminiHistoryTimeline(session) {
     const items = [];
+    let pendingTurnMessages = [];
+    const flushPendingTurnSummary = () => {
+        const summary = summarizeGeminiRecordedMessages(pendingTurnMessages);
+        pendingTurnMessages = [];
+        if (!summary) {
+            return;
+        }
+        items.push({
+            type: "turn_summary",
+            usage: summary.usage,
+            modelId: summary.modelId,
+        });
+    };
     for (const message of session.messages) {
         if (message.type === "user") {
+            flushPendingTurnSummary();
             const text = extractRecordedContentText(message.content ?? message.displayContent).trim();
             if (text.length > 0) {
                 items.push({
@@ -542,8 +580,10 @@ export function buildGeminiHistoryTimeline(session) {
             continue;
         }
         if (message.type !== "gemini") {
+            flushPendingTurnSummary();
             continue;
         }
+        pendingTurnMessages.push(message);
         const assistantText = extractRecordedContentText(message.content ?? message.displayContent).trim();
         if (assistantText.length > 0) {
             items.push({ type: "assistant_message", text: assistantText });
@@ -568,8 +608,107 @@ export function buildGeminiHistoryTimeline(session) {
             }));
         }
     }
+    flushPendingTurnSummary();
     return items;
 }
+export function summarizeGeminiRecordedMessages(messages) {
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let outputTokens = 0;
+    let hasUsage = false;
+    let modelId = null;
+    for (const message of messages) {
+        if (message.type !== "gemini") {
+            continue;
+        }
+        const usage = toGeminiRecordedUsage(message);
+        if (usage) {
+            inputTokens += usage.inputTokens ?? 0;
+            cachedInputTokens += usage.cachedInputTokens ?? 0;
+            outputTokens += usage.outputTokens ?? 0;
+            hasUsage = true;
+        }
+        const recordedModelId = nonEmptyString(message.model);
+        if (recordedModelId) {
+            modelId = recordedModelId;
+        }
+    }
+    if (!hasUsage) {
+        return null;
+    }
+    return {
+        usage: {
+            ...(inputTokens > 0 ? { inputTokens } : {}),
+            ...(cachedInputTokens > 0 ? { cachedInputTokens } : {}),
+            ...(outputTokens > 0 ? { outputTokens } : {}),
+        },
+        modelId,
+    };
+}
+export function summarizeGeminiRecordedTurn(session, turnStartedAt) {
+    return summarizeGeminiRecordedMessages(getGeminiRecordedTurnMessages(session, turnStartedAt));
+}
+function getGeminiRecordedTurnMessages(session, turnStartedAt) {
+    const turnStartMs = turnStartedAt.getTime();
+    const turnMessages = [];
+    let collecting = false;
+    for (const message of session.messages) {
+        const timestampMs = typeof message.timestamp === "string" ? Date.parse(message.timestamp) : Number.NaN;
+        const isInTurn = Number.isFinite(timestampMs) && timestampMs >= turnStartMs;
+        if (isInTurn) {
+            collecting = true;
+            turnMessages.push(message);
+            continue;
+        }
+        if (collecting && message.type === "gemini") {
+            turnMessages.push(message);
+        }
+    }
+    return turnMessages;
+}
+function hasGeminiRecordedAssistantMessage(messages) {
+    return messages.some((message) => message.type === "gemini");
+}
+function countGeminiRecordedHistoryEvents(session) {
+    let count = 0;
+    for (const message of session.messages) {
+        if (message.type === "user") {
+            const text = extractRecordedContentText(message.content ?? message.displayContent).trim();
+            if (text.length > 0) {
+                count += 1;
+            }
+            continue;
+        }
+        if (message.type !== "gemini") {
+            continue;
+        }
+        const assistantText = extractRecordedContentText(message.content ?? message.displayContent).trim();
+        if (assistantText.length > 0) {
+            count += 1;
+        }
+        for (const thought of message.thoughts ?? []) {
+            const text = extractRecordedThoughtText(thought);
+            if (text) {
+                count += 1;
+            }
+        }
+        count += (message.toolCalls ?? []).length;
+    }
+    return count;
+}
+function toGeminiRecordedUsage(message) {
+    const inputTokens = message.tokens?.input ?? 0;
+    const cachedInputTokens = message.tokens?.cached ?? 0;
+    const outputTokens = message.tokens?.output ?? 0;
+    if (inputTokens === 0 && cachedInputTokens === 0 && outputTokens === 0) {
+        return undefined;
+    }
+    return {
+        ...(inputTokens > 0 ? { inputTokens } : {}),
+        ...(cachedInputTokens > 0 ? { cachedInputTokens } : {}),
+        ...(outputTokens > 0 ? { outputTokens } : {}),
+    };
+}
 async function listKnownGeminiProjects() {
     let entries;
     try {
@@ -598,11 +737,14 @@ async function resolveGeminiProjectTempDirForCwd(cwd) {
     const projects = await listKnownGeminiProjects();
     return projects.find((project) => project.cwd === cwd)?.tempDir ?? null;
 }
-async function loadGeminiRecordedSessionForCwd(cwd, sessionId) {
+async function findGeminiRecordedSessionForCwd(cwd, sessionId) {
     const tempDir = await resolveGeminiProjectTempDirForCwd(cwd);
     if (!tempDir) {
         return null;
     }
+    return findGeminiRecordedSessionForTempDir(tempDir, sessionId);
+}
+async function findGeminiRecordedSessionForTempDir(tempDir, sessionId) {
     const chatsDir = path.join(tempDir, "chats");
     let chatFiles;
     try {
@@ -615,13 +757,26 @@ async function loadGeminiRecordedSessionForCwd(cwd, sessionId) {
         if (!fileName.startsWith("session-") || !fileName.endsWith(".json")) {
             continue;
         }
-        const session = await readGeminiSessionFile(path.join(chatsDir, fileName));
+        const filePath = path.join(chatsDir, fileName);
+        const session = await readGeminiSessionFile(filePath);
         if (session?.sessionId === sessionId) {
-            return session;
+            return {
+                filePath,
+                session,
+            };
         }
     }
     return null;
 }
+async function geminiSessionFileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function listGeminiSessionsForProject(params) {
     const chatsDir = path.join(params.tempDir, "chats");
     let chatFiles;
@@ -1023,6 +1178,8 @@ class GeminiAgentSession {
         this.expectedHistoryEventCount = null;
         this.capturedHistoryEventCount = 0;
         this.currentRunInterrupted = false;
+        this.hasObservedRecordedSession = false;
+        this.recordedSessionFilePath = null;
         this.config = config;
         this.logger = logger.child({ sessionProvider: GEMINI_PROVIDER });
         this.runtimeSettings = runtimeSettings;
@@ -1049,6 +1206,7 @@ class GeminiAgentSession {
         const timeline = [];
         let finalText = "";
         let canceled = false;
+        let usage;
         for await (const event of this.stream(prompt, options)) {
             if (event.type === "timeline") {
                 timeline.push(event.item);
@@ -1056,6 +1214,9 @@ class GeminiAgentSession {
                     finalText += event.item.text;
                 }
             }
+            else if (event.type === "turn_completed") {
+                usage = event.usage;
+            }
             else if (event.type === "turn_failed") {
                 throw new Error(event.error);
             }
@@ -1066,6 +1227,7 @@ class GeminiAgentSession {
         return {
             sessionId: this.sessionId ?? "",
             finalText,
+            ...(usage ? { usage } : {}),
             timeline,
             ...(canceled ? { canceled } : {}),
         };
@@ -1081,6 +1243,7 @@ class GeminiAgentSession {
         const queue = new AsyncEventQueue();
         this.activeTurnQueue = queue;
         this.currentRunInterrupted = false;
+        const turnStartedAt = new Date();
         queue.push({
             type: "turn_started",
             provider: GEMINI_PROVIDER,
@@ -1090,7 +1253,7 @@ class GeminiAgentSession {
             sessionId: this.sessionId,
             prompt: toGeminiPromptBlocks(prompt),
         })
-            .then((response) => {
+            .then(async (response) => {
             if (response.stopReason === "cancelled") {
                 queue.push({
                     type: "turn_canceled",
@@ -1099,9 +1262,17 @@ class GeminiAgentSession {
                 });
             }
             else {
+                // ACP does not report usage, so we synthesize it from Gemini's recorded session file.
+                const recordedTurnSummary = await this.readRecordedTurnSummary(turnStartedAt);
                 queue.push({
                     type: "turn_completed",
                     provider: GEMINI_PROVIDER,
+                    ...(recordedTurnSummary
+                        ? {
+                            usage: recordedTurnSummary.usage,
+                            modelId: recordedTurnSummary.modelId,
+                        }
+                        : {}),
                 });
             }
             queue.close();
@@ -1379,8 +1550,11 @@ class GeminiAgentSession {
                 },
             });
             if (this.sessionId) {
-                const recordedSession = await loadGeminiRecordedSessionForCwd(this.config.cwd, this.sessionId);
-                this.beginHistoryCapture(recordedSession ? buildGeminiHistoryTimeline(recordedSession).length : null);
+                const recordedSessionMatch = await findGeminiRecordedSessionForCwd(this.config.cwd, this.sessionId);
+                const recordedSession = recordedSessionMatch?.session ?? null;
+                this.hasObservedRecordedSession = recordedSession !== null;
+                this.recordedSessionFilePath = recordedSessionMatch?.filePath ?? null;
+                this.beginHistoryCapture(recordedSession ? countGeminiRecordedHistoryEvents(recordedSession) : null);
                 const response = await this.connection.loadSession({
                     sessionId: this.sessionId,
                     cwd: this.config.cwd,
@@ -1527,6 +1701,71 @@ class GeminiAgentSession {
     emitLiveEvent(event) {
         this.activeTurnQueue?.push(event);
     }
+    async readRecordedTurnSummary(turnStartedAt) {
+        if (!this.sessionId) {
+            return null;
+        }
+        const tempDir = await resolveGeminiProjectTempDirForCwd(this.config.cwd);
+        if (!tempDir) {
+            return null;
+        }
+        const deadline = Date.now() + GEMINI_HISTORY_FALLBACK_IDLE_MS;
+        const discoveryDeadline = Date.now() +
+            (this.hasObservedRecordedSession && !this.recordedSessionFilePath
+                ? GEMINI_RECORDED_SESSION_DISCOVERY_TIMEOUT_MS
+                : GEMINI_HISTORY_FALLBACK_IDLE_MS);
+        let latestFingerprint = null;
+        let observedSummary = false;
+        let latestEmptyTurnFingerprint = null;
+        let observedEmptyTurn = false;
+        let sawRecordedSession = false;
+        while (Date.now() <= deadline) {
+            let recordedSession = null;
+            if (this.recordedSessionFilePath) {
+                recordedSession = await readGeminiSessionFile(this.recordedSessionFilePath);
+                if (!recordedSession && !(await geminiSessionFileExists(this.recordedSessionFilePath))) {
+                    this.recordedSessionFilePath = null;
+                }
+            }
+            if (!recordedSession) {
+                const recordedSessionMatch = await findGeminiRecordedSessionForTempDir(tempDir, this.sessionId);
+                recordedSession = recordedSessionMatch?.session ?? null;
+                if (recordedSessionMatch) {
+                    this.recordedSessionFilePath = recordedSessionMatch.filePath;
+                }
+            }
+            if (recordedSession) {
+                sawRecordedSession = true;
+                this.hasObservedRecordedSession = true;
+                const turnMessages = getGeminiRecordedTurnMessages(recordedSession, turnStartedAt);
+                const nextSummary = summarizeGeminiRecordedMessages(turnMessages);
+                if (nextSummary) {
+                    const nextFingerprint = JSON.stringify(nextSummary);
+                    if (observedSummary && nextFingerprint === latestFingerprint) {
+                        return nextSummary;
+                    }
+                    latestFingerprint = nextFingerprint;
+                    observedSummary = true;
+                    observedEmptyTurn = false;
+                    latestEmptyTurnFingerprint = null;
+                }
+                else if (hasGeminiRecordedAssistantMessage(turnMessages)) {
+                    const nextEmptyTurnFingerprint = JSON.stringify(turnMessages);
+                    if (observedEmptyTurn &&
+                        nextEmptyTurnFingerprint === latestEmptyTurnFingerprint) {
+                        return null;
+                    }
+                    observedEmptyTurn = true;
+                    latestEmptyTurnFingerprint = nextEmptyTurnFingerprint;
+                }
+            }
+            else if (!sawRecordedSession && Date.now() >= discoveryDeadline) {
+                return null;
+            }
+            await delay(GEMINI_RECORDED_SESSION_POLL_INTERVAL_MS);
+        }
+        return null;
+    }
     async handlePermissionRequest(params) {
         if (this.currentRunInterrupted) {
             return {