@kenkaiiii/ggcoder 4.3.237 → 4.3.238

package/dist/ui/App.js

@@ -12,7 +12,7 @@ import { useDoublePress } from "./hooks/useDoublePress.js";
 import { useTaskBarStore, useTaskBarPolling, focusTaskBar, exitTaskBar, expandTaskBar, collapseTaskBar, navigateTaskBar, killTask, } from "./stores/taskbar-store.js";
 import { playNotificationSound } from "../utils/sound.js";
 import {} from "@kenkaiiii/gg-ai";
-import { downscaleForPreview, extractImagePaths } from "../utils/image.js";
+import { downscaleForPreview, extractMediaPaths } from "../utils/image.js";
 import { useAgentLoop } from "./hooks/useAgentLoop.js";
 import { useTranscriptHistory } from "./hooks/useTranscriptHistory.js";
 import { createWebSearchTool } from "../tools/web-search.js";
@@ -36,9 +36,9 @@ import { detectLanguages } from "../core/language-detector.js";
 import { detectVerifyCommands } from "../core/verify-commands.js";
 import { RewindOverlay } from "./components/RewindOverlay.js";
 import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
-import { getMCPServers } from "../core/mcp/index.js";
+import { getAllMcpServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
-import { splitAssistantStreamingText } from "./utils/assistant-stream-split.js";
+import { splitAssistantStreamingText, estimateRenderedRows, } from "./utils/assistant-stream-split.js";
 import { getNextPendingTask, markTaskInProgress } from "../core/tasks-store.js";
 import { buildUserContentWithAttachments } from "./prompt-routing.js";
 import { submitPromptCommand } from "./submit-prompt-command.js";
@@ -563,6 +563,8 @@ export function App(props) {
         tools: currentTools,
         webSearch: props.webSearch,
         maxTokens: props.maxTokens,
+        supportsImages: getModel(currentModel)?.supportsImages ?? true,
+        supportsVideo: getModel(currentModel)?.supportsVideo ?? false,
         thinking: thinkingLevel,
         apiKey: activeApiKey,
         baseUrl: activeBaseUrl,
@@ -1020,6 +1022,18 @@ export function App(props) {
             log("INFO", "server_tool", `Server tool call: ${name}`, { id });
             const startedAt = Date.now();
             const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
+            // Feed the pinned LiveToolPanel so provider-side tools (Anthropic's
+            // native web_search) appear in the same rolling window as client
+            // tools. `input` carries the tool args (e.g. { query }) the row reads.
+            setLiveToolFeed((prev) => [
+                ...prev,
+                {
+                    id,
+                    name,
+                    args: (input ?? {}),
+                    status: "running",
+                },
+            ].slice(-(LIVE_TOOL_PANEL_ROWS * 2)));
             // Flush completed items (including assistant text) before adding server
             // tool UI — same rationale as onToolStart.
             setLiveItems((prev) => {
@@ -1050,6 +1064,9 @@ export function App(props) {
         }, [queueFlush]),
         onServerToolResult: useCallback((toolUseId, resultType, data) => {
             log("INFO", "server_tool", `Server tool result`, { toolUseId, resultType });
+            // Mark the panel entry done. Aborts never reach here (handled in
+            // onAborted), so a result that arrives is always a normal completion.
+            setLiveToolFeed((prev) => prev.map((entry) => entry.id === toolUseId ? { ...entry, status: "done" } : entry));
             setLiveItems((prev) => {
                 let updated;
                 const startIdx = prev.findIndex((item) => item.kind === "server_tool_start" && item.serverToolCallId === toolUseId);
@@ -1255,10 +1272,14 @@ export function App(props) {
             const imageCount = typeof content === "string"
                 ? undefined
                 : content.filter((c) => c.type === "image").length || undefined;
+            const videoCount = typeof content === "string"
+                ? undefined
+                : content.filter((c) => c.type === "video").length || undefined;
             const userItem = {
                 kind: "user",
                 text: displayText,
                 imageCount,
+                videoCount,
                 id: getId(),
             };
             setLastUserMessage(displayText);
@@ -1295,6 +1316,13 @@ export function App(props) {
                 },
             ];
         }, []),
+        onRetry: useCallback(() => {
+            // Roll back any pending progressive flushes from the aborted attempt.
+            // Without this, a stall retry regenerates the preamble and the old
+            // flushed paragraph + the new one both end up in terminal history.
+            pendingHistoryFlushRef.current = pendingHistoryFlushRef.current.filter((item) => item.kind !== "assistant");
+            streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
+        }, []),
     });
     // First-time-per-project auto-run of /setup. Bound after `agentLoop` is in
     // scope so the ref closure can dispatch to it. Called from the initial
@@ -1410,6 +1438,9 @@ export function App(props) {
         void agentLoop.run(action.prompt).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
         // Intentional one-shot: run once on mount, never re-fire on re-render.
@@ -1564,31 +1595,35 @@ export function App(props) {
         }
         // ── Build user content (shared by normal + queued paths) ──
         const hasImages = inputImages.length > 0;
+        const imageCount = inputImages.filter((img) => img.kind === "image").length;
+        const videoCount = inputImages.filter((img) => img.kind === "video").length;
         const modelInfo = getModel(currentModel);
         const modelSupportsImages = modelInfo?.supportsImages ?? true;
-        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages);
+        const modelSupportsVideo = modelInfo?.supportsVideo ?? false;
+        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages, modelSupportsVideo);
         // ── Queue message if agent is already running ──
         if (agentLoop.isRunning) {
             log("INFO", "queue", `Queued message: ${trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed}`);
             agentLoop.queueMessage(userContent, input);
             let displayText = input;
             if (hasImages) {
-                const { cleanText } = await extractImagePaths(input, props.cwd);
+                const { cleanText } = await extractMediaPaths(input, props.cwd);
                 displayText = cleanText;
             }
             const queuedItem = {
                 kind: "queued",
                 text: displayText,
-                imageCount: hasImages ? inputImages.length : undefined,
+                imageCount: imageCount > 0 ? imageCount : undefined,
+                videoCount: videoCount > 0 ? videoCount : undefined,
                 id: getId(),
             };
             setLiveItems((prev) => [...prev, queuedItem]);
             return;
         }
-        // Build display text — strip image paths, show badges instead
+        // Build display text — strip image/video paths, show badges instead
         let displayText = input;
         if (hasImages) {
-            const { cleanText } = await extractImagePaths(input, props.cwd);
+            const { cleanText } = await extractMediaPaths(input, props.cwd);
             displayText = cleanText;
         }
         let imagePreviews;
@@ -1604,7 +1639,8 @@ export function App(props) {
         const userItem = {
             kind: "user",
             text: displayText,
-            imageCount: hasImages ? inputImages.length : undefined,
+            imageCount: imageCount > 0 ? imageCount : undefined,
+            videoCount: videoCount > 0 ? videoCount : undefined,
             imagePreviews,
             pasteInfo,
             id: getId(),
@@ -1638,6 +1674,12 @@ export function App(props) {
             const msg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", msg);
             const isAbort = msg.includes("aborted") || msg.includes("abort");
+            // If the agent loop threw but left isRunning in a stale true state
+            // (can happen when the finally block hasn't been processed by React
+            // yet), reset it so the user isn't deadlocked with a non-working UI.
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [
                 ...prev,
                 isAbort
@@ -1728,8 +1770,14 @@ export function App(props) {
                     rebuildPromptWithTools(next);
                     return next;
                 });
-                // Reconnect MCP servers
-                if (props.mcpManager) {
+                // Reconnect MCP servers ONLY when the resolved server set actually
+                // changes. GLM is the only provider with a different set (Z.AI
+                // servers), so a switch that doesn't involve GLM on either side
+                // keeps the identical set — tearing down a live stdio child (e.g.
+                // kencode-search) and re-spawning `npx` there only risks a failed
+                // re-spawn that would silently drop the tools.
+                const glmInvolved = newProvider === "glm" || prevProvider === "glm";
+                if (props.mcpManager && glmInvolved) {
                     void (async () => {
                         // Disconnect old MCP servers
                         await props.mcpManager.dispose();
@@ -1748,7 +1796,11 @@ export function App(props) {
                             apiKey = props.credentialsByProvider?.["glm"]?.accessToken;
                         }
                         try {
-                            const mcpTools = await props.mcpManager.connectAll(getMCPServers(newProvider, apiKey));
+                            // Use getAllMcpServers so user-configured servers (from
+                            // ~/.gg/mcp.json and ./.gg/mcp.json) survive the reconnect —
+                            // getMCPServers returns provider defaults only.
+                            const servers = await getAllMcpServers(newProvider, apiKey, props.cwd);
+                            const mcpTools = await props.mcpManager.connectAll(servers);
                             setCurrentTools((prev) => {
                                 const next = [...prev.filter((t) => !t.name.startsWith("mcp__")), ...mcpTools];
                                 rebuildPromptWithTools(next);
@@ -1999,6 +2051,9 @@ export function App(props) {
         setDoneStatus(null);
         setLiveItems([taskItem]);
         void agentLoop.run(fullPrompt).catch((err) => {
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     }, [agentLoop, currentModel, currentProvider, props]);
@@ -2047,7 +2102,23 @@ export function App(props) {
     // every chunk boundary. Slicing by the prospective flush here keeps the live
     // frame height monotonic, so the footer never bounces.
     const alreadyFlushedChars = streamedAssistantFlushRef.current.flushedChars;
-    const pendingFlushChars = rawVisibleStreamingText
+    // Retry-safety gate: don't commit streamed paragraphs to permanent scrollback
+    // while the text is still small enough to live entirely in the live region.
+    // A silent stall-retry (agent-loop.ts) restarts the LLM call from scratch and
+    // regenerates the opening text — reworded, so the byte-identical dedup can't
+    // catch it. Anything already printed to scrollback can't be un-written, so the
+    // regen appends as a second ⏺ bullet that paraphrases the first. Keeping short
+    // streamed text live (it clears via setStreamingText("") on retry) closes that
+    // hole. We only start flushing once the unflushed text would overflow the live
+    // area — the original anti-jump purpose, which only matters for long responses
+    // that are far less likely to be a stalled preamble. Once flushing has begun
+    // for this turn (alreadyFlushedChars > 0) we keep flushing every boundary so
+    // committed continuation paragraphs stay consistent with the live tail.
+    const unflushedStreamingRows = rawVisibleStreamingText
+        ? estimateRenderedRows(rawVisibleStreamingText.slice(alreadyFlushedChars), columns)
+        : 0;
+    const shouldFlushStreamedText = alreadyFlushedChars > 0 || unflushedStreamingRows > measuredLiveAreaRows;
+    const pendingFlushChars = rawVisibleStreamingText && shouldFlushStreamedText
         ? splitAssistantStreamingText(rawVisibleStreamingText.slice(alreadyFlushedChars)).flushedText
             .length
         : 0;
@@ -2058,6 +2129,13 @@ export function App(props) {
         }
         if (rawVisibleStreamingText === streamedAssistantFlushRef.current.text)
             return;
+        if (!shouldFlushStreamedText) {
+            streamedAssistantFlushRef.current = {
+                ...streamedAssistantFlushRef.current,
+                text: rawVisibleStreamingText,
+            };
+            return;
+        }
         const alreadyFlushed = streamedAssistantFlushRef.current.flushedChars;
         const unflushedText = rawVisibleStreamingText.slice(alreadyFlushed);
         const split = splitAssistantStreamingText(unflushedText);
@@ -2080,7 +2158,7 @@ export function App(props) {
             ...streamedAssistantFlushRef.current,
             text: rawVisibleStreamingText,
         };
-    }, [rawVisibleStreamingText, queueFlush]);
+    }, [rawVisibleStreamingText, shouldFlushStreamedText, queueFlush]);
     const visibleStreamingText = stripDoneMarkers(rawVisibleStreamingText.slice(alreadyFlushedChars + pendingFlushChars));
     const lastLiveItem = liveItems.at(-1);
     // For spacing decisions, the previous row is the last item that actually
@@ -2384,6 +2462,9 @@ export function App(props) {
         void agentLoop.run(rejectionMsg).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     };