@townco/ui 0.1.105 → 0.1.107

package/dist/core/hooks/use-chat-messages.d.ts

@@ -160,6 +160,7 @@ export declare function useChatMessages(client: AcpClient | null, startSession:
                 isStreaming?: boolean | undefined;
             }[] | undefined;
             subagentStreaming?: boolean | undefined;
+            subagentCompleted?: boolean | undefined;
         }[] | undefined;
         hookNotifications?: {
             id: string;

package/dist/core/hooks/use-chat-session.js

@@ -76,12 +76,28 @@ export function useChatSession(client, initialSessionId) {
                     // Check if we should append to the last assistant message or create a new one
                     const messages = useChatStore.getState().messages;
                     const lastMessage = messages[messages.length - 1];
+                    // Check if this is a replay chunk (not live streaming)
+                    const isReplayChunk = updateMeta?.isReplay === true;
                     if (update.message.role === "assistant" &&
+                        lastMessage?.role === "assistant" &&
+                        textContent &&
+                        isReplayChunk) {
+                        // During replay, always append to the last assistant message
+                        // This allows multi-part messages (text, tools, text) to accumulate correctly
+                        logger.debug("Appending replay text to existing assistant message", {
+                            existingLength: lastMessage.content.length,
+                            appendingLength: textContent.length,
+                        });
+                        useChatStore.getState().updateMessage(lastMessage.id, {
+                            content: lastMessage.content + textContent,
+                        });
+                    }
+                    else if (update.message.role === "assistant" &&
                         lastMessage?.role === "assistant" &&
                         lastMessage.content === "" &&
                         textContent) {
-                        // Append text to existing empty assistant message (created by tool call)
-                        logger.debug("Appending text to existing assistant message");
+                        // Non-replay: append text to existing empty assistant message (created by tool call)
+                        logger.debug("Appending text to existing empty assistant message");
                         useChatStore.getState().updateMessage(lastMessage.id, {
                             content: lastMessage.content + textContent,
                         });

package/dist/core/hooks/use-tool-calls.d.ts

@@ -157,6 +157,7 @@ export declare function useToolCalls(client: AcpClient | null): {
             isStreaming?: boolean | undefined;
         }[] | undefined;
         subagentStreaming?: boolean | undefined;
+        subagentCompleted?: boolean | undefined;
     }[]>;
     getToolCallsForSession: (sessionId: string) => {
         id: string;
@@ -307,5 +308,6 @@ export declare function useToolCalls(client: AcpClient | null): {
             isStreaming?: boolean | undefined;
         }[] | undefined;
         subagentStreaming?: boolean | undefined;
+        subagentCompleted?: boolean | undefined;
     }[];
 };

package/dist/core/hooks/use-tool-calls.js

@@ -28,22 +28,10 @@ export function useToolCalls(client) {
                 addToolCallToCurrentMessage(update.toolCall);
             }
             else if (update.type === "tool_call_update") {
-                // Tool call update notification
-                _logger.info("[SUBAGENT] Frontend received tool_call_update", {
-                    sessionId: update.sessionId,
-                    toolCallId: update.toolCallUpdate.id,
-                    status: update.toolCallUpdate.status,
-                    hasSubagentMessages: !!update.toolCallUpdate.subagentMessages,
-                    subagentMessageCount: update.toolCallUpdate.subagentMessages?.length || 0,
-                });
                 // Update session-level tool calls (for sidebar)
                 updateToolCall(update.sessionId, update.toolCallUpdate);
                 // Also update in current assistant message (for inline display)
                 updateToolCallInCurrentMessage(update.toolCallUpdate);
-                _logger.info("[SUBAGENT] Successfully updated tool call state", {
-                    sessionId: update.sessionId,
-                    toolCallId: update.toolCallUpdate.id,
-                });
             }
         });
         return () => {

package/dist/core/schemas/chat.d.ts

@@ -239,6 +239,7 @@ export declare const DisplayMessage: z.ZodObject<{
             isStreaming: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
         subagentStreaming: z.ZodOptional<z.ZodBoolean>;
+        subagentCompleted: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     hookNotifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -503,6 +504,7 @@ export declare const ChatSessionState: z.ZodObject<{
                 isStreaming: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             subagentStreaming: z.ZodOptional<z.ZodBoolean>;
+            subagentCompleted: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
         hookNotifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;

package/dist/core/schemas/tool-call.d.ts

@@ -445,6 +445,7 @@ export declare const ToolCallSchema: z.ZodObject<{
         isStreaming: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     subagentStreaming: z.ZodOptional<z.ZodBoolean>;
+    subagentCompleted: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ToolCall = z.infer<typeof ToolCallSchema>;
 /**
@@ -596,6 +597,7 @@ export declare const ToolCallUpdateSchema: z.ZodObject<{
         }, z.core.$strip>], "type">>>;
         isStreaming: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
+    subagentCompleted: z.ZodOptional<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodObject<{
         truncationWarning: z.ZodOptional<z.ZodString>;
         compactionAction: z.ZodOptional<z.ZodEnum<{

package/dist/core/schemas/tool-call.js

@@ -183,6 +183,8 @@ export const ToolCallSchema = z.object({
     subagentMessages: z.array(SubagentMessageSchema).optional(),
     /** Whether the sub-agent is currently streaming */
     subagentStreaming: z.boolean().optional(),
+    /** Whether the sub-agent has completed */
+    subagentCompleted: z.boolean().optional(),
 });
 /**
  * Partial update for an existing tool call
@@ -207,6 +209,8 @@ export const ToolCallUpdateSchema = z.object({
     subagentSessionId: z.string().optional(),
     /** Sub-agent messages for replay */
     subagentMessages: z.array(SubagentMessageSchema).optional(),
+    /** Whether the sub-agent has completed */
+    subagentCompleted: z.boolean().optional(),
     /** Internal metadata (e.g., compaction info) */
     _meta: z
         .object({
@@ -245,6 +249,8 @@ export function mergeToolCallUpdate(existing, update) {
         subagentSessionId: update.subagentSessionId ?? existing.subagentSessionId,
         // Sub-agent messages for replay
         subagentMessages: update.subagentMessages ?? existing.subagentMessages,
+        // Sub-agent completion status (once true, stays true)
+        subagentCompleted: update.subagentCompleted ?? existing.subagentCompleted,
         // Internal metadata (compaction info)
         _meta: update._meta ?? existing._meta,
     };

package/dist/core/store/chat-store.js

@@ -265,10 +265,12 @@ export const useChatStore = create((set) => ({
         if (!lastAssistantMsg)
             return state;
         // Track the content position where this tool call was invoked
-        const contentPosition = lastAssistantMsg.content.length;
+        // Set contentPosition to where the tool call was invoked in the content stream
+        // This ensures tool calls appear inline at the correct position, even during streaming
+        const currentContentLength = lastAssistantMsg.content.length;
         const toolCallWithPosition = {
             ...toolCall,
-            contentPosition,
+            contentPosition: currentContentLength,
         };
         messages[lastAssistantIndex] = {
             ...lastAssistantMsg,
@@ -300,7 +302,8 @@ export const useChatStore = create((set) => ({
         if (!existing)
             return state;
         const updatedToolCalls = [...toolCalls];
-        updatedToolCalls[existingIndex] = mergeToolCallUpdate(existing, update);
+        const merged = mergeToolCallUpdate(existing, update);
+        updatedToolCalls[existingIndex] = merged;
         messages[lastAssistantIndex] = {
             ...lastAssistantMsg,
             toolCalls: updatedToolCalls,

package/dist/core/utils/tool-call-state.js

@@ -14,7 +14,14 @@ export function getToolCallDisplayState(toolCall) {
     if (toolCall.status === "failed" || toolCall.error) {
         return "failed";
     }
-    // Completed state
+    // Check if this is a subagent call
+    const hasSubagent = !!(toolCall.subagentMessages && toolCall.subagentMessages.length > 0);
+    // For subagent calls: completed when subagentCompleted is true (regardless of status)
+    // This handles the case where status is "in_progress" but subagent has finished
+    if (hasSubagent && toolCall.subagentCompleted) {
+        return "completed";
+    }
+    // Completed state (for non-subagent calls)
     if (toolCall.status === "completed") {
         return "completed";
     }

package/dist/gui/components/MessageContent.js

@@ -2,7 +2,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { cva } from "class-variance-authority";
 import * as React from "react";
 import { useChatStore } from "../../core/store/chat-store.js";
-import { isPreliminaryToolCall } from "../../core/utils/tool-call-state.js";
+import { getToolCallDisplayState, isPreliminaryToolCall, } from "../../core/utils/tool-call-state.js";
 import { cn } from "../lib/utils.js";
 import { HookNotification } from "./HookNotification.js";
 import { Reasoning } from "./Reasoning.js";
@@ -140,6 +140,19 @@ export const MessageContent = React.forwardRef(({ role: roleProp, variant, isStr
                     };
                     // Get tool_response hook notifications to associate with tool calls
                     const toolResponseHooks = (message.hookNotifications || []).filter((n) => n.hookType === "tool_response");
+                    // Helper to check if all non-preliminary tool calls are completed
+                    const areAllToolCallsCompleted = () => {
+                        const nonPreliminary = sortedToolCalls.filter((tc) => !isPreliminaryToolCall(tc));
+                        if (nonPreliminary.length === 0)
+                            return false;
+                        return nonPreliminary.every((tc) => getToolCallDisplayState(tc) === "completed");
+                    };
+                    // Check if we should show the thinking indicator
+                    // Show when: all tool calls are complete, message is streaming, and there's minimal content after tool calls
+                    const shouldShowThinkingIndicator = message.isStreaming &&
+                        sortedToolCalls.length > 0 &&
+                        areAllToolCallsCompleted() &&
+                        message.content.trim().length < 50; // Only show if there's very little text content
                     // Helper to render a tool call or group
                     const renderToolCallOrGroup = (item, index) => {
                         // Batch group (parallel operations)
@@ -175,9 +188,8 @@ export const MessageContent = React.forwardRef(({ role: roleProp, variant, isStr
                         // Check if hook notifications have positions for inline rendering
                         const hasHookPositions = hookNotifications.some((n) => n.contentPosition !== undefined);
                         if (!hasHookPositions) {
-                            // No positions - render hooks at top, then tool calls, then content
-                            return (_jsxs(_Fragment, { children: [hookNotifications.length > 0 && (_jsx("div", { className: "flex flex-col gap-2 mb-1", children: hookNotifications.map((notification) => (_jsx(HookNotification, { notification: notification }, notification.id))) })), groupedToolCalls.length > 0 && (_jsx("div", { className: "flex flex-col gap-2 mb-1", children: groupedToolCalls.map((item, index) => renderToolCallOrGroup(item, index)) })), _jsx("div", { children: _jsx(Response, { content: message.content, isStreaming: message.isStreaming, showEmpty: false, sources: message.sources ?? [] }) })
-                                ] }));
+                            // No positions - render hooks at top, then content, then tool calls
+                            return (_jsxs(_Fragment, { children: [hookNotifications.length > 0 && (_jsx("div", { className: "flex flex-col gap-2 mb-1", children: hookNotifications.map((notification) => (_jsx(HookNotification, { notification: notification }, notification.id))) })), _jsx("div", { children: _jsx(Response, { content: message.content, isStreaming: message.isStreaming, showEmpty: false, sources: message.sources ?? [] }) }), groupedToolCalls.length > 0 && (_jsx("div", { className: "flex flex-col gap-2 mb-1", children: groupedToolCalls.map((item, index) => renderToolCallOrGroup(item, index)) })), shouldShowThinkingIndicator && (_jsx("div", { className: "flex flex-col my-4 rounded-md px-1 -mx-1 w-fit", children: _jsx("div", { className: "flex items-center gap-1.5", children: _jsx("span", { className: "text-paragraph-sm text-text-secondary/70", children: "Thinking..." }) }) }))] }));
                         }
                         // Hooks have positions - render them inline with content
                         const elements = [];
@@ -336,6 +348,10 @@ export const MessageContent = React.forwardRef(({ role: roleProp, variant, isStr
                                     toolCalls: [preliminaryToolCalls[0]], isGrouped: false }) }, `tool-${preliminaryToolCalls[0]?.id}`));
                         }
                     }
+                    // Add thinking indicator if all tool calls are complete but message is still streaming
+                    if (shouldShowThinkingIndicator) {
+                        elements.push(_jsx("div", { className: "flex flex-col my-4 rounded-md px-1 -mx-1 w-fit", children: _jsx("div", { className: "flex items-center gap-1.5", children: _jsx("span", { className: "text-paragraph-sm text-text-secondary/70", children: "Thinking..." }) }) }, "thinking-indicator"));
+                    }
                     return _jsx(_Fragment, { children: elements });
                 })()) : (_jsxs("div", { className: "flex flex-col gap-2", children: [message.images && message.images.length > 0 && (_jsx("div", { className: "flex flex-wrap gap-2", children: message.images.map((image, imageIndex) => (_jsx("img", { src: `data:${image.mimeType};base64,${image.data}`, alt: `Attachment ${imageIndex + 1}`, className: "max-w-[200px] max-h-[200px] rounded-lg object-cover" }, `image-${image.mimeType}-${image.data.slice(0, 20)}`))) })), message.content && (_jsx("div", { className: "whitespace-pre-wrap", children: message.content }))] }))] }));
     }

package/dist/gui/components/SubAgentDetails.js

@@ -23,18 +23,6 @@ export function SubAgentDetails({ parentStatus, agentName, query, isExpanded: co
     const thinkingContainerRef = useRef(null);
     // Use messages from storedMessages prop (populated by parent via tool_call_update)
     const messages = storedMessages || [];
-    // Log when messages are received/updated
-    useEffect(() => {
-        console.log("[SUBAGENT] SubAgentDetails received messages update", {
-            agentName,
-            messageCount: messages.length,
-            parentStatus,
-            hasMessages: messages.length > 0,
-            contentPreview: messages[0]?.content?.substring(0, 100),
-            toolCallCount: messages[0]?.toolCalls?.length || 0,
-            contentBlockCount: messages[0]?.contentBlocks?.length || 0,
-        });
-    }, [messages, agentName, parentStatus]);
     // Determine if subagent is still running based on parent status
     const isRunning = parentStatus === "in_progress" || parentStatus === "pending";
     // Get the current/latest message
@@ -44,13 +32,6 @@ export function SubAgentDetails({ parentStatus, agentName, query, isExpanded: co
             (currentMessage.toolCalls && currentMessage.toolCalls.length > 0) ||
             (currentMessage.contentBlocks &&
                 currentMessage.contentBlocks.length > 0));
-    console.log("[SUBAGENT] SubAgentDetails render state", {
-        agentName,
-        messageCount: messages.length,
-        hasContent,
-        isRunning,
-        parentStatus,
-    });
     // Auto-collapse Thinking when completed (so Output is the primary view)
     const prevIsRunningRef = useRef(isRunning);
     useEffect(() => {

package/dist/gui/components/ToolOperation.js

@@ -71,8 +71,8 @@ function formatElapsedTime(seconds) {
 /**
  * Component to display running duration for a tool call
  */
-function RunningDuration({ startTime }) {
-    const elapsed = useElapsedTime(startTime, true);
+function RunningDuration({ startTime, isRunning = true, }) {
+    const elapsed = useElapsedTime(startTime, isRunning);
     return (_jsx("span", { className: "text-xs text-text-secondary/70 tabular-nums ml-1", children: formatElapsedTime(elapsed) }));
 }
 /**
@@ -227,7 +227,7 @@ export function ToolOperation({ toolCalls, isGrouped = false, autoMinimize = tru
     // For preliminary/selecting states, show simple non-expandable text
     if (isSelecting && !isGrouped) {
         return (_jsx("div", { className: "flex flex-col my-4 rounded-md px-1 -mx-1 w-fit", children: _jsxs("div", { className: "flex items-center gap-1.5", children: [
-                    _jsx("div", { className: "text-text-secondary/70", children: _jsx(IconComponent, { className: "h-3 w-3" }) }), _jsxs("span", { className: "text-paragraph-xs text-text-muted", children: [displayText, singleToolCall?.startedAt && (_jsx(RunningDuration, { startTime: singleToolCall.startedAt }))] })
+                    _jsx("div", { className: "text-text-secondary/70", children: _jsx(IconComponent, { className: "h-3 w-3" }) }), _jsxs("span", { className: "text-paragraph-xs text-text-muted", children: [displayText, singleToolCall?.startedAt && (_jsx(RunningDuration, { startTime: singleToolCall.startedAt, isRunning: !singleToolCall.subagentCompleted }))] })
                 ] }) }));
     }
     // If it's a grouped preliminary (selecting) state
@@ -241,9 +241,11 @@ export function ToolOperation({ toolCalls, isGrouped = false, autoMinimize = tru
                 return null;
             return Math.min(...startTimes);
         })();
+        // Check if all tool calls in the group are completed
+        const allCompleted = toolCalls.every((tc) => tc.subagentCompleted);
         return (_jsxs("div", { className: "flex flex-col my-4 rounded-md px-1 -mx-1 w-fit", children: [
                 _jsxs("div", { className: "flex items-center gap-1.5", children: [
-                        _jsx("div", { className: "text-text-secondary/70", children: _jsx(ListVideo, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-text-secondary/70", children: "Selecting tools" }), selectingStartTime && (_jsx(RunningDuration, { startTime: selectingStartTime })), _jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-text-secondary/70", children: toolCalls.length })
+                        _jsx("div", { className: "text-text-secondary/70", children: _jsx(ListVideo, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-text-secondary/70", children: "Selecting tools" }), selectingStartTime && (_jsx(RunningDuration, { startTime: selectingStartTime, isRunning: !allCompleted })), _jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-text-secondary/70", children: toolCalls.length })
                     ] }), _jsx("span", { className: "text-paragraph-sm text-text-secondary/70 pl-4.5", children: displayText })
             ] }));
     }
@@ -253,7 +255,7 @@ export function ToolOperation({ toolCalls, isGrouped = false, autoMinimize = tru
                     _jsxs("div", { className: "flex items-center gap-1.5", children: [
                             _jsx("div", { className: "text-text-secondary/70 group-hover:text-text-secondary transition-colors", children: _jsx(IconComponent, { className: "h-3 w-3" }) }), _jsxs("span", { className: "text-paragraph-sm text-text-secondary/70 group-hover:text-text-secondary transition-colors", children: [isGrouped && _jsx("span", { className: "mr-1", children: "Parallel operation" }), !isGrouped && displayText] }), !isGrouped &&
                                 singleToolCall?.startedAt &&
-                                displayState === "executing" && (_jsx(RunningDuration, { startTime: singleToolCall.startedAt })), isGrouped &&
+                                displayState === "executing" && (_jsx(RunningDuration, { startTime: singleToolCall.startedAt, isRunning: !singleToolCall.subagentCompleted })), isGrouped &&
                                 displayState === "executing" &&
                                 (() => {
                                     const startTimes = toolCalls
@@ -262,7 +264,10 @@ export function ToolOperation({ toolCalls, isGrouped = false, autoMinimize = tru
                                     if (startTimes.length === 0)
                                         return null;
                                     const earliestStart = Math.min(...startTimes);
-                                    return _jsx(RunningDuration, { startTime: earliestStart });
+                                    // Check if all tool calls are completed
+                                    const allCompleted = toolCalls.every((tc) => tc.status === "completed" &&
+                                        (!tc.subagentMessages || tc.subagentCompleted));
+                                    return (_jsx(RunningDuration, { startTime: earliestStart, isRunning: !allCompleted }));
                                 })(), isGrouped && (_jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-text-secondary/70", children: toolCalls.length })), isFailed && (_jsx("span", { title: isGrouped
                                     ? `${toolCalls.filter((tc) => tc.status === "failed").length} of ${toolCalls.length} operations failed`
                                     : singleToolCall?.error || "Operation failed", children: _jsx(AlertCircle, { className: "h-3 w-3 text-destructive" }) })), isGrouped && groupHasCompaction && (_jsx(TooltipProvider, { delayDuration: 0, children: _jsxs(Tooltip, { children: [
@@ -338,7 +343,8 @@ function GroupedToolCallItem({ toolCall, hookNotification, }) {
         hookNotification?.metadata?.action === "compacted_then_truncated" ||
         toolCall._meta?.compactionAction === "truncated");
     const isFailed = toolCall.status === "failed";
-    const isRunning = toolCall.status === "pending" || toolCall.status === "in_progress";
+    const isRunning = (toolCall.status === "pending" || toolCall.status === "in_progress") &&
+        !toolCall.subagentCompleted;
     if (isSubagentCall) {
         // Render subagent with clickable header and SubAgentDetails component
         return (_jsxs("div", { className: "flex flex-col ml-5", children: [

package/dist/sdk/schemas/session.d.ts

@@ -350,6 +350,7 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
             isStreaming: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
         subagentStreaming: z.ZodOptional<z.ZodBoolean>;
+        subagentCompleted: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     messageId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
@@ -557,6 +558,7 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
             }, z.core.$strip>], "type">>>;
             isStreaming: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
+        subagentCompleted: z.ZodOptional<z.ZodBoolean>;
         _meta: z.ZodOptional<z.ZodObject<{
             truncationWarning: z.ZodOptional<z.ZodString>;
             compactionAction: z.ZodOptional<z.ZodEnum<{

package/dist/sdk/transports/http.js

@@ -1169,6 +1169,17 @@ export class HttpTransport {
                 typeof update._meta.originalContentPath === "string"
                 ? update._meta.originalContentPath
                 : undefined;
+            // Check for subagentCompleted at top level first (sent by adapter),
+            // then fallback to _meta (for backward compatibility)
+            const subagentCompleted = "subagentCompleted" in update &&
+                typeof update.subagentCompleted === "boolean"
+                ? update.subagentCompleted
+                : update._meta &&
+                    typeof update._meta === "object" &&
+                    "subagentCompleted" in update._meta &&
+                    typeof update._meta.subagentCompleted === "boolean"
+                    ? update._meta.subagentCompleted
+                    : undefined;
             // Tool call update notification
             const toolCallUpdate = {
                 id: update.toolCallId ?? "",
@@ -1181,6 +1192,7 @@ export class HttpTransport {
                 locations: update.locations,
                 rawOutput: update.rawOutput,
                 tokenUsage: update.tokenUsage,
+                subagentCompleted,
                 content: update.content?.map((c) => {
                     // Type guard to safely check properties
                     if (typeof c !== "object" || c === null) {
@@ -1492,8 +1504,9 @@ export class HttpTransport {
                         isComplete: false,
                     };
                 }
-                // Only queue chunks for live streaming, not replay
-                if (chunk && !isReplay) {
+                // Queue chunks for both live streaming AND replay
+                // Replay chunks need to be accumulated just like live chunks
+                if (chunk) {
                     // Resolve any waiting receive() calls immediately
                     const resolver = this.chunkResolvers.shift();
                     if (resolver) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/ui",
-  "version": "0.1.105",
+  "version": "0.1.107",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -49,7 +49,7 @@
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-tabs": "^1.1.13",
     "@radix-ui/react-tooltip": "^1.2.8",
-    "@townco/core": "0.0.83",
+    "@townco/core": "0.0.85",
     "@types/mdast": "^4.0.4",
     "@uiw/react-json-view": "^2.0.0-alpha.39",
     "class-variance-authority": "^0.7.1",
@@ -67,19 +67,19 @@
     "zustand": "^5.0.8"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.102",
+    "@townco/tsconfig": "0.1.104",
     "@types/node": "^24.10.0",
     "@types/react": "^19.2.2",
     "@types/unist": "^3.0.3",
     "@typescript/native-preview": "^7.0.0-dev.20251207.1",
     "ink": "^6.4.0",
-    "react": "19.2.1",
+    "react": "19.2.3",
     "tailwindcss": "^4.1.17"
   },
   "peerDependencies": {
     "ink": "^6.4.0",
-    "react": "^19.2.1",
-    "react-dom": "^19.2.1"
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3"
   },
   "peerDependenciesMeta": {
     "react": {

package/dist/core/hooks/use-subagent-stream.d.ts

@@ -1,28 +0,0 @@
-import type { SubagentMessage } from "../schemas/tool-call.js";
-export interface UseSubagentStreamOptions {
-    /** Sub-agent HTTP port */
-    port: number;
-    /** Sub-agent session ID */
-    sessionId: string;
-    /** Base host (defaults to localhost) */
-    host?: string;
-}
-export interface UseSubagentStreamReturn {
-    /** Accumulated messages from the sub-agent */
-    messages: SubagentMessage[];
-    /** Whether the stream is currently active */
-    isStreaming: boolean;
-    /** Error message if connection failed */
-    error: string | null;
-}
-/**
- * Hook to connect directly to a sub-agent's SSE endpoint and stream messages.
- *
- * This hook:
- * - Connects to the sub-agent's HTTP server at the given port
- * - Subscribes to the /events SSE endpoint with the session ID
- * - Parses incoming session/update notifications
- * - Extracts text chunks and tool calls
- * - Returns accumulated messages for display
- */
-export declare function useSubagentStream(options: UseSubagentStreamOptions | null): UseSubagentStreamReturn;

package/dist/core/hooks/use-subagent-stream.js

@@ -1,256 +0,0 @@
-import { createLogger } from "@townco/core";
-import { useCallback, useEffect, useRef, useState } from "react";
-const logger = createLogger("subagent-stream");
-/**
- * Hook to connect directly to a sub-agent's SSE endpoint and stream messages.
- *
- * This hook:
- * - Connects to the sub-agent's HTTP server at the given port
- * - Subscribes to the /events SSE endpoint with the session ID
- * - Parses incoming session/update notifications
- * - Extracts text chunks and tool calls
- * - Returns accumulated messages for display
- */
-export function useSubagentStream(options) {
-    const [messages, setMessages] = useState([]);
-    // Start as streaming=true if options provided, since we're about to connect
-    const [_isStreaming, setIsStreaming] = useState(!!options);
-    const [hasCompleted, setHasCompleted] = useState(false);
-    const [error, setError] = useState(null);
-    const abortControllerRef = useRef(null);
-    const currentMessageRef = useRef(null);
-    const updateTimeoutRef = useRef(null);
-    // Throttled update to prevent excessive re-renders
-    const scheduleUpdate = useCallback(() => {
-        // If there's already a pending timeout, let it handle the update
-        // (it will read the latest currentMessageRef value)
-        if (updateTimeoutRef.current)
-            return;
-        updateTimeoutRef.current = setTimeout(() => {
-            updateTimeoutRef.current = null;
-            if (currentMessageRef.current) {
-                setMessages([{ ...currentMessageRef.current }]);
-            }
-        }, 250); // Batch updates every 250ms
-    }, []);
-    // Process incoming SSE message from sub-agent
-    // Defined BEFORE connectToSubagent so it's available in the closure
-    const processSSEMessage = useCallback((data) => {
-        try {
-            const message = JSON.parse(data);
-            logger.debug("Processing SSE message", {
-                method: message.method,
-                hasParams: !!message.params,
-            });
-            // Check if this is a session/update notification
-            if (message.method === "session/update" && message.params?.update) {
-                const update = message.params.update;
-                logger.debug("Got session update", {
-                    sessionUpdate: update.sessionUpdate,
-                });
-                if (update.sessionUpdate === "agent_message_chunk") {
-                    // Handle text chunk
-                    const content = update.content;
-                    if (content?.type === "text" && typeof content.text === "string") {
-                        if (currentMessageRef.current) {
-                            currentMessageRef.current.content += content.text;
-                            // Add to contentBlocks - append to last text block or create new one
-                            const blocks = currentMessageRef.current.contentBlocks ?? [];
-                            const lastBlock = blocks[blocks.length - 1];
-                            if (lastBlock && lastBlock.type === "text") {
-                                lastBlock.text += content.text;
-                            }
-                            else {
-                                blocks.push({ type: "text", text: content.text });
-                            }
-                            currentMessageRef.current.contentBlocks = blocks;
-                            scheduleUpdate();
-                        }
-                    }
-                }
-                else if (update.sessionUpdate === "tool_call") {
-                    // Handle new tool call
-                    const toolCall = {
-                        id: update.toolCallId ?? `tc-${Date.now()}`,
-                        title: update.title ?? "Tool call",
-                        prettyName: update._meta?.prettyName,
-                        icon: update._meta?.icon,
-                        status: update.status ?? "pending",
-                        content: [],
-                    };
-                    if (currentMessageRef.current) {
-                        currentMessageRef.current.toolCalls = [
-                            ...(currentMessageRef.current.toolCalls ?? []),
-                            toolCall,
-                        ];
-                        // Add to contentBlocks for interleaved display
-                        const blocks = currentMessageRef.current.contentBlocks ?? [];
-                        blocks.push({ type: "tool_call", toolCall });
-                        currentMessageRef.current.contentBlocks = blocks;
-                        scheduleUpdate();
-                    }
-                }
-                else if (update.sessionUpdate === "tool_call_update") {
-                    // Handle tool call update (status change, completion)
-                    if (currentMessageRef.current?.toolCalls) {
-                        const toolCallId = update.toolCallId;
-                        const updateToolCall = (tc) => tc.id === toolCallId
-                            ? {
-                                ...tc,
-                                status: update.status ?? tc.status,
-                                content: update.content ?? tc.content,
-                            }
-                            : tc;
-                        currentMessageRef.current.toolCalls =
-                            currentMessageRef.current.toolCalls.map(updateToolCall);
-                        // Also update in contentBlocks
-                        if (currentMessageRef.current.contentBlocks) {
-                            currentMessageRef.current.contentBlocks =
-                                currentMessageRef.current.contentBlocks.map((block) => block.type === "tool_call"
-                                    ? { ...block, toolCall: updateToolCall(block.toolCall) }
-                                    : block);
-                        }
-                        scheduleUpdate();
-                    }
-                }
-            }
-        }
-        catch (err) {
-            logger.error("Failed to parse sub-agent SSE message", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }, [scheduleUpdate]);
-    const connectToSubagent = useCallback(async (port, sessionId, host, protocol) => {
-        const baseUrl = `${protocol}//${host}:${port}`;
-        logger.info("Connecting to sub-agent SSE", { baseUrl, sessionId });
-        setIsStreaming(true);
-        setError(null);
-        // Create abort controller for cleanup
-        const abortController = new AbortController();
-        abortControllerRef.current = abortController;
-        try {
-            logger.info("Fetching SSE endpoint", {
-                url: `${baseUrl}/events`,
-                sessionId,
-            });
-            const response = await fetch(`${baseUrl}/events`, {
-                method: "GET",
-                headers: {
-                    "X-Session-ID": sessionId,
-                },
-                signal: abortController.signal,
-            });
-            logger.info("SSE response received", {
-                status: response.status,
-                ok: response.ok,
-            });
-            if (!response.ok) {
-                throw new Error(`SSE connection failed: HTTP ${response.status}`);
-            }
-            if (!response.body) {
-                throw new Error("Response body is null");
-            }
-            logger.info("Sub-agent SSE connection opened, starting to read stream");
-            // Read the SSE stream
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = "";
-            // Initialize current message
-            currentMessageRef.current = {
-                id: `subagent-${Date.now()}`,
-                content: "",
-                toolCalls: [],
-                contentBlocks: [],
-                isStreaming: true,
-            };
-            setMessages([currentMessageRef.current]);
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    logger.debug("Sub-agent SSE stream closed");
-                    break;
-                }
-                // Decode the chunk and add to buffer
-                buffer += decoder.decode(value, { stream: true });
-                // Process complete SSE messages
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || ""; // Keep incomplete line in buffer
-                let currentEvent = { event: "message", data: "" };
-                for (const line of lines) {
-                    if (line.startsWith("event:")) {
-                        currentEvent.event = line.substring(6).trim();
-                    }
-                    else if (line.startsWith("data:")) {
-                        currentEvent.data = line.substring(5).trim();
-                    }
-                    else if (line === "") {
-                        // Empty line signals end of event
-                        if (currentEvent.event === "message" && currentEvent.data) {
-                            processSSEMessage(currentEvent.data);
-                        }
-                        // Reset for next event
-                        currentEvent = { event: "message", data: "" };
-                    }
-                }
-            }
-        }
-        catch (err) {
-            if (err instanceof Error && err.name === "AbortError") {
-                logger.debug("Sub-agent SSE stream aborted");
-            }
-            else {
-                const errorMessage = err instanceof Error
-                    ? err.message
-                    : "Failed to connect to sub-agent";
-                logger.error("Sub-agent SSE error", { error: errorMessage });
-                setError(errorMessage);
-            }
-        }
-        finally {
-            // Mark streaming as complete
-            if (currentMessageRef.current) {
-                currentMessageRef.current.isStreaming = false;
-                setMessages((prev) => prev.map((m) => m.id === currentMessageRef.current?.id
-                    ? { ...m, isStreaming: false }
-                    : m));
-            }
-            setHasCompleted(true);
-            setIsStreaming(false);
-            abortControllerRef.current = null;
-            logger.debug("Sub-agent stream completed");
-        }
-    }, [processSSEMessage]);
-    // Extract values from options (memoized to avoid dependency issues)
-    const port = options?.port;
-    const sessionId = options?.sessionId;
-    const host = options?.host ??
-        (typeof window !== "undefined" ? window.location.hostname : "localhost");
-    const protocol = typeof window !== "undefined" ? window.location.protocol : "http:";
-    // Connect when options change
-    useEffect(() => {
-        if (!port || !sessionId) {
-            return;
-        }
-        // Reset state for new connection
-        setMessages([]);
-        setError(null);
-        setHasCompleted(false);
-        setIsStreaming(true);
-        connectToSubagent(port, sessionId, host, protocol);
-        // Cleanup on unmount or options change
-        return () => {
-            if (abortControllerRef.current) {
-                abortControllerRef.current.abort();
-                abortControllerRef.current = null;
-            }
-            if (updateTimeoutRef.current) {
-                clearTimeout(updateTimeoutRef.current);
-                updateTimeoutRef.current = null;
-            }
-        };
-    }, [port, sessionId, host, protocol, connectToSubagent]);
-    // Derive streaming status: streaming if we haven't completed yet
-    const effectiveIsStreaming = !hasCompleted;
-    return { messages, isStreaming: effectiveIsStreaming, error };
-}

package/dist/gui/components/InvokingGroup.d.ts

@@ -1,9 +0,0 @@
-import type { ToolCall as ToolCallType } from "../../core/schemas/tool-call.js";
-export interface InvokingGroupProps {
-    toolCalls: ToolCallType[];
-}
-/**
- * InvokingGroup component - displays a group of preliminary (invoking) tool calls
- * Shows as "Invoking parallel operation (N)" with a summary of unique tool names
- */
-export declare function InvokingGroup({ toolCalls }: InvokingGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/gui/components/InvokingGroup.js

@@ -1,16 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ListVideo } from "lucide-react";
-import React from "react";
-/**
- * InvokingGroup component - displays a group of preliminary (invoking) tool calls
- * Shows as "Invoking parallel operation (N)" with a summary of unique tool names
- */
-export function InvokingGroup({ toolCalls }) {
-    // Get unique display names for the summary
-    const displayNames = toolCalls.map((tc) => tc.prettyName || tc.title);
-    const uniqueNames = [...new Set(displayNames)];
-    const summary = uniqueNames.length <= 2
-        ? uniqueNames.join(", ")
-        : `${uniqueNames.slice(0, 2).join(", ")} +${uniqueNames.length - 2} more`;
-    return (_jsxs("div", { className: "flex flex-col my-4", children: [_jsxs("div", { className: "flex items-center gap-1.5 text-paragraph-sm text-muted-foreground/50", children: [_jsx(ListVideo, { className: "h-3 w-3" }), _jsx("span", { children: "Invoking parallel operation" }), _jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-muted-foreground/50", children: toolCalls.length })] }), _jsx("span", { className: "text-paragraph-sm text-muted-foreground/50 pl-4.5", children: summary })] }));
-}

package/dist/gui/components/ToolCall.d.ts

@@ -1,8 +0,0 @@
-import type { ToolCall as ToolCallType } from "../../core/schemas/tool-call.js";
-export interface ToolCallProps {
-    toolCall: ToolCallType;
-}
-/**
- * ToolCall component - displays a single tool call with collapsible details
- */
-export declare function ToolCall({ toolCall }: ToolCallProps): import("react/jsx-runtime").JSX.Element;

package/dist/gui/components/ToolCall.js

@@ -1,226 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import JsonView from "@uiw/react-json-view";
-import { AlertCircle, CheckSquare, ChevronDown, ChevronRight, CircleDot, Cloud, Edit, FileText, Globe, Image, Link, Search, Wrench, } from "lucide-react";
-import React, { useState } from "react";
-import { ChatLayout } from "./index.js";
-import { SubAgentDetails } from "./SubAgentDetails.js";
-import { useTheme } from "./ThemeProvider.js";
-/**
- * Map of icon names to Lucide components
- */
-const ICON_MAP = {
-    Globe: Globe,
-    Image: Image,
-    Link: Link,
-    Cloud: Cloud,
-    CheckSquare: CheckSquare,
-    Search: Search,
-    FileText: FileText,
-    Edit: Edit,
-    Wrench: Wrench,
-    CircleDot: CircleDot,
-};
-/**
- * Tool call kind icons (using emoji for simplicity)
- */
-const _kindIcons = {
-    read: "\u{1F4C4}",
-    edit: "\u{270F}\u{FE0F}",
-    delete: "\u{1F5D1}\u{FE0F}",
-    move: "\u{1F4E6}",
-    search: "\u{1F50D}",
-    execute: "\u{2699}\u{FE0F}",
-    think: "\u{1F4AD}",
-    fetch: "\u{1F310}",
-    switch_mode: "\u{1F501}",
-    other: "\u{1F527}",
-};
-/**
- * ToolCall component - displays a single tool call with collapsible details
- */
-export function ToolCall({ toolCall }) {
-    const [isExpanded, setIsExpanded] = useState(false);
-    const [isSubagentExpanded, setIsSubagentExpanded] = useState(false);
-    const { resolvedTheme } = useTheme();
-    // Detect TodoWrite tool and subagent
-    const isTodoWrite = toolCall.title === "todo_write";
-    const isSubagentCall = !!(toolCall.subagentPort && toolCall.subagentSessionId);
-    // Safely access ChatLayout context - will be undefined if not within ChatLayout
-    const layoutContext = React.useContext(ChatLayout.Context);
-    // Click handler: toggle sidepanel for TodoWrite, subagent details for subagents, expand for others
-    const handleHeaderClick = React.useCallback(() => {
-        if (isTodoWrite && layoutContext) {
-            // Toggle sidepanel - close if already open on todo tab, otherwise open
-            if (layoutContext.panelSize !== "hidden" &&
-                layoutContext.activeTab === "todo") {
-                layoutContext.setPanelSize("hidden");
-            }
-            else {
-                layoutContext.setPanelSize("small");
-                layoutContext.setActiveTab("todo");
-            }
-        }
-        else if (isSubagentCall) {
-            // Toggle subagent details
-            setIsSubagentExpanded(!isSubagentExpanded);
-        }
-        else {
-            // Normal expand/collapse
-            setIsExpanded(!isExpanded);
-        }
-    }, [
-        isTodoWrite,
-        layoutContext,
-        isExpanded,
-        isSubagentCall,
-        isSubagentExpanded,
-    ]);
-    // Determine which icon to show
-    const IconComponent = toolCall.icon && ICON_MAP[toolCall.icon]
-        ? ICON_MAP[toolCall.icon]
-        : CircleDot;
-    // Determine display name
-    const displayName = toolCall.prettyName || toolCall.title;
-    // Determine icon color based on status (especially for subagents)
-    const isSubagentRunning = isSubagentCall &&
-        (toolCall.status === "in_progress" || toolCall.status === "pending");
-    const isSubagentFailed = isSubagentCall && toolCall.status === "failed";
-    const iconColorClass = isSubagentCall
-        ? isSubagentFailed
-            ? "text-destructive"
-            : isSubagentRunning
-                ? "text-foreground animate-pulse"
-                : "text-green-500"
-        : "text-muted-foreground";
-    const statusTooltip = isSubagentCall
-        ? isSubagentFailed
-            ? "Sub-agent failed"
-            : isSubagentRunning
-                ? "Sub-agent running"
-                : "Sub-agent completed"
-        : undefined;
-    // Check if there's an error
-    const hasError = toolCall.status === "failed" || !!toolCall.error;
-    // Check if this is a preliminary (pending) tool call without full details yet
-    const isPreliminary = toolCall.status === "pending" &&
-        (!toolCall.rawInput || Object.keys(toolCall.rawInput).length === 0);
-    // JSON View style based on theme
-    const jsonStyle = {
-        fontSize: "11px",
-        backgroundColor: "transparent",
-        fontFamily: "inherit",
-        "--w-rjv-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
-        "--w-rjv-key-string": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
-        "--w-rjv-background-color": "transparent",
-        "--w-rjv-line-color": resolvedTheme === "dark" ? "#27272a" : "#e4e4e7",
-        "--w-rjv-arrow-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-edit-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
-        "--w-rjv-info-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-update-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
-        "--w-rjv-copied-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
-        "--w-rjv-copied-success-color": resolvedTheme === "dark" ? "#22c55e" : "#16a34a",
-        "--w-rjv-curlybraces-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-colon-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-brackets-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-quotes-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-quotes-string-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
-        "--w-rjv-type-string-color": resolvedTheme === "dark" ? "#22c55e" : "#16a34a",
-        "--w-rjv-type-int-color": resolvedTheme === "dark" ? "#f59e0b" : "#d97706",
-        "--w-rjv-type-float-color": resolvedTheme === "dark" ? "#f59e0b" : "#d97706",
-        "--w-rjv-type-bigint-color": resolvedTheme === "dark" ? "#f59e0b" : "#d97706",
-        "--w-rjv-type-boolean-color": resolvedTheme === "dark" ? "#3b82f6" : "#2563eb",
-        "--w-rjv-type-date-color": resolvedTheme === "dark" ? "#ec4899" : "#db2777",
-        "--w-rjv-type-url-color": resolvedTheme === "dark" ? "#3b82f6" : "#2563eb",
-        "--w-rjv-type-null-color": resolvedTheme === "dark" ? "#ef4444" : "#dc2626",
-        "--w-rjv-type-nan-color": resolvedTheme === "dark" ? "#ef4444" : "#dc2626",
-        "--w-rjv-type-undefined-color": resolvedTheme === "dark" ? "#ef4444" : "#dc2626",
-    };
-    // Preliminary tool calls show as simple light gray text without expansion
-    if (isPreliminary) {
-        return (_jsx("div", { className: "flex flex-col my-4", children: _jsxs("span", { className: "text-paragraph-sm text-muted-foreground/50", children: ["Invoking ", displayName] }) }));
-    }
-    return (_jsxs("div", { className: "flex flex-col my-4", children: [_jsxs("button", { type: "button", className: "flex flex-col items-start gap-0.5 cursor-pointer bg-transparent border-none p-0 text-left group w-fit", onClick: handleHeaderClick, "aria-expanded": isTodoWrite ? undefined : isExpanded, children: [_jsxs("div", { className: "flex items-center gap-1.5 text-[11px] font-medium text-muted-foreground", children: [_jsx("div", { className: iconColorClass, title: statusTooltip, children: _jsx(IconComponent, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-muted-foreground", children: displayName }), hasError && _jsx(AlertCircle, { className: "h-3 w-3 text-destructive" }), isTodoWrite ? (_jsx(ChevronRight, { className: "h-3 w-3 text-muted-foreground/70" })) : (_jsx(ChevronDown, { className: `h-3 w-3 text-muted-foreground/70 transition-transform duration-200 ${isExpanded ? "rotate-180" : ""}` }))] }), toolCall.subline && (_jsx("span", { className: "text-paragraph-sm text-muted-foreground/70 pl-4.5", children: toolCall.subline }))] }), !isTodoWrite && isSubagentCall && (_jsx("div", { className: "pl-4.5", children: _jsx(SubAgentDetails, { port: toolCall.subagentPort, sessionId: toolCall.subagentSessionId, parentStatus: toolCall.status, agentName: toolCall.rawInput?.agentName, query: toolCall.rawInput?.query, isExpanded: isSubagentExpanded, onExpandChange: setIsSubagentExpanded }) })), !isTodoWrite && !isSubagentCall && isExpanded && (_jsxs("div", { className: "mt-2 text-sm border border-border rounded-lg bg-card overflow-hidden w-full", children: [toolCall.rawInput &&
-                        Object.keys(toolCall.rawInput).length > 0 &&
-                        !toolCall.subagentPort && (_jsxs("div", { className: "p-3 border-b border-border", children: [_jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Input" }), _jsx("div", { className: "text-[11px] font-mono text-foreground", children: _jsx(JsonView, { value: toolCall.rawInput, collapsed: false, displayDataTypes: false, displayObjectSize: false, enableClipboard: true, style: jsonStyle }) })] })), toolCall.locations && toolCall.locations.length > 0 && (_jsxs("div", { className: "p-3 border-b border-border", children: [_jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Files" }), _jsx("ul", { className: "space-y-1", children: toolCall.locations.map((loc) => (_jsxs("li", { className: "font-mono text-[11px] text-foreground bg-muted px-1.5 py-0.5 rounded w-fit", children: [loc.path, loc.line !== null &&
-                                            loc.line !== undefined &&
-                                            `:${loc.line}`] }, `${loc.path}:${loc.line ?? ""}`))) })] })), (toolCall.content && toolCall.content.length > 0) ||
-                        toolCall.error ? (_jsxs("div", { className: "p-3 border-b border-border last:border-0", children: [_jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Output" }), _jsxs("div", { className: "space-y-2 text-[11px] text-foreground", children: [toolCall.content?.map((block, idx) => {
-                                        // Generate a stable key based on content
-                                        const getBlockKey = () => {
-                                            if (block.type === "diff" && "path" in block) {
-                                                return `diff-${block.path}-${idx}`;
-                                            }
-                                            if (block.type === "terminal" && "terminalId" in block) {
-                                                return `terminal-${block.terminalId}`;
-                                            }
-                                            if (block.type === "text" && "text" in block) {
-                                                return `text-${block.text.substring(0, 20)}-${idx}`;
-                                            }
-                                            if (block.type === "content" && "content" in block) {
-                                                const innerContent = block.content;
-                                                return `content-${innerContent.text?.substring(0, 20)}-${idx}`;
-                                            }
-                                            return `block-${idx}`;
-                                        };
-                                        // Helper to render text content (with JSON parsing if applicable)
-                                        const renderTextContent = (text, key) => {
-                                            // Try to parse as JSON
-                                            try {
-                                                const parsed = JSON.parse(text);
-                                                // If it's an object or array, render with JsonView
-                                                if (typeof parsed === "object" && parsed !== null) {
-                                                    return (_jsx("div", { className: "text-[11px]", children: _jsx(JsonView, { value: parsed, collapsed: false, displayDataTypes: false, displayObjectSize: false, enableClipboard: true, style: jsonStyle }) }, key));
-                                                }
-                                            }
-                                            catch {
-                                                // Not valid JSON, render as plain text
-                                            }
-                                            // Render as plain text
-                                            return (_jsx("pre", { className: "whitespace-pre-wrap font-mono text-[11px] text-foreground overflow-x-auto", children: text }, key));
-                                        };
-                                        // Handle nested content blocks (ACP format)
-                                        if (block.type === "content" && "content" in block) {
-                                            const innerContent = block.content;
-                                            if (innerContent.type === "text" && innerContent.text) {
-                                                return renderTextContent(innerContent.text, getBlockKey());
-                                            }
-                                        }
-                                        // Handle direct text blocks
-                                        if (block.type === "text" && "text" in block) {
-                                            return renderTextContent(block.text, getBlockKey());
-                                        }
-                                        // Handle image blocks
-                                        if (block.type === "image") {
-                                            const alt = block.alt || "Generated image";
-                                            let imageSrc;
-                                            if ("data" in block) {
-                                                // Base64 encoded image
-                                                const mimeType = block.mimeType || "image/png";
-                                                imageSrc = `data:${mimeType};base64,${block.data}`;
-                                            }
-                                            else if ("url" in block) {
-                                                // URL or file path
-                                                imageSrc = block.url;
-                                            }
-                                            else {
-                                                return null;
-                                            }
-                                            return (_jsx("div", { className: "my-2", children: _jsx("img", { src: imageSrc, alt: alt, className: "max-w-full h-auto rounded-md border border-border" }) }, getBlockKey()));
-                                        }
-                                        // Handle diff blocks
-                                        if (block.type === "diff" &&
-                                            "path" in block &&
-                                            "oldText" in block &&
-                                            "newText" in block) {
-                                            return (_jsxs("div", { className: "border border-border rounded bg-card", children: [_jsxs("div", { className: "bg-muted px-2 py-1 text-[10px] font-mono text-muted-foreground border-b border-border", children: [block.path, "line" in block &&
-                                                                block.line !== null &&
-                                                                block.line !== undefined &&
-                                                                `:${block.line}`] }), _jsxs("div", { className: "p-2 font-mono text-[11px]", children: [_jsxs("div", { className: "text-red-500 dark:text-red-400", children: ["- ", block.oldText] }), _jsxs("div", { className: "text-green-500 dark:text-green-400", children: ["+ ", block.newText] })] })] }, getBlockKey()));
-                                        }
-                                        // Handle terminal blocks
-                                        if (block.type === "terminal" && "terminalId" in block) {
-                                            return (_jsxs("div", { className: "bg-neutral-900 text-neutral-100 p-2 rounded text-[11px] font-mono", children: ["Terminal: ", block.terminalId] }, getBlockKey()));
-                                        }
-                                        return null;
-                                    }), toolCall.error && (_jsxs("div", { className: "text-destructive font-mono text-[11px] mt-2", children: ["Error: ", toolCall.error] }))] })] })) : null, toolCall._meta?.truncationWarning && (_jsxs("div", { className: "mx-3 mt-3 mb-0 flex items-center gap-2 rounded-md bg-yellow-50 dark:bg-yellow-950/20 px-3 py-2 text-[11px] text-yellow-800 dark:text-yellow-200 border border-yellow-200 dark:border-yellow-900", children: [_jsx("span", { className: "text-yellow-600 dark:text-yellow-500", children: "\u26A0\uFE0F" }), _jsx("span", { children: toolCall._meta.truncationWarning })] })), (toolCall.tokenUsage || toolCall.startedAt) && (_jsxs("div", { className: "p-2 bg-muted/50 border-t border-border flex flex-wrap gap-4 text-[10px] text-muted-foreground font-sans", children: [toolCall.tokenUsage && (_jsxs("div", { className: "flex gap-3", children: [toolCall.tokenUsage.inputTokens !== undefined && (_jsxs("div", { children: [_jsx("span", { className: "uppercase tracking-wide font-semibold mr-1", children: "Input:" }), toolCall.tokenUsage.inputTokens.toLocaleString()] })), toolCall.tokenUsage.outputTokens !== undefined && (_jsxs("div", { children: [_jsx("span", { className: "uppercase tracking-wide font-semibold mr-1", children: "Output:" }), toolCall.tokenUsage.outputTokens.toLocaleString()] })), toolCall.tokenUsage.totalTokens !== undefined && (_jsxs("div", { children: [_jsx("span", { className: "uppercase tracking-wide font-semibold mr-1", children: "Total:" }), toolCall.tokenUsage.totalTokens.toLocaleString()] }))] })), toolCall.startedAt && (_jsxs("div", { className: "flex gap-3 ml-auto", children: [_jsxs("span", { children: ["Started: ", new Date(toolCall.startedAt).toLocaleTimeString()] }), toolCall.completedAt && (_jsxs("span", { children: ["Completed:", " ", new Date(toolCall.completedAt).toLocaleTimeString(), " (", Math.round((toolCall.completedAt - toolCall.startedAt) / 1000), "s)"] }))] }))] }))] }))] }));
-}

package/dist/gui/components/ToolCallGroup.d.ts

@@ -1,8 +0,0 @@
-import type { ToolCall as ToolCallType } from "../../core/schemas/tool-call.js";
-export interface ToolCallGroupProps {
-    toolCalls: ToolCallType[];
-}
-/**
- * ToolCallGroup component - displays a group of parallel tool calls with collapsible details
- */
-export declare function ToolCallGroup({ toolCalls }: ToolCallGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/gui/components/ToolCallGroup.js

@@ -1,29 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ChevronDown, ListVideo } from "lucide-react";
-import React, { useState } from "react";
-import { ToolCall } from "./ToolCall.js";
-/**
- * ToolCallGroup component - displays a group of parallel tool calls with collapsible details
- */
-export function ToolCallGroup({ toolCalls }) {
-    const [isExpanded, setIsExpanded] = useState(false);
-    // Calculate group status based on individual tool call statuses
-    const getGroupStatus = () => {
-        const statuses = toolCalls.map((tc) => tc.status);
-        if (statuses.some((s) => s === "failed"))
-            return "failed";
-        if (statuses.some((s) => s === "in_progress"))
-            return "in_progress";
-        if (statuses.every((s) => s === "completed"))
-            return "completed";
-        return "pending";
-    };
-    const groupStatus = getGroupStatus();
-    // Generate summary of tool names
-    const toolNames = toolCalls.map((tc) => tc.prettyName || tc.title);
-    const uniqueNames = [...new Set(toolNames)];
-    const summary = uniqueNames.length <= 2
-        ? uniqueNames.join(", ")
-        : `${uniqueNames.slice(0, 2).join(", ")} +${uniqueNames.length - 2} more`;
-    return (_jsxs("div", { className: "flex flex-col my-4", children: [_jsxs("button", { type: "button", className: "flex flex-col items-start gap-0.5 cursor-pointer bg-transparent border-none p-0 text-left group w-fit", onClick: () => setIsExpanded(!isExpanded), "aria-expanded": isExpanded, children: [_jsxs("div", { className: "flex items-center gap-1.5 text-[11px] font-medium text-muted-foreground", children: [_jsx("div", { className: "text-muted-foreground", children: _jsx(ListVideo, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-muted-foreground", children: "Parallel operation" }), _jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-muted-foreground/70", children: toolCalls.length }), _jsx(ChevronDown, { className: `h-3 w-3 text-muted-foreground/70 transition-transform duration-200 ${isExpanded ? "rotate-180" : ""}` })] }), !isExpanded && (_jsx("span", { className: "text-paragraph-sm text-muted-foreground/70 pl-4.5", children: summary }))] }), isExpanded && (_jsx("div", { className: "mt-1", children: toolCalls.map((toolCall) => (_jsxs("div", { className: "flex items-start", children: [_jsx("div", { className: "w-2.5 h-4 border-l-2 border-b-2 border-border rounded-bl-[6px] mt-1 mr-0.5 shrink-0" }), _jsx("div", { className: "flex-1 -mt-2", children: _jsx(ToolCall, { toolCall: toolCall }) })] }, toolCall.id))) }))] }));
-}