@junctionpanel/server 0.1.76 → 0.1.78

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

@@ -412,6 +412,25 @@ function asRecord(value) {
     }
     return value;
 }
+function parseGeminiErrorPayload(value) {
+    const directRecord = asRecord(value);
+    if (directRecord) {
+        return directRecord;
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+        return null;
+    }
+    try {
+        return asRecord(JSON.parse(trimmed));
+    }
+    catch {
+        return null;
+    }
+}
 function formatGeminiAcpError(error) {
     if (error instanceof acp.RequestError) {
         const directMessage = nonEmptyString(error.message);
@@ -426,9 +445,45 @@ function formatGeminiAcpError(error) {
         }
         return message;
     }
-    const message = nonEmptyString(stringifyUnknown(error));
+    const rawMessage = stringifyUnknown(error);
+    const errorPayload = parseGeminiErrorPayload(rawMessage) ?? parseGeminiErrorPayload(error);
+    const payloadMessage = nonEmptyString(errorPayload?.message);
+    const message = payloadMessage ?? nonEmptyString(rawMessage);
+    const normalizedMessage = message?.toLowerCase() ?? "";
+    if (message &&
+        normalizedMessage.includes("no capacity available for model")) {
+        return `${message} Retry in a moment or switch to a Flash/Auto Gemini model.`;
+    }
     return message ?? "Gemini ACP request failed";
 }
+function appendGeminiStreamText(current, incoming) {
+    if (incoming.length === 0) {
+        return current;
+    }
+    if (current.length === 0) {
+        return incoming;
+    }
+    if (incoming.length > current.length && incoming.startsWith(current)) {
+        return incoming;
+    }
+    const maxOverlap = Math.min(current.length, Math.max(incoming.length - 1, 0));
+    for (let overlapLength = maxOverlap; overlapLength > 0; overlapLength -= 1) {
+        if (current.endsWith(incoming.slice(0, overlapLength))) {
+            return current + incoming.slice(overlapLength);
+        }
+    }
+    return current + incoming;
+}
+function shouldPreferRecordedGeminiTurnOutput(modelId) {
+    const normalizedModelId = modelId?.trim().toLowerCase() ?? "";
+    return (normalizedModelId.includes("gemini-3.1-pro-preview") ||
+        normalizedModelId.includes("gemini-3.1-pro-preview-customtools"));
+}
+function shouldDeferGeminiTextStreaming(modelId) {
+    const normalizedModelId = modelId?.trim().toLowerCase() ?? "";
+    return (shouldPreferRecordedGeminiTurnOutput(normalizedModelId) ||
+        normalizedModelId.includes("auto-gemini-3"));
+}
 export function normalizeGeminiMode(modeId) {
     if (!modeId) {
         return DEFAULT_GEMINI_MODE;
@@ -849,6 +904,16 @@ function getGeminiRecordedTurnMessages(session, turnStartedAt) {
 function hasGeminiRecordedAssistantMessage(messages) {
     return messages.some((message) => message.type === "gemini");
 }
+function buildGeminiRecordedTurnOutputItems(messages) {
+    const items = [];
+    for (const message of messages) {
+        if (message.type !== "gemini") {
+            continue;
+        }
+        items.push(...buildGeminiRecordedMessageTimelineItems(message).filter((item) => item.type === "assistant_message" || item.type === "reasoning"));
+    }
+    return items;
+}
 function countGeminiRecordedHistoryEvents(session) {
     let count = 0;
     for (const message of session.messages) {
@@ -1513,6 +1578,7 @@ class GeminiAgentSession {
         this.pendingPermissions = new Map();
         this.toolStates = new Map();
         this.activeTurnQueue = null;
+        this.activeTurnState = null;
         this.historyEvents = [];
         this.historyReadyPromise = null;
         this.resolveHistoryReady = null;
@@ -1544,6 +1610,44 @@ class GeminiAgentSession {
         await this.openConnection();
         this.initialized = true;
     }
+    beginActiveTurn(queue, startedAt) {
+        const turnState = {
+            startedAt,
+            queue,
+            terminalState: "open",
+            deferTextStreaming: shouldDeferGeminiTextStreaming(this.currentModelId),
+            liveAssistantText: "",
+            liveReasoningText: "",
+            deferredOutputItems: [],
+        };
+        this.activeTurnState = turnState;
+        return turnState;
+    }
+    finalizeActiveTurn(turnState, terminalState) {
+        if (turnState.terminalState !== "open") {
+            return false;
+        }
+        turnState.terminalState = terminalState;
+        return true;
+    }
+    trackLiveTurnOutput(turnState, item) {
+        if (!turnState || turnState.terminalState !== "open") {
+            return;
+        }
+        if (item.type === "assistant_message") {
+            turnState.liveAssistantText = appendGeminiStreamText(turnState.liveAssistantText, item.text);
+            if (turnState.deferTextStreaming) {
+                turnState.deferredOutputItems.push(item);
+            }
+            return;
+        }
+        if (item.type === "reasoning") {
+            turnState.liveReasoningText = appendGeminiStreamText(turnState.liveReasoningText, item.text);
+            if (turnState.deferTextStreaming) {
+                turnState.deferredOutputItems.push(item);
+            }
+        }
+    }
     async run(prompt, options) {
         const timeline = [];
         let finalText = "";
@@ -1553,7 +1657,7 @@ class GeminiAgentSession {
             if (event.type === "timeline") {
                 timeline.push(event.item);
                 if (event.item.type === "assistant_message") {
-                    finalText += event.item.text;
+                    finalText = appendGeminiStreamText(finalText, event.item.text);
                 }
             }
             else if (event.type === "turn_completed") {
@@ -1585,48 +1689,60 @@ class GeminiAgentSession {
         const queue = new AsyncEventQueue();
         this.activeTurnQueue = queue;
         this.currentRunInterrupted = false;
+        const connection = this.connection;
         const turnStartedAt = new Date();
+        const turnState = this.beginActiveTurn(queue, turnStartedAt);
         queue.push({
             type: "turn_started",
             provider: GEMINI_PROVIDER,
         });
-        void this.connection
-            .prompt({
-            sessionId: this.sessionId,
-            prompt: toGeminiPromptBlocks(prompt),
-        })
-            .then(async (response) => {
-            if (response.stopReason === "cancelled") {
-                queue.push({
-                    type: "turn_canceled",
-                    provider: GEMINI_PROVIDER,
-                    reason: "Interrupted",
+        void (async () => {
+            try {
+                const response = await connection.prompt({
+                    sessionId: this.sessionId,
+                    prompt: toGeminiPromptBlocks(prompt),
                 });
+                if (response.stopReason === "cancelled") {
+                    if (!this.finalizeActiveTurn(turnState, "canceled")) {
+                        return;
+                    }
+                    queue.push({
+                        type: "turn_canceled",
+                        provider: GEMINI_PROVIDER,
+                        reason: "Interrupted",
+                    });
+                }
+                else {
+                    if (!this.finalizeActiveTurn(turnState, "completed")) {
+                        return;
+                    }
+                    const recordedTurnCompletion = await this.readRecordedTurnCompletion(turnStartedAt);
+                    await this.emitRecordedTurnOutput(turnState, recordedTurnCompletion);
+                    queue.push({
+                        type: "turn_completed",
+                        provider: GEMINI_PROVIDER,
+                        ...(recordedTurnCompletion?.summary
+                            ? {
+                                usage: recordedTurnCompletion.summary.usage,
+                                modelId: recordedTurnCompletion.summary.modelId,
+                            }
+                            : {}),
+                    });
+                }
+                queue.close();
             }
-            else {
-                // ACP does not report usage, so we synthesize it from Gemini's recorded session file.
-                const recordedTurnSummary = await this.readRecordedTurnSummary(turnStartedAt);
+            catch (error) {
+                if (!this.finalizeActiveTurn(turnState, "failed")) {
+                    return;
+                }
                 queue.push({
-                    type: "turn_completed",
+                    type: "turn_failed",
                     provider: GEMINI_PROVIDER,
-                    ...(recordedTurnSummary
-                        ? {
-                            usage: recordedTurnSummary.usage,
-                            modelId: recordedTurnSummary.modelId,
-                        }
-                        : {}),
+                    error: formatGeminiAcpError(error),
                 });
+                queue.close();
             }
-            queue.close();
-        })
-            .catch((error) => {
-            queue.push({
-                type: "turn_failed",
-                provider: GEMINI_PROVIDER,
-                error: formatGeminiAcpError(error),
-            });
-            queue.close();
-        });
+        })();
         try {
             while (true) {
                 const nextEvent = await queue.shift();
@@ -1640,6 +1756,9 @@ class GeminiAgentSession {
             if (this.activeTurnQueue === queue) {
                 this.activeTurnQueue = null;
             }
+            if (this.activeTurnState === turnState) {
+                this.activeTurnState = null;
+            }
             this.currentRunInterrupted = false;
         }
     }
@@ -1802,6 +1921,7 @@ class GeminiAgentSession {
         }
         this.activeTurnQueue?.close();
         this.activeTurnQueue = null;
+        this.activeTurnState = null;
         if (this.child?.stdin) {
             this.child.stdin.end();
         }
@@ -1830,6 +1950,7 @@ class GeminiAgentSession {
         if (this.closePromise === params.closePromise) {
             this.closePromise = Promise.resolve();
         }
+        this.activeTurnState = null;
     }
     async setModel(modelId) {
         await this.initialize();
@@ -1933,13 +2054,26 @@ class GeminiAgentSession {
                     this.connection = null;
                 }
                 if (!this.closed) {
-                    if (this.activeTurnQueue) {
-                        this.activeTurnQueue.push({
-                            type: "turn_failed",
-                            provider: GEMINI_PROVIDER,
-                            error: message,
-                        });
-                        this.activeTurnQueue.close();
+                    const activeTurnState = this.activeTurnState;
+                    if (activeTurnState && this.activeTurnQueue) {
+                        const terminalState = this.currentRunInterrupted ? "canceled" : "failed";
+                        if (this.finalizeActiveTurn(activeTurnState, terminalState)) {
+                            if (terminalState === "canceled") {
+                                this.activeTurnQueue.push({
+                                    type: "turn_canceled",
+                                    provider: GEMINI_PROVIDER,
+                                    reason: "Interrupted",
+                                });
+                            }
+                            else {
+                                this.activeTurnQueue.push({
+                                    type: "turn_failed",
+                                    provider: GEMINI_PROVIDER,
+                                    error: message,
+                                });
+                            }
+                            this.activeTurnQueue.close();
+                        }
                     }
                     this.logger.warn({ code, signal, stderr }, "Gemini ACP process closed");
                 }
@@ -2138,6 +2272,45 @@ class GeminiAgentSession {
             this.currentModeId = notification.update.currentModeId;
             return;
         }
+        const activeTurnState = this.activeTurnState;
+        if (notification.update.sessionUpdate === "agent_message_chunk") {
+            if (notification.update.content.type !== "text") {
+                return;
+            }
+            const text = notification.update.content.text;
+            if (text.length === 0) {
+                return;
+            }
+            if (activeTurnState && activeTurnState.terminalState !== "open") {
+                return;
+            }
+            this.trackLiveTurnOutput(activeTurnState, {
+                type: "assistant_message",
+                text,
+            });
+            if (activeTurnState?.deferTextStreaming) {
+                return;
+            }
+        }
+        if (notification.update.sessionUpdate === "agent_thought_chunk") {
+            if (notification.update.content.type !== "text") {
+                return;
+            }
+            const text = notification.update.content.text;
+            if (text.length === 0) {
+                return;
+            }
+            if (activeTurnState && activeTurnState.terminalState !== "open") {
+                return;
+            }
+            this.trackLiveTurnOutput(activeTurnState, {
+                type: "reasoning",
+                text,
+            });
+            if (activeTurnState?.deferTextStreaming) {
+                return;
+            }
+        }
         const includeUserMessages = this.historyCaptureActive;
         const events = sessionUpdateToEvents(notification.update, this.toolStates, {
             includeUserMessages,
@@ -2158,13 +2331,48 @@ class GeminiAgentSession {
             return;
         }
         for (const event of events) {
+            if (activeTurnState?.terminalState !== "open" &&
+                event.type === "timeline" &&
+                (event.item.type === "assistant_message" || event.item.type === "reasoning")) {
+                continue;
+            }
             this.emitLiveEvent(event);
         }
     }
     emitLiveEvent(event) {
         this.activeTurnQueue?.push(event);
     }
-    async readRecordedTurnSummary(turnStartedAt) {
+    async emitRecordedTurnOutput(turnState, completion) {
+        const recordedOutputItems = completion
+            ? buildGeminiRecordedTurnOutputItems(completion.messages)
+            : [];
+        const preferRecordedOutput = shouldPreferRecordedGeminiTurnOutput(completion?.summary?.modelId) ||
+            turnState.deferTextStreaming;
+        const outputItems = recordedOutputItems.length > 0
+            ? recordedOutputItems.filter((item) => {
+                if (preferRecordedOutput) {
+                    return true;
+                }
+                if (item.type === "assistant_message") {
+                    return turnState.liveAssistantText.length === 0;
+                }
+                if (item.type === "reasoning") {
+                    return turnState.liveReasoningText.length === 0;
+                }
+                return false;
+            })
+            : turnState.deferTextStreaming
+                ? turnState.deferredOutputItems
+                : [];
+        for (const item of outputItems) {
+            turnState.queue.push({
+                type: "timeline",
+                provider: GEMINI_PROVIDER,
+                item,
+            });
+        }
+    }
+    async readRecordedTurnCompletion(turnStartedAt) {
         if (!this.sessionId) {
             return null;
         }
@@ -2177,10 +2385,10 @@ class GeminiAgentSession {
             (this.hasObservedRecordedSession && !this.recordedSessionFilePath
                 ? GEMINI_RECORDED_SESSION_DISCOVERY_TIMEOUT_MS
                 : GEMINI_HISTORY_FALLBACK_IDLE_MS);
-        let latestFingerprint = null;
+        let latestSummaryFingerprint = null;
         let observedSummary = false;
-        let latestEmptyTurnFingerprint = null;
-        let observedEmptyTurn = false;
+        let latestTurnFingerprint = null;
+        let observedTurn = false;
         let sawRecordedSession = false;
         while (Date.now() <= deadline) {
             let recordedSession = null;
@@ -2202,24 +2410,32 @@ class GeminiAgentSession {
                 this.hasObservedRecordedSession = true;
                 const turnMessages = getGeminiRecordedTurnMessages(recordedSession, turnStartedAt);
                 const nextSummary = summarizeGeminiRecordedMessages(turnMessages);
+                const turnFingerprint = JSON.stringify(turnMessages);
                 if (nextSummary) {
-                    const nextFingerprint = JSON.stringify(nextSummary);
-                    if (observedSummary && nextFingerprint === latestFingerprint) {
-                        return nextSummary;
+                    const nextSummaryFingerprint = JSON.stringify(nextSummary);
+                    if (observedSummary &&
+                        nextSummaryFingerprint === latestSummaryFingerprint &&
+                        observedTurn &&
+                        turnFingerprint === latestTurnFingerprint) {
+                        return {
+                            summary: nextSummary,
+                            messages: turnMessages,
+                        };
                     }
-                    latestFingerprint = nextFingerprint;
+                    latestSummaryFingerprint = nextSummaryFingerprint;
                     observedSummary = true;
-                    observedEmptyTurn = false;
-                    latestEmptyTurnFingerprint = null;
+                    latestTurnFingerprint = turnFingerprint;
+                    observedTurn = true;
                 }
                 else if (hasGeminiRecordedAssistantMessage(turnMessages)) {
-                    const nextEmptyTurnFingerprint = JSON.stringify(turnMessages);
-                    if (observedEmptyTurn &&
-                        nextEmptyTurnFingerprint === latestEmptyTurnFingerprint) {
-                        return null;
+                    if (observedTurn && turnFingerprint === latestTurnFingerprint) {
+                        return {
+                            summary: null,
+                            messages: turnMessages,
+                        };
                     }
-                    observedEmptyTurn = true;
-                    latestEmptyTurnFingerprint = nextEmptyTurnFingerprint;
+                    observedTurn = true;
+                    latestTurnFingerprint = turnFingerprint;
                 }
             }
             else if (!sawRecordedSession && Date.now() >= discoveryDeadline) {