@townco/ui 0.1.14 → 0.1.16

package/dist/core/schemas/chat.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ToolCallSchema } from "./tool-call.js";
 /**
  * Chat UI state schemas
  */
@@ -6,46 +7,45 @@ import { z } from "zod";
  * Display message schema (UI representation of messages)
  */
 export const DisplayMessage = z.object({
-	id: z.string(),
-	role: z.enum(["user", "assistant", "system"]),
-	content: z.string(),
-	timestamp: z.iso.datetime(),
-	isStreaming: z.boolean().default(false),
-	streamingStartTime: z.number().optional(), // Unix timestamp when streaming started
-	metadata: z.record(z.string(), z.unknown()).optional(),
+    id: z.string(),
+    role: z.enum(["user", "assistant", "system"]),
+    content: z.string(),
+    timestamp: z.iso.datetime(),
+    isStreaming: z.boolean().default(false),
+    streamingStartTime: z.number().optional(), // Unix timestamp when streaming started
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    toolCalls: z.array(ToolCallSchema).optional(),
 });
 /**
  * Input state schema
  */
 export const InputState = z.object({
-	value: z.string(),
-	isSubmitting: z.boolean(),
-	attachedFiles: z.array(
-		z.object({
-			name: z.string(),
-			path: z.string(),
-			size: z.number(),
-			mimeType: z.string(),
-		}),
-	),
+    value: z.string(),
+    isSubmitting: z.boolean(),
+    attachedFiles: z.array(z.object({
+        name: z.string(),
+        path: z.string(),
+        size: z.number(),
+        mimeType: z.string(),
+    })),
 });
 /**
  * Chat session UI state
  */
 export const ChatSessionState = z.object({
-	sessionId: z.string().nullable(),
-	isConnected: z.boolean(),
-	isStreaming: z.boolean(),
-	messages: z.array(DisplayMessage),
-	input: InputState,
-	error: z.string().nullable(),
+    sessionId: z.string().nullable(),
+    isConnected: z.boolean(),
+    isStreaming: z.boolean(),
+    messages: z.array(DisplayMessage),
+    input: InputState,
+    error: z.string().nullable(),
 });
 /**
  * Connection status
  */
 export const ConnectionStatus = z.enum([
-	"disconnected",
-	"connecting",
-	"connected",
-	"error",
+    "disconnected",
+    "connecting",
+    "connected",
+    "error",
 ]);

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

@@ -2,3 +2,4 @@
  * Export all core schemas
  */
 export * from "./chat.js";
+export * from "./tool-call.js";

package/dist/core/schemas/index.js

@@ -2,3 +2,4 @@
  * Export all core schemas
  */
 export * from "./chat.js";
+export * from "./tool-call.js";

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

@@ -0,0 +1,174 @@
+import { z } from "zod";
+/**
+ * Tool call status lifecycle
+ */
+export declare const ToolCallStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    in_progress: "in_progress";
+    completed: "completed";
+    failed: "failed";
+}>;
+export type ToolCallStatus = z.infer<typeof ToolCallStatusSchema>;
+/**
+ * Tool call categories for UI presentation
+ */
+export declare const ToolCallKindSchema: z.ZodEnum<{
+    read: "read";
+    edit: "edit";
+    delete: "delete";
+    move: "move";
+    search: "search";
+    execute: "execute";
+    think: "think";
+    fetch: "fetch";
+    switch_mode: "switch_mode";
+    other: "other";
+}>;
+export type ToolCallKind = z.infer<typeof ToolCallKindSchema>;
+/**
+ * File location with optional line number
+ */
+export declare const FileLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type FileLocation = z.infer<typeof FileLocationSchema>;
+/**
+ * Token usage metadata for tracking LLM consumption
+ */
+export declare const TokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TokenUsage = z.infer<typeof TokenUsageSchema>;
+/**
+ * Content block types for tool call results
+ */
+export declare const ToolCallContentBlockSchema: 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<"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">;
+export type ToolCallContentBlock = z.infer<typeof ToolCallContentBlockSchema>;
+/**
+ * Complete tool call state as displayed in the UI
+ */
+export declare const ToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        read: "read";
+        edit: "edit";
+        delete: "delete";
+        move: "move";
+        search: "search";
+        execute: "execute";
+        think: "think";
+        fetch: "fetch";
+        switch_mode: "switch_mode";
+        other: "other";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    rawInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    rawOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    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<"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">>>;
+    error: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ToolCall = z.infer<typeof ToolCallSchema>;
+/**
+ * Partial update for an existing tool call
+ */
+export declare const ToolCallUpdateSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        failed: "failed";
+    }>>;
+    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    rawOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    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<"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">>>;
+    error: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ToolCallUpdate = z.infer<typeof ToolCallUpdateSchema>;
+/**
+ * Helper to merge a tool call update into an existing tool call
+ */
+export declare function mergeToolCallUpdate(existing: ToolCall, update: ToolCallUpdate): ToolCall;

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

@@ -0,0 +1,130 @@
+import { z } from "zod";
+/**
+ * Tool call status lifecycle
+ */
+export const ToolCallStatusSchema = z.enum([
+    "pending",
+    "in_progress",
+    "completed",
+    "failed",
+]);
+/**
+ * Tool call categories for UI presentation
+ */
+export const ToolCallKindSchema = z.enum([
+    "read",
+    "edit",
+    "delete",
+    "move",
+    "search",
+    "execute",
+    "think",
+    "fetch",
+    "switch_mode",
+    "other",
+]);
+/**
+ * File location with optional line number
+ */
+export const FileLocationSchema = z.object({
+    path: z.string(),
+    line: z.number().nullable().optional(),
+});
+/**
+ * Token usage metadata for tracking LLM consumption
+ */
+export const TokenUsageSchema = z.object({
+    inputTokens: z.number().optional(),
+    outputTokens: z.number().optional(),
+    totalTokens: z.number().optional(),
+});
+/**
+ * Content block types for tool call results
+ */
+export const ToolCallContentBlockSchema = z.discriminatedUnion("type", [
+    // ACP nested content format
+    z.object({
+        type: z.literal("content"),
+        content: z.object({
+            type: z.literal("text"),
+            text: z.string(),
+        }),
+    }),
+    // Direct text block (legacy)
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("diff"),
+        path: z.string(),
+        oldText: z.string(),
+        newText: z.string(),
+        line: z.number().nullable().optional(),
+    }),
+    z.object({
+        type: z.literal("terminal"),
+        terminalId: z.string(),
+    }),
+]);
+/**
+ * Complete tool call state as displayed in the UI
+ */
+export const ToolCallSchema = z.object({
+    /** Unique identifier within the session */
+    id: z.string(),
+    /** Human-readable description of the operation */
+    title: z.string(),
+    /** Category for UI presentation */
+    kind: ToolCallKindSchema,
+    /** Current execution status */
+    status: ToolCallStatusSchema,
+    /** Affected file paths with optional line numbers */
+    locations: z.array(FileLocationSchema).optional(),
+    /** Raw parameters passed to the tool */
+    rawInput: z.record(z.string(), z.unknown()).optional(),
+    /** Raw response from the tool */
+    rawOutput: z.record(z.string(), z.unknown()).optional(),
+    /** Produced results (content blocks, diffs, terminal output) */
+    content: z.array(ToolCallContentBlockSchema).optional(),
+    /** Error message if status is 'failed' */
+    error: z.string().optional(),
+    /** Timestamp when the tool call started */
+    startedAt: z.number().optional(),
+    /** Timestamp when the tool call completed/failed */
+    completedAt: z.number().optional(),
+    /** Token usage metadata for this tool call */
+    tokenUsage: TokenUsageSchema.optional(),
+});
+/**
+ * Partial update for an existing tool call
+ */
+export const ToolCallUpdateSchema = z.object({
+    id: z.string(),
+    status: ToolCallStatusSchema.optional(),
+    locations: z.array(FileLocationSchema).optional(),
+    rawOutput: z.record(z.string(), z.unknown()).optional(),
+    content: z.array(ToolCallContentBlockSchema).optional(),
+    error: z.string().optional(),
+    completedAt: z.number().optional(),
+    tokenUsage: TokenUsageSchema.optional(),
+});
+/**
+ * Helper to merge a tool call update into an existing tool call
+ */
+export function mergeToolCallUpdate(existing, update) {
+    const merged = {
+        ...existing,
+        // Only update fields that are defined in the update
+        status: update.status ?? existing.status,
+        locations: update.locations ?? existing.locations,
+        rawOutput: update.rawOutput ?? existing.rawOutput,
+        content: update.content
+            ? [...(existing.content ?? []), ...update.content]
+            : existing.content,
+        error: update.error ?? existing.error,
+        completedAt: update.completedAt ?? existing.completedAt,
+        tokenUsage: update.tokenUsage ?? existing.tokenUsage,
+    };
+    return merged;
+}

package/dist/core/store/chat-store.d.ts

@@ -1,36 +1,36 @@
-import type {
-	ConnectionStatus,
-	DisplayMessage,
-	InputState,
-} from "../schemas/index.js";
+import type { ConnectionStatus, DisplayMessage, InputState } from "../schemas/index.js";
+import type { ToolCall, ToolCallUpdate } from "../schemas/tool-call.js";
 /**
  * Chat store state
  */
 export interface ChatStore {
-	connectionStatus: ConnectionStatus;
-	sessionId: string | null;
-	error: string | null;
-	messages: DisplayMessage[];
-	isStreaming: boolean;
-	streamingStartTime: number | null;
-	input: InputState;
-	setConnectionStatus: (status: ConnectionStatus) => void;
-	setSessionId: (id: string | null) => void;
-	setError: (error: string | null) => void;
-	addMessage: (message: DisplayMessage) => void;
-	updateMessage: (id: string, updates: Partial<DisplayMessage>) => void;
-	clearMessages: () => void;
-	setIsStreaming: (streaming: boolean) => void;
-	setStreamingStartTime: (time: number | null) => void;
-	setInputValue: (value: string) => void;
-	setInputSubmitting: (submitting: boolean) => void;
-	addFileAttachment: (file: InputState["attachedFiles"][number]) => void;
-	removeFileAttachment: (index: number) => void;
-	clearInput: () => void;
+    connectionStatus: ConnectionStatus;
+    sessionId: string | null;
+    error: string | null;
+    messages: DisplayMessage[];
+    isStreaming: boolean;
+    streamingStartTime: number | null;
+    toolCalls: Record<string, ToolCall[]>;
+    input: InputState;
+    setConnectionStatus: (status: ConnectionStatus) => void;
+    setSessionId: (id: string | null) => void;
+    setError: (error: string | null) => void;
+    addMessage: (message: DisplayMessage) => void;
+    updateMessage: (id: string, updates: Partial<DisplayMessage>) => void;
+    clearMessages: () => void;
+    setIsStreaming: (streaming: boolean) => void;
+    setStreamingStartTime: (time: number | null) => void;
+    addToolCall: (sessionId: string, toolCall: ToolCall) => void;
+    updateToolCall: (sessionId: string, update: ToolCallUpdate) => void;
+    addToolCallToCurrentMessage: (toolCall: ToolCall) => void;
+    updateToolCallInCurrentMessage: (update: ToolCallUpdate) => void;
+    setInputValue: (value: string) => void;
+    setInputSubmitting: (submitting: boolean) => void;
+    addFileAttachment: (file: InputState["attachedFiles"][number]) => void;
+    removeFileAttachment: (index: number) => void;
+    clearInput: () => void;
 }
 /**
  * Create chat store
  */
-export declare const useChatStore: import("zustand").UseBoundStore<
-	import("zustand").StoreApi<ChatStore>
->;
+export declare const useChatStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ChatStore>>;

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

@@ -1,65 +1,129 @@
 import { create } from "zustand";
+import { mergeToolCallUpdate } from "../schemas/tool-call.js";
 /**
  * Create chat store
  */
 export const useChatStore = create((set) => ({
-	// Initial state
-	connectionStatus: "disconnected",
-	sessionId: null,
-	error: null,
-	messages: [],
-	isStreaming: false,
-	streamingStartTime: null,
-	input: {
-		value: "",
-		isSubmitting: false,
-		attachedFiles: [],
-	},
-	// Actions
-	setConnectionStatus: (status) => set({ connectionStatus: status }),
-	setSessionId: (id) => set({ sessionId: id }),
-	setError: (error) => set({ error }),
-	addMessage: (message) =>
-		set((state) => ({
-			messages: [...state.messages, message],
-		})),
-	updateMessage: (id, updates) =>
-		set((state) => ({
-			messages: state.messages.map((msg) =>
-				msg.id === id ? { ...msg, ...updates } : msg,
-			),
-		})),
-	clearMessages: () => set({ messages: [] }),
-	setIsStreaming: (streaming) => set({ isStreaming: streaming }),
-	setStreamingStartTime: (time) => set({ streamingStartTime: time }),
-	setInputValue: (value) =>
-		set((state) => ({
-			input: { ...state.input, value },
-		})),
-	setInputSubmitting: (submitting) =>
-		set((state) => ({
-			input: { ...state.input, isSubmitting: submitting },
-		})),
-	addFileAttachment: (file) =>
-		set((state) => ({
-			input: {
-				...state.input,
-				attachedFiles: [...state.input.attachedFiles, file],
-			},
-		})),
-	removeFileAttachment: (index) =>
-		set((state) => ({
-			input: {
-				...state.input,
-				attachedFiles: state.input.attachedFiles.filter((_, i) => i !== index),
-			},
-		})),
-	clearInput: () =>
-		set((_state) => ({
-			input: {
-				value: "",
-				isSubmitting: false,
-				attachedFiles: [],
-			},
-		})),
+    // Initial state
+    connectionStatus: "disconnected",
+    sessionId: null,
+    error: null,
+    messages: [],
+    isStreaming: false,
+    streamingStartTime: null,
+    toolCalls: {},
+    input: {
+        value: "",
+        isSubmitting: false,
+        attachedFiles: [],
+    },
+    // Actions
+    setConnectionStatus: (status) => set({ connectionStatus: status }),
+    setSessionId: (id) => set({ sessionId: id }),
+    setError: (error) => set({ error }),
+    addMessage: (message) => set((state) => ({
+        messages: [...state.messages, message],
+    })),
+    updateMessage: (id, updates) => set((state) => ({
+        messages: state.messages.map((msg) => msg.id === id ? { ...msg, ...updates } : msg),
+    })),
+    clearMessages: () => set({ messages: [] }),
+    setIsStreaming: (streaming) => set({ isStreaming: streaming }),
+    setStreamingStartTime: (time) => set({ streamingStartTime: time }),
+    addToolCall: (sessionId, toolCall) => set((state) => ({
+        toolCalls: {
+            ...state.toolCalls,
+            [sessionId]: [...(state.toolCalls[sessionId] || []), toolCall],
+        },
+    })),
+    addToolCallToCurrentMessage: (toolCall) => set((state) => {
+        // Find the most recent assistant message (which should be streaming)
+        const lastAssistantIndex = state.messages.findLastIndex((msg) => msg.role === "assistant");
+        if (lastAssistantIndex === -1) {
+            console.warn("No assistant message found to add tool call to");
+            return state;
+        }
+        const messages = [...state.messages];
+        const lastAssistantMsg = messages[lastAssistantIndex];
+        if (!lastAssistantMsg)
+            return state;
+        messages[lastAssistantIndex] = {
+            ...lastAssistantMsg,
+            toolCalls: [...(lastAssistantMsg.toolCalls || []), toolCall],
+        };
+        return { messages };
+    }),
+    updateToolCallInCurrentMessage: (update) => set((state) => {
+        // Find the most recent assistant message
+        const lastAssistantIndex = state.messages.findLastIndex((msg) => msg.role === "assistant");
+        if (lastAssistantIndex === -1) {
+            console.warn("No assistant message found to update tool call in");
+            return state;
+        }
+        const messages = [...state.messages];
+        const lastAssistantMsg = messages[lastAssistantIndex];
+        if (!lastAssistantMsg)
+            return state;
+        const toolCalls = lastAssistantMsg.toolCalls || [];
+        const existingIndex = toolCalls.findIndex((tc) => tc.id === update.id);
+        if (existingIndex === -1) {
+            console.warn(`Tool call ${update.id} not found in message`);
+            return state;
+        }
+        const existing = toolCalls[existingIndex];
+        if (!existing)
+            return state;
+        const updatedToolCalls = [...toolCalls];
+        updatedToolCalls[existingIndex] = mergeToolCallUpdate(existing, update);
+        messages[lastAssistantIndex] = {
+            ...lastAssistantMsg,
+            toolCalls: updatedToolCalls,
+        };
+        return { messages };
+    }),
+    updateToolCall: (sessionId, update) => set((state) => {
+        const sessionToolCalls = state.toolCalls[sessionId] || [];
+        const existingIndex = sessionToolCalls.findIndex((tc) => tc.id === update.id);
+        if (existingIndex === -1) {
+            // Tool call not found, ignore update
+            return state;
+        }
+        const existing = sessionToolCalls[existingIndex];
+        if (!existing) {
+            return state;
+        }
+        const updatedToolCalls = [...sessionToolCalls];
+        updatedToolCalls[existingIndex] = mergeToolCallUpdate(existing, update);
+        return {
+            toolCalls: {
+                ...state.toolCalls,
+                [sessionId]: updatedToolCalls,
+            },
+        };
+    }),
+    setInputValue: (value) => set((state) => ({
+        input: { ...state.input, value },
+    })),
+    setInputSubmitting: (submitting) => set((state) => ({
+        input: { ...state.input, isSubmitting: submitting },
+    })),
+    addFileAttachment: (file) => set((state) => ({
+        input: {
+            ...state.input,
+            attachedFiles: [...state.input.attachedFiles, file],
+        },
+    })),
+    removeFileAttachment: (index) => set((state) => ({
+        input: {
+            ...state.input,
+            attachedFiles: state.input.attachedFiles.filter((_, i) => i !== index),
+        },
+    })),
+    clearInput: () => set((_state) => ({
+        input: {
+            value: "",
+            isSubmitting: false,
+            attachedFiles: [],
+        },
+    })),
 }));