@townco/ui 0.1.67 → 0.1.69

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

@@ -19,6 +19,11 @@ export declare function useChatMessages(client: AcpClient | null, startSession:
             batchId?: string | undefined;
             prettyName?: string | undefined;
             icon?: string | undefined;
+            verbiage?: {
+                active: string;
+                past: string;
+                paramKey?: string | undefined;
+            } | undefined;
             subline?: string | undefined;
             contentPosition?: number | undefined;
             locations?: {

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

@@ -17,6 +17,11 @@ export declare function useToolCalls(client: AcpClient | null): {
         batchId?: string | undefined;
         prettyName?: string | undefined;
         icon?: string | undefined;
+        verbiage?: {
+            active: string;
+            past: string;
+            paramKey?: string | undefined;
+        } | undefined;
         subline?: string | undefined;
         contentPosition?: number | undefined;
         locations?: {

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

@@ -1,5 +1,7 @@
+import { createLogger } from "@townco/core";
 import { useEffect } from "react";
 import { useChatStore } from "../store/chat-store.js";
+const logger = createLogger("use-tool-calls", "debug");
 /**
  * Hook to track and manage tool calls from ACP sessions
  *
@@ -20,7 +22,6 @@ export function useToolCalls(client) {
         // Subscribe to session updates for tool calls
         const unsubscribe = client.onSessionUpdate((update) => {
             if (update.type === "tool_call") {
-                // Initial tool call notification
                 // Add to session-level tool calls (for sidebar)
                 addToolCall(update.sessionId, update.toolCall);
                 // Also add to current assistant message (for inline display)

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

@@ -31,6 +31,11 @@ export declare const DisplayMessage: z.ZodObject<{
         title: z.ZodString;
         prettyName: z.ZodOptional<z.ZodString>;
         icon: z.ZodOptional<z.ZodString>;
+        verbiage: z.ZodOptional<z.ZodObject<{
+            active: z.ZodString;
+            past: z.ZodString;
+            paramKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         subline: z.ZodOptional<z.ZodString>;
         kind: z.ZodEnum<{
             read: "read";
@@ -248,6 +253,11 @@ export declare const ChatSessionState: z.ZodObject<{
             title: z.ZodString;
             prettyName: z.ZodOptional<z.ZodString>;
             icon: z.ZodOptional<z.ZodString>;
+            verbiage: z.ZodOptional<z.ZodObject<{
+                active: z.ZodString;
+                past: z.ZodString;
+                paramKey: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
             subline: z.ZodOptional<z.ZodString>;
             kind: z.ZodEnum<{
                 read: "read";

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

@@ -273,6 +273,11 @@ export declare const ToolCallSchema: z.ZodObject<{
     title: z.ZodString;
     prettyName: z.ZodOptional<z.ZodString>;
     icon: z.ZodOptional<z.ZodString>;
+    verbiage: z.ZodOptional<z.ZodObject<{
+        active: z.ZodString;
+        past: z.ZodString;
+        paramKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     subline: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
         read: "read";
@@ -498,6 +503,97 @@ export declare const ToolCallUpdateSchema: z.ZodObject<{
     }, z.core.$strip>>;
     subagentPort: z.ZodOptional<z.ZodNumber>;
     subagentSessionId: z.ZodOptional<z.ZodString>;
+    subagentMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            prettyName: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                in_progress: "in_progress";
+                completed: "completed";
+                failed: "failed";
+            }>;
+            content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"content">;
+                content: z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                data: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+                alt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodString;
+                alt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"diff">;
+                path: z.ZodString;
+                oldText: z.ZodString;
+                newText: z.ZodString;
+                line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"terminal">;
+                terminalId: z.ZodString;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>>>;
+        contentBlocks: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_call">;
+            toolCall: z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                prettyName: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    in_progress: "in_progress";
+                    completed: "completed";
+                    failed: "failed";
+                }>;
+                content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"content">;
+                    content: z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    data: z.ZodString;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    alt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    url: z.ZodString;
+                    alt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"diff">;
+                    path: z.ZodString;
+                    oldText: z.ZodString;
+                    newText: z.ZodString;
+                    line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"terminal">;
+                    terminalId: z.ZodString;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">>>;
+        isStreaming: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ToolCallUpdate = z.infer<typeof ToolCallUpdateSchema>;
 /**

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

@@ -132,6 +132,14 @@ export const ToolCallSchema = z.object({
     prettyName: z.string().optional(),
     /** Optional icon identifier for the tool (e.g. "Globe", "Search", "Edit") */
     icon: z.string().optional(),
+    /** Optional verbiage templates for displaying the tool call in different tenses */
+    verbiage: z
+        .object({
+        active: z.string(),
+        past: z.string(),
+        paramKey: z.string().optional(),
+    })
+        .optional(),
     /** Optional subline text to display below the tool title (e.g. current task status) */
     subline: z.string().optional(),
     /** Category for UI presentation */
@@ -195,6 +203,8 @@ export const ToolCallUpdateSchema = z.object({
     subagentPort: z.number().optional(),
     /** Sub-agent session ID for SSE connection */
     subagentSessionId: z.string().optional(),
+    /** Sub-agent messages for replay */
+    subagentMessages: z.array(SubagentMessageSchema).optional(),
 });
 /**
  * Helper to merge a tool call update into an existing tool call
@@ -220,6 +230,8 @@ export function mergeToolCallUpdate(existing, update) {
         // Sub-agent connection info
         subagentPort: update.subagentPort ?? existing.subagentPort,
         subagentSessionId: update.subagentSessionId ?? existing.subagentSessionId,
+        // Sub-agent messages for replay
+        subagentMessages: update.subagentMessages ?? existing.subagentMessages,
     };
     return merged;
 }

package/dist/core/utils/tool-call-state.d.ts

@@ -0,0 +1,30 @@
+import type { ToolCall } from "../schemas/tool-call.js";
+/**
+ * Display state for tool calls
+ * Maps to the UI presentation state
+ */
+export type ToolCallDisplayState = "selecting" | "executing" | "completed" | "failed";
+/**
+ * Determine if a tool call is preliminary (not yet fully invoked)
+ */
+export declare function isPreliminaryToolCall(toolCall: ToolCall): boolean;
+/**
+ * Get the display state for a tool call
+ */
+export declare function getToolCallDisplayState(toolCall: ToolCall): ToolCallDisplayState;
+/**
+ * Get verbiage based on display state
+ */
+export declare function getToolCallStateVerbiage(toolCall: ToolCall): string;
+/**
+ * Check if a group of tool calls are all completed
+ */
+export declare function areAllToolCallsCompleted(toolCalls: ToolCall[]): boolean;
+/**
+ * Check if any tool call in a group has failed
+ */
+export declare function hasAnyToolCallFailed(toolCalls: ToolCall[]): boolean;
+/**
+ * Get the overall state for a group of tool calls
+ */
+export declare function getGroupDisplayState(toolCalls: ToolCall[]): ToolCallDisplayState;

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

@@ -0,0 +1,73 @@
+import { getToolCallVerbiage } from "./tool-verbiage.js";
+/**
+ * Determine if a tool call is preliminary (not yet fully invoked)
+ */
+export function isPreliminaryToolCall(toolCall) {
+    return (toolCall.status === "pending" &&
+        (!toolCall.rawInput || Object.keys(toolCall.rawInput).length === 0));
+}
+/**
+ * Get the display state for a tool call
+ */
+export function getToolCallDisplayState(toolCall) {
+    // Failed state
+    if (toolCall.status === "failed" || toolCall.error) {
+        return "failed";
+    }
+    // Completed state
+    if (toolCall.status === "completed") {
+        return "completed";
+    }
+    // Selecting state (preliminary - no parameters yet)
+    if (isPreliminaryToolCall(toolCall)) {
+        return "selecting";
+    }
+    // Executing state (pending or in_progress with parameters)
+    if (toolCall.status === "pending" || toolCall.status === "in_progress") {
+        return "executing";
+    }
+    // Default to executing
+    return "executing";
+}
+/**
+ * Get verbiage based on display state
+ */
+export function getToolCallStateVerbiage(toolCall) {
+    const displayState = getToolCallDisplayState(toolCall);
+    switch (displayState) {
+        case "selecting":
+            return `Selecting ${toolCall.prettyName || toolCall.title}`;
+        case "executing":
+            return getToolCallVerbiage(toolCall, "active");
+        case "completed":
+            return getToolCallVerbiage(toolCall, "past");
+        case "failed":
+            return `Failed to use ${toolCall.prettyName || toolCall.title}`;
+        default:
+            return toolCall.prettyName || toolCall.title;
+    }
+}
+/**
+ * Check if a group of tool calls are all completed
+ */
+export function areAllToolCallsCompleted(toolCalls) {
+    return toolCalls.every((tc) => getToolCallDisplayState(tc) === "completed");
+}
+/**
+ * Check if any tool call in a group has failed
+ */
+export function hasAnyToolCallFailed(toolCalls) {
+    return toolCalls.some((tc) => getToolCallDisplayState(tc) === "failed");
+}
+/**
+ * Get the overall state for a group of tool calls
+ */
+export function getGroupDisplayState(toolCalls) {
+    if (hasAnyToolCallFailed(toolCalls))
+        return "failed";
+    if (areAllToolCallsCompleted(toolCalls))
+        return "completed";
+    if (toolCalls.every((tc) => isPreliminaryToolCall(tc)))
+        return "selecting";
+    return "executing";
+}

package/dist/core/utils/tool-summary.d.ts

@@ -0,0 +1,13 @@
+import type { ToolCall } from "../schemas/tool-call.js";
+/**
+ * Generate a smart summary for a group of parallel tool calls
+ */
+export declare function generateSmartSummary(toolCalls: ToolCall[], tense: "active" | "past"): string;
+/**
+ * Get a short summary for display in collapsed state
+ */
+export declare function getCollapsedSummary(toolCalls: ToolCall[]): string;
+/**
+ * Get a summary for display in expanded/active state
+ */
+export declare function getActiveSummary(toolCalls: ToolCall[]): string;

package/dist/core/utils/tool-summary.js

@@ -0,0 +1,172 @@
+import { getToolCallVerbiage, getToolDisplayName } from "./tool-verbiage.js";
+/**
+ * Extract a readable parameter value for summarization
+ */
+function extractKeyParameter(toolCall) {
+    if (!toolCall.rawInput)
+        return null;
+    // Common parameter names to check, in order of preference
+    const paramKeys = [
+        "query",
+        "search_term",
+        "pattern",
+        "target_file",
+        "file_path",
+        "command",
+        "target_directory",
+    ];
+    for (const key of paramKeys) {
+        const value = toolCall.rawInput[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    // Check subline as fallback
+    if (toolCall.subline) {
+        return toolCall.subline;
+    }
+    return null;
+}
+/**
+ * Truncate a list of items with "and N more" suffix
+ */
+function formatItemList(items, maxItems = 3) {
+    if (items.length === 0)
+        return "";
+    if (items.length === 1)
+        return items[0];
+    if (items.length <= maxItems) {
+        return items.slice(0, -1).join(", ") + " and " + items[items.length - 1];
+    }
+    const shown = items.slice(0, maxItems);
+    const remaining = items.length - maxItems;
+    return shown.join(", ") + ` and ${remaining} more`;
+}
+/**
+ * Detect common patterns in file paths
+ */
+function detectFilePattern(paths) {
+    if (paths.length === 0)
+        return null;
+    // Extract directory from first path
+    const firstPath = paths[0];
+    const lastSlash = firstPath.lastIndexOf("/");
+    if (lastSlash === -1)
+        return null;
+    const directory = firstPath.substring(0, lastSlash);
+    // Check if all paths are in the same directory
+    const allInSameDir = paths.every((p) => p.startsWith(directory + "/"));
+    if (allInSameDir) {
+        return directory;
+    }
+    return null;
+}
+/**
+ * Generate a smart summary for multiple tool calls of the same type
+ */
+function generateSameToolSummary(toolCalls, tense) {
+    if (toolCalls.length === 0)
+        return "";
+    if (toolCalls.length === 1) {
+        return getToolCallVerbiage(toolCalls[0], tense);
+    }
+    const firstTool = toolCalls[0];
+    const toolName = firstTool.title;
+    // Extract parameters from all tool calls
+    const parameters = toolCalls
+        .map(extractKeyParameter)
+        .filter((p) => p !== null);
+    // Special handling for file operations
+    // Support both Town SDK tool names and legacy/Cursor tool names
+    const isFileOperation = toolName === "Read" ||
+        toolName === "Write" ||
+        toolName === "read_file" ||
+        toolName === "write" ||
+        toolName === "search_replace" ||
+        toolName === "delete_file";
+    if (isFileOperation) {
+        if (parameters.length > 0) {
+            const directory = detectFilePattern(parameters);
+            if (directory) {
+                const verb = tense === "active" ? "working on" : "worked on";
+                return `${verb.charAt(0).toUpperCase() + verb.slice(1)} ${parameters.length} files in ${directory}`;
+            }
+            const verb = toolName === "Read" || toolName === "read_file"
+                ? tense === "active"
+                    ? "Reading"
+                    : "Read"
+                : toolName === "Write" || toolName === "write"
+                    ? tense === "active"
+                        ? "Writing"
+                        : "Wrote"
+                    : toolName === "search_replace"
+                        ? tense === "active"
+                            ? "Editing"
+                            : "Edited"
+                        : tense === "active"
+                            ? "Deleting"
+                            : "Deleted";
+            return `${verb} ${formatItemList(parameters)}`;
+        }
+    }
+    // Special handling for search operations
+    // Support both Town SDK tool names and legacy/Cursor tool names
+    const isSearchOperation = toolName === "WebSearch" ||
+        toolName === "Grep" ||
+        toolName === "web_search" ||
+        toolName === "codebase_search" ||
+        toolName === "grep";
+    if (isSearchOperation) {
+        if (parameters.length > 0) {
+            const verb = toolName === "WebSearch" || toolName === "web_search"
+                ? tense === "active"
+                    ? "Searching the web for"
+                    : "Searched the web for"
+                : toolName === "codebase_search"
+                    ? tense === "active"
+                        ? "Searching codebase for"
+                        : "Searched codebase for"
+                    : tense === "active"
+                        ? "Searching for"
+                        : "Searched for";
+            return `${verb} ${formatItemList(parameters)}`;
+        }
+    }
+    // Generic fallback: use tool display name
+    const displayName = getToolDisplayName(firstTool);
+    const verb = tense === "active" ? "Using" : "Used";
+    return `${verb} ${displayName} ${toolCalls.length} times`;
+}
+/**
+ * Generate a smart summary for a group of parallel tool calls
+ */
+export function generateSmartSummary(toolCalls, tense) {
+    if (toolCalls.length === 0)
+        return "";
+    if (toolCalls.length === 1) {
+        return getToolCallVerbiage(toolCalls[0], tense);
+    }
+    // Check if all tool calls are of the same type
+    const toolNames = [...new Set(toolCalls.map((tc) => tc.title))];
+    if (toolNames.length === 1) {
+        return generateSameToolSummary(toolCalls, tense);
+    }
+    // Mixed tool types - show display names
+    const displayNames = toolCalls
+        .map((tc) => tc.prettyName || tc.title)
+        .filter((name, index, self) => self.indexOf(name) === index);
+    const verb = tense === "active" ? "Running" : "Ran";
+    return `${verb} ${formatItemList(displayNames)}`;
+}
+/**
+ * Get a short summary for display in collapsed state
+ */
+export function getCollapsedSummary(toolCalls) {
+    return generateSmartSummary(toolCalls, "past");
+}
+/**
+ * Get a summary for display in expanded/active state
+ */
+export function getActiveSummary(toolCalls) {
+    return generateSmartSummary(toolCalls, "active");
+}

package/dist/core/utils/tool-verbiage.d.ts

@@ -0,0 +1,28 @@
+import type { ToolCall } from "../schemas/tool-call.js";
+/**
+ * Tool-specific verbiage templates
+ * Format: {paramName} will be replaced with actual parameter values
+ */
+export interface ToolVerbiageTemplate {
+    active: string;
+    past: string;
+    paramKey?: string;
+}
+/**
+ * Mapping of tool names to their verbiage templates
+ *
+ * NOTE: Built-in Town SDK tools now include verbiage metadata in their definitions.
+ * This map is kept as a fallback for:
+ * - Legacy/external tools (e.g., Cursor IDE tools)
+ * - Custom tools without verbiage metadata
+ * - Backward compatibility
+ */
+export declare const TOOL_VERBIAGE_MAP: Record<string, ToolVerbiageTemplate>;
+/**
+ * Get display verbiage for a tool call
+ */
+export declare function getToolCallVerbiage(toolCall: ToolCall, tense: "active" | "past"): string;
+/**
+ * Get a short display name for a tool (for grouping)
+ */
+export declare function getToolDisplayName(toolCall: ToolCall): string;