@townco/ui 0.1.83 → 0.1.93

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

@@ -23,22 +23,29 @@ export function useChatInput(client, startSession) {
      * Handle input submission
      */
     const handleSubmit = useCallback(async () => {
-        if (!input.value.trim() || input.isSubmitting) {
+        // Read fresh state directly from store to avoid stale closure issues
+        const currentInput = useChatStore.getState().input;
+        if (!currentInput.value.trim() || currentInput.isSubmitting) {
             return;
         }
-        const message = input.value;
-        const attachments = input.attachedFiles;
+        const message = currentInput.value;
+        const attachments = currentInput.attachedFiles;
+        const promptParameters = currentInput.selectedPromptParameters;
         logger.debug("Submitting message with attachments", {
             messageLength: message.length,
             attachmentCount: attachments.length,
             hasAttachments: attachments.length > 0,
+            hasPromptParameters: !!promptParameters && Object.keys(promptParameters).length > 0,
+            promptParameters,
         });
         // Clear input immediately for better UX
         setInputValue("");
         setInputSubmitting(true);
         try {
-            await sendMessage(message, attachments.length > 0 ? attachments : undefined);
-            // Clear attachments after successful send
+            await sendMessage(message, attachments.length > 0 ? attachments : undefined, promptParameters && Object.keys(promptParameters).length > 0
+                ? promptParameters
+                : undefined);
+            // Clear attachments after successful send (keep promptParameters for next message)
             useChatStore.setState((state) => ({
                 input: { ...state.input, attachedFiles: [] },
             }));
@@ -52,7 +59,7 @@ export function useChatInput(client, startSession) {
         finally {
             setInputSubmitting(false);
         }
-    }, [input, setInputValue, setInputSubmitting, sendMessage]);
+    }, [setInputValue, setInputSubmitting, sendMessage]);
     /**
      * Handle file attachment
      */

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

@@ -194,6 +194,15 @@ export declare function useChatMessages(client: AcpClient | null, startSession:
             mimeType: string;
             data: string;
         }[] | undefined;
+        sources?: {
+            id: string;
+            url: string;
+            title: string;
+            snippet?: string | undefined;
+            favicon?: string | undefined;
+            toolCallId: string;
+            sourceName?: string | undefined;
+        }[] | undefined;
     }[];
     isStreaming: boolean;
     sendMessage: (content: string, attachments?: {
@@ -202,5 +211,13 @@ export declare function useChatMessages(client: AcpClient | null, startSession:
         size: number;
         mimeType: string;
         data: string;
+    }[] | undefined, promptParameters?: Record<string, string> | undefined) => Promise<void>;
+    editAndResend: (userMessageIndex: number, newContent: string, attachments?: {
+        name: string;
+        path: string;
+        size: number;
+        mimeType: string;
+        data: string;
     }[] | undefined) => Promise<void>;
+    cancel: () => Promise<void>;
 };

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

@@ -1,5 +1,5 @@
 import { createLogger } from "@townco/core";
-import { useCallback } from "react";
+import { useCallback, useRef } from "react";
 import { useChatStore } from "../store/chat-store.js";
 const logger = createLogger("use-chat-messages", "debug");
 /**
@@ -20,14 +20,25 @@ export function useChatMessages(client, startSession) {
     const addToolCallToCurrentMessage = useChatStore((state) => state.addToolCallToCurrentMessage);
     const updateToolCallInCurrentMessage = useChatStore((state) => state.updateToolCallInCurrentMessage);
     const addHookNotificationToCurrentMessage = useChatStore((state) => state.addHookNotificationToCurrentMessage);
+    const addSourcesToCurrentMessage = useChatStore((state) => state.addSourcesToCurrentMessage);
+    const truncateMessagesFrom = useChatStore((state) => state.truncateMessagesFrom);
+    // Track the current assistant message ID for cancellation
+    const currentAssistantMessageIdRef = useRef(null);
+    // Track if current turn was cancelled
+    const wasCancelledRef = useRef(false);
     /**
      * Send a message to the agent
+     * @param content - The message text content
+     * @param attachments - Optional image attachments
+     * @param promptParameters - Optional per-message parameters to influence agent behavior
      */
-    const sendMessage = useCallback(async (content, attachments) => {
+    const sendMessage = useCallback(async (content, attachments, promptParameters) => {
         logger.debug("[sendMessage] Called with", {
             contentLength: content.length,
             attachmentsCount: attachments?.length || 0,
             hasAttachments: !!attachments && attachments.length > 0,
+            hasPromptParameters: !!promptParameters,
+            promptParameters: promptParameters,
         });
         if (!client) {
             logger.error("No client available");
@@ -83,12 +94,16 @@ export function useChatMessages(client, startSession) {
                 streamingStartTime: startTime, // Use the same start time from when user sent message
             };
             addMessage(assistantMessage);
+            // Store the assistant message ID for potential cancellation
+            currentAssistantMessageIdRef.current = assistantMessageId;
+            // Reset cancellation flag for new message
+            wasCancelledRef.current = false;
             // Start receiving chunks (async iterator)
             const messageStream = client.receiveMessages();
             // Send ONLY the new message (not full history)
             // The agent backend now manages conversation context
             client
-                .sendMessage(content, activeSessionId, attachments)
+                .sendMessage(content, activeSessionId, attachments, promptParameters)
                 .catch((error) => {
                 const message = error instanceof Error ? error.message : String(error);
                 setError(message);
@@ -99,6 +114,11 @@ export function useChatMessages(client, startSession) {
             let accumulatedContent = "";
             let streamCompleted = false;
             for await (const chunk of messageStream) {
+                // Check if cancelled before processing each chunk
+                if (wasCancelledRef.current) {
+                    logger.info("Stream cancelled, exiting loop");
+                    break;
+                }
                 // Handle different chunk types using discriminated union
                 if (chunk.type === "content") {
                     // Content chunk - text streaming
@@ -139,6 +159,7 @@ export function useChatMessages(client, startSession) {
                         });
                         setIsStreaming(false);
                         setStreamingStartTime(null); // Clear global streaming start time
+                        currentAssistantMessageIdRef.current = null; // Clear cancellation ref
                         streamCompleted = true;
                         break;
                     }
@@ -150,8 +171,11 @@ export function useChatMessages(client, startSession) {
                                 content: accumulatedContent,
                                 ...(chunk.tokenUsage ? { tokenUsage: chunk.tokenUsage } : {}),
                             });
-                            // Small delay to allow Ink to render between chunks (~60fps)
-                            await new Promise((resolve) => setTimeout(resolve, 16));
+                            // Small delay to allow rendering between chunks (~60fps)
+                            // Skip delay when tab is hidden to prevent browser throttling from blocking the stream
+                            if (!document.hidden) {
+                                await new Promise((resolve) => setTimeout(resolve, 16));
+                            }
                         }
                     }
                 }
@@ -177,16 +201,34 @@ export function useChatMessages(client, startSession) {
                     // Add/update hook notification in current assistant message
                     addHookNotificationToCurrentMessage(chunk.notification);
                 }
+                else if (chunk.type === "sources") {
+                    // Sources chunk - citation sources from tool calls
+                    logger.debug("Received sources chunk", { chunk });
+                    // Add sources to current assistant message for citation rendering
+                    addSourcesToCurrentMessage(chunk.sources);
+                }
             }
             // Ensure streaming state is cleared even if no explicit isComplete was received
             if (!streamCompleted) {
-                logger.warn("Stream ended without isComplete flag");
-                updateMessage(assistantMessageId, {
-                    isStreaming: false,
-                    streamingStartTime: undefined,
-                });
+                if (wasCancelledRef.current) {
+                    // User cancelled - append "[Cancelled]" indicator
+                    logger.info("Stream cancelled by user");
+                    updateMessage(assistantMessageId, {
+                        content: `${accumulatedContent}\n\n[Cancelled]`,
+                        isStreaming: false,
+                        streamingStartTime: undefined,
+                    });
+                }
+                else {
+                    logger.warn("Stream ended without isComplete flag");
+                    updateMessage(assistantMessageId, {
+                        isStreaming: false,
+                        streamingStartTime: undefined,
+                    });
+                }
                 setIsStreaming(false);
                 setStreamingStartTime(null);
+                currentAssistantMessageIdRef.current = null;
             }
         }
         catch (error) {
@@ -194,6 +236,7 @@ export function useChatMessages(client, startSession) {
             setError(message);
             setIsStreaming(false);
             setStreamingStartTime(null); // Clear streaming start time on error
+            currentAssistantMessageIdRef.current = null;
             // Ensure the assistant message isStreaming is set to false
             updateMessage(assistantMessageId, {
                 isStreaming: false,
@@ -215,10 +258,251 @@ export function useChatMessages(client, startSession) {
         addToolCallToCurrentMessage,
         updateToolCallInCurrentMessage,
         addHookNotificationToCurrentMessage,
+        addSourcesToCurrentMessage,
+    ]);
+    /**
+     * Cancel the current agent turn
+     * Stops streaming and appends "[Cancelled]" to the message
+     */
+    const cancel = useCallback(async () => {
+        if (!client || !isStreaming) {
+            logger.debug("Cannot cancel: not streaming or no client");
+            return;
+        }
+        logger.info("Cancelling current turn");
+        // Set cancelled flag FIRST - the stream loop will check this
+        wasCancelledRef.current = true;
+        try {
+            // Call client cancel to stop the agent
+            await client.cancel(sessionId || undefined);
+        }
+        catch (error) {
+            logger.error("Error cancelling turn", { error });
+        }
+        // Note: The stream loop will handle updating the message with "[Cancelled]"
+        // and clearing the streaming state when it exits
+    }, [client, isStreaming, sessionId]);
+    /**
+     * Edit and resend a message from a specific point in the conversation.
+     * Truncates the conversation to the specified message and sends the new content.
+     *
+     * @param messageIndex - The index of the user message to edit (in UI messages array)
+     * @param newContent - The new text content
+     * @param attachments - Optional image attachments
+     */
+    const editAndResend = useCallback(async (userMessageIndex, newContent, attachments) => {
+        logger.debug("[editAndResend] Called with", {
+            userMessageIndex,
+            contentLength: newContent.length,
+            attachmentsCount: attachments?.length || 0,
+        });
+        if (!client) {
+            logger.error("No client available");
+            setError("No client available");
+            return;
+        }
+        if (!sessionId) {
+            logger.error("No session available");
+            setError("No session available");
+            return;
+        }
+        // Find the Nth user message (0-indexed) in the UI messages array
+        let userMessageCount = 0;
+        let targetArrayIndex = -1;
+        for (let i = 0; i < messages.length; i++) {
+            if (messages[i]?.role === "user") {
+                if (userMessageCount === userMessageIndex) {
+                    targetArrayIndex = i;
+                    break;
+                }
+                userMessageCount++;
+            }
+        }
+        if (targetArrayIndex === -1) {
+            logger.error("User message not found", {
+                userMessageIndex,
+                totalUserMessages: userMessageCount,
+            });
+            setError("User message not found");
+            return;
+        }
+        const targetMessage = messages[targetArrayIndex];
+        logger.debug("[editAndResend] Found target message", {
+            userMessageIndex,
+            targetArrayIndex,
+            messageRole: targetMessage?.role,
+        });
+        // Create assistant message ID outside try block so it's accessible in catch
+        const assistantMessageId = `msg_${Date.now()}_assistant`;
+        try {
+            // Start streaming and track time
+            const startTime = Date.now();
+            setIsStreaming(true);
+            setStreamingStartTime(startTime);
+            // Truncate UI messages - keep everything BEFORE the target message
+            truncateMessagesFrom(targetArrayIndex);
+            // Add the new user message to UI
+            const userMessage = {
+                id: `msg_${Date.now()}_user`,
+                role: "user",
+                content: newContent,
+                timestamp: new Date().toISOString(),
+                isStreaming: false,
+                ...(attachments && attachments.length > 0
+                    ? {
+                        images: attachments
+                            .filter((a) => a.mimeType.startsWith("image/"))
+                            .map((a) => ({ mimeType: a.mimeType, data: a.data })),
+                    }
+                    : {}),
+            };
+            addMessage(userMessage);
+            // Create placeholder for assistant message
+            const assistantMessage = {
+                id: assistantMessageId,
+                role: "assistant",
+                content: "",
+                timestamp: new Date().toISOString(),
+                isStreaming: true,
+                streamingStartTime: startTime,
+            };
+            addMessage(assistantMessage);
+            // Store the assistant message ID for potential cancellation
+            currentAssistantMessageIdRef.current = assistantMessageId;
+            wasCancelledRef.current = false;
+            // Start receiving chunks (async iterator)
+            const messageStream = client.receiveMessages();
+            // Call editAndResend on the backend
+            client
+                .editAndResend(userMessageIndex, newContent, sessionId, attachments)
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                setError(message);
+                setIsStreaming(false);
+                setStreamingStartTime(null);
+            });
+            // Listen for streaming chunks (same as sendMessage)
+            let accumulatedContent = "";
+            let streamCompleted = false;
+            for await (const chunk of messageStream) {
+                if (wasCancelledRef.current) {
+                    logger.info("Stream cancelled, exiting loop");
+                    break;
+                }
+                if (chunk.type === "content") {
+                    // biome-ignore lint/suspicious/noExplicitAny: Accessing dynamic properties from streaming chunks
+                    const chunkMeta = chunk._meta;
+                    const contextSizeData = 
+                    // biome-ignore lint/suspicious/noExplicitAny: Accessing dynamic properties from streaming chunks
+                    chunkMeta?.context_size || chunk.context_size;
+                    if (contextSizeData != null) {
+                        const contextSize = contextSizeData;
+                        logger.info("✅ Received context_size from backend", {
+                            context_size: contextSize,
+                            totalEstimated: contextSize.totalEstimated,
+                        });
+                        setLatestContextSize(contextSize);
+                    }
+                    if (chunk.isComplete) {
+                        updateMessage(assistantMessageId, {
+                            content: accumulatedContent,
+                            isStreaming: false,
+                            streamingStartTime: undefined,
+                            ...(chunk.tokenUsage ? { tokenUsage: chunk.tokenUsage } : {}),
+                        });
+                        setIsStreaming(false);
+                        setStreamingStartTime(null);
+                        currentAssistantMessageIdRef.current = null;
+                        streamCompleted = true;
+                        break;
+                    }
+                    else {
+                        if (chunk.contentDelta.type === "text") {
+                            accumulatedContent += chunk.contentDelta.text;
+                            updateMessage(assistantMessageId, {
+                                content: accumulatedContent,
+                                ...(chunk.tokenUsage ? { tokenUsage: chunk.tokenUsage } : {}),
+                            });
+                            if (!document.hidden) {
+                                await new Promise((resolve) => setTimeout(resolve, 16));
+                            }
+                        }
+                    }
+                }
+                else if (chunk.type === "tool_call") {
+                    logger.debug("Received tool_call chunk", { chunk });
+                    addToolCall(sessionId, chunk.toolCall);
+                    addToolCallToCurrentMessage(chunk.toolCall);
+                }
+                else if (chunk.type === "tool_call_update") {
+                    logger.debug("Received tool_call_update chunk", { chunk });
+                    updateToolCall(sessionId, chunk.toolCallUpdate);
+                    updateToolCallInCurrentMessage(chunk.toolCallUpdate);
+                }
+                else if (chunk.type === "hook_notification") {
+                    logger.debug("Received hook_notification chunk", { chunk });
+                    addHookNotificationToCurrentMessage(chunk.notification);
+                }
+                else if (chunk.type === "sources") {
+                    logger.debug("Received sources chunk", { chunk });
+                    addSourcesToCurrentMessage(chunk.sources);
+                }
+            }
+            if (!streamCompleted) {
+                if (wasCancelledRef.current) {
+                    logger.info("Stream cancelled by user");
+                    updateMessage(assistantMessageId, {
+                        content: `${accumulatedContent}\n\n[Cancelled]`,
+                        isStreaming: false,
+                        streamingStartTime: undefined,
+                    });
+                }
+                else {
+                    logger.warn("Stream ended without isComplete flag");
+                    updateMessage(assistantMessageId, {
+                        isStreaming: false,
+                        streamingStartTime: undefined,
+                    });
+                }
+                setIsStreaming(false);
+                setStreamingStartTime(null);
+                currentAssistantMessageIdRef.current = null;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            setError(message);
+            setIsStreaming(false);
+            setStreamingStartTime(null);
+            currentAssistantMessageIdRef.current = null;
+            updateMessage(assistantMessageId, {
+                isStreaming: false,
+                streamingStartTime: undefined,
+            });
+        }
+    }, [
+        client,
+        sessionId,
+        messages,
+        truncateMessagesFrom,
+        addMessage,
+        updateMessage,
+        setIsStreaming,
+        setStreamingStartTime,
+        setError,
+        setLatestContextSize,
+        addToolCall,
+        updateToolCall,
+        addToolCallToCurrentMessage,
+        updateToolCallInCurrentMessage,
+        addHookNotificationToCurrentMessage,
+        addSourcesToCurrentMessage,
     ]);
     return {
         messages,
         isStreaming,
         sendMessage,
+        editAndResend,
+        cancel,
     };
 }

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

@@ -279,6 +279,15 @@ export declare const DisplayMessage: z.ZodObject<{
         mimeType: z.ZodString;
         data: z.ZodString;
     }, z.core.$strip>>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodString;
+        snippet: z.ZodOptional<z.ZodString>;
+        favicon: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodString;
+        sourceName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type DisplayMessage = z.infer<typeof DisplayMessage>;
 /**
@@ -294,6 +303,7 @@ export declare const InputState: z.ZodObject<{
         mimeType: z.ZodString;
         data: z.ZodString;
     }, z.core.$strip>>;
+    selectedPromptParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type InputState = z.infer<typeof InputState>;
 /**
@@ -533,6 +543,15 @@ export declare const ChatSessionState: z.ZodObject<{
             mimeType: z.ZodString;
             data: z.ZodString;
         }, z.core.$strip>>>;
+        sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            url: z.ZodString;
+            title: z.ZodString;
+            snippet: z.ZodOptional<z.ZodString>;
+            favicon: z.ZodOptional<z.ZodString>;
+            toolCallId: z.ZodString;
+            sourceName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     input: z.ZodObject<{
         value: z.ZodString;
@@ -544,6 +563,7 @@ export declare const ChatSessionState: z.ZodObject<{
             mimeType: z.ZodString;
             data: z.ZodString;
         }, z.core.$strip>>;
+        selectedPromptParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>;
     error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;

package/dist/core/schemas/chat.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { HookNotification, HookType } from "../../sdk/schemas/message.js";
+import { SourceSchema } from "./source.js";
 import { TokenUsageSchema, ToolCallSchema } from "./tool-call.js";
 /**
  * Chat UI state schemas
@@ -64,6 +65,7 @@ export const DisplayMessage = z.object({
     hookNotifications: z.array(HookNotificationDisplay).optional(), // Hook notifications for this message
     tokenUsage: TokenUsageSchema.optional(), // Token usage for this message
     images: z.array(DisplayImageAttachment).optional(), // Image attachments for user messages
+    sources: z.array(SourceSchema).optional(), // Citation sources from tool calls
 });
 /**
  * Input state schema
@@ -78,6 +80,8 @@ export const InputState = z.object({
         mimeType: z.string(),
         data: z.string(), // base64 encoded file data
     })),
+    /** Selected prompt parameters for per-message configuration. Maps parameter ID to selected option ID. */
+    selectedPromptParameters: z.record(z.string(), z.string()).optional(),
 });
 /**
  * Chat session UI state

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

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

package/dist/core/schemas/index.js

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

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+/**
+ * Citation source extracted from tool calls (WebSearch, WebFetch, MCP tools)
+ */
+export declare const SourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    url: z.ZodString;
+    title: z.ZodString;
+    snippet: z.ZodOptional<z.ZodString>;
+    favicon: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodString;
+    sourceName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Source = z.infer<typeof SourceSchema>;
+/**
+ * Helper to derive favicon URL from a domain
+ */
+export declare function getFaviconUrl(url: string): string;
+/**
+ * Helper to extract domain name from URL
+ */
+export declare function getSourceName(url: string): string;

package/dist/core/schemas/source.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+/**
+ * Citation source extracted from tool calls (WebSearch, WebFetch, MCP tools)
+ */
+export const SourceSchema = z.object({
+    /** Unique identifier for LLM reference (e.g., "1", "2") */
+    id: z.string(),
+    /** The URL of the source */
+    url: z.string().url(),
+    /** Title of the source page/article */
+    title: z.string(),
+    /** Optional snippet/excerpt from the source */
+    snippet: z.string().optional(),
+    /** Favicon URL (derived from domain) */
+    favicon: z.string().optional(),
+    /** The tool call ID that produced this source */
+    toolCallId: z.string(),
+    /** Source name/domain (e.g., "Reuters", "GitHub") */
+    sourceName: z.string().optional(),
+});
+/**
+ * Helper to derive favicon URL from a domain
+ */
+export function getFaviconUrl(url) {
+    try {
+        const domain = new URL(url).hostname;
+        return `https://www.google.com/s2/favicons?domain=${domain}&sz=32`;
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Helper to extract domain name from URL
+ */
+export function getSourceName(url) {
+    try {
+        const hostname = new URL(url).hostname;
+        // Remove www. prefix and get the main domain
+        return hostname.replace(/^www\./, "").split(".")[0] || hostname;
+    }
+    catch {
+        return "Unknown";
+    }
+}

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

@@ -2,6 +2,7 @@ import { type LogEntry } from "@townco/core";
 import type { TodoItem } from "../../gui/components/TodoListItem.js";
 import type { HookNotification } from "../../sdk/schemas/message.js";
 import type { ConnectionStatus, DisplayMessage, InputState } from "../schemas/index.js";
+import type { Source } from "../schemas/source.js";
 import type { ToolCall, ToolCallUpdate } from "../schemas/tool-call.js";
 /**
  * Selector to get todos for the current session (memoized to prevent infinite loops)
@@ -62,10 +63,12 @@ export interface ChatStore {
     addToolCallToCurrentMessage: (toolCall: ToolCall) => void;
     updateToolCallInCurrentMessage: (update: ToolCallUpdate) => void;
     addHookNotificationToCurrentMessage: (notification: HookNotification) => void;
+    addSourcesToCurrentMessage: (sources: Source[]) => void;
     setInputValue: (value: string) => void;
     setInputSubmitting: (submitting: boolean) => void;
     addFileAttachment: (file: InputState["attachedFiles"][number]) => void;
     removeFileAttachment: (index: number) => void;
+    setSelectedPromptParameters: (params: Record<string, string>) => void;
     clearInput: () => void;
     addTokenUsage: (tokenUsage: {
         inputTokens?: number;
@@ -79,6 +82,7 @@ export interface ChatStore {
     addLog: (log: LogEntry) => void;
     clearLogs: () => void;
     setActiveTab: (tab: "chat" | "logs") => void;
+    truncateMessagesFrom: (messageIndex: number) => void;
 }
 /**
  * Create chat store