clippy-test 1.0.9 → 2.0.1

package/dist/logsManager.js

@@ -0,0 +1,90 @@
+/**
+ * Singleton Logs Manager
+ * Maintains logs data
+ */
+export class LogsManager {
+    constructor() {
+        this.logs = "";
+        // Private constructor to prevent direct instantiation
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!LogsManager.instance) {
+            LogsManager.instance = new LogsManager();
+        }
+        return LogsManager.instance;
+    }
+    /**
+     * Append Logs
+     * @param chunk
+     */
+    addChunk(chunk) {
+        this.logs += chunk;
+    }
+    /**
+     * Retrieves logs
+     */
+    getLogs() {
+        return this.logs;
+    }
+    getTailLogs(n) {
+        const logs = this.getLogs() || "";
+        const linesArr = logs.split("\n");
+        const tail = linesArr.slice(-n).join("\n");
+        return tail;
+    }
+    getGrepLogs(pattern, before = 5, after = 5) {
+        const logs = this.getLogs() || "";
+        if (!pattern || !pattern.trim()) {
+            return "";
+        }
+        const lines = logs.split("\n");
+        const normalizedPattern = pattern.toLowerCase();
+        const beforeCount = before;
+        const afterCount = after;
+        const blocks = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.toLowerCase().includes(normalizedPattern)) {
+                const start = Math.max(0, i - beforeCount);
+                const end = Math.min(lines.length, i + afterCount + 1);
+                const contextBlock = lines.slice(start, end).join("\n");
+                blocks.push(`block (match line ${i + 1}): ${contextBlock}`);
+            }
+        }
+        if (blocks.length === 0) {
+            return `No matches found for pattern "${pattern}" in logs.`;
+        }
+        return blocks.join("\n\n");
+    }
+    getRecentErrors(n) {
+        const logs = this.getLogs() || "";
+        const lines = logs.split("\n");
+        const matched = [];
+        if (!Number.isFinite(n) || n <= 0) {
+            return "Invalid value for n. Please provide a positive number of error lines to fetch.";
+        }
+        const errorRegex = /\b(ERROR|ERR|FATAL|CRITICAL|WARN|WARNING|SEVERE|ALERT|PANIC|EMERGENCY)\b|(Exception|Unhandled|Uncaught|Traceback|stacktrace|Caused by:)|(TypeError|ReferenceError|RangeError|SyntaxError|RuntimeError|ValueError|NullPointerException|IllegalArgument)|(timeout|timed out|connection refused|connection reset|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN)|(HTTP\s(4\d\d|5\d\d)|\b5\d\d\b|\b429\b|\b503\b)|(OOM|out of memory|disk full|quota exceeded|rate limited|deadlock|segfault|SIGKILL|panic)/i;
+        for (let i = lines.length - 1; i >= 0 && matched.length < n; i--) {
+            const line = lines[i];
+            if (errorRegex.test(line)) {
+                matched.push(line);
+            }
+        }
+        if (matched.length === 0) {
+            return "No recent error log lines found";
+        }
+        return matched.reverse().join("\n");
+    }
+    /**
+     * Clear all logs
+     */
+    clearAll() {
+        this.logs = "";
+    }
+}
+// Export the singleton instance
+export default LogsManager.getInstance();
+//# sourceMappingURL=logsManager.js.map

package/dist/postinstall.js

@@ -0,0 +1,20 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+try {
+  const patchPackagePath = join(process.cwd(), 'node_modules', '.bin', 'patch-package');
+  const patchesDir = join(process.cwd(), 'patches');
+  
+  if (existsSync(patchPackagePath) && existsSync(patchesDir)) {
+    execSync('patch-package', { stdio: 'ignore', timeout: 5000 });
+  }
+} catch (error) {
+}
+
+console.log(`
+OnCall installed.
+
+Run:
+  oncall --help
+to get started.`);

package/dist/tools/ripgrep.js

@@ -29,11 +29,11 @@ export async function ripgrepSearch(query, options = {}) {
     }
     const searchDir = workingDirectory || (typeof process !== "undefined" ? process.cwd() : undefined);
     if (!searchDir) {
-        console.error("[ripgrep] workingDirectory is required for client-side usage");
+        // console.error("[ripgrep] workingDirectory is required for client-side usage");
         return [];
     }
     try {
-        let rg = new RipGrep(query, workingDirectory);
+        let rg = new RipGrep(query, searchDir);
         rg.withFilename().lineNumber();
         if (!caseSensitive) {
             rg.ignoreCase();
@@ -82,7 +82,7 @@ export async function ripgrepSearch(query, options = {}) {
             error.code === 1) {
             return [];
         }
-        console.error("[ripgrep] Error executing ripgrep:", error.message);
+        // console.error("[ripgrep] Error executing ripgrep:", error.message);
         return [];
     }
 }

package/dist/useWebSocket.d.ts

@@ -1,10 +1,15 @@
-export declare function useWebSocket(url: string): {
+import WebSocket from "ws";
+import { BaseMessage } from "langchain";
+import { LogsManager } from "./logsManager.js";
+export declare function useWebSocket(url: string, rawLogData: LogsManager): {
     connectWebSocket: () => void;
     socketId: string;
-    sendQuery: (query: string, logs: any, state?: any) => void;
-    chatResponseMessages: any[];
-    setChatResponseMessages: import("react").Dispatch<import("react").SetStateAction<any[]>>;
-    setTrimmedChats: import("react").Dispatch<import("react").SetStateAction<any[]>>;
+    sendQuery: (messages: BaseMessage[], architecture: string, logs?: string, planningDoc?: string) => void;
+    chatResponseMessages: BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[];
+    visibleChats: BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[];
+    setVisibleChats: import("react").Dispatch<import("react").SetStateAction<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>>;
+    setChatResponseMessages: import("react").Dispatch<import("react").SetStateAction<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>>;
+    setTrimmedChats: import("react").Dispatch<import("react").SetStateAction<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>>;
     isConnected: boolean;
     connectionError: string;
     isLoading: boolean;
@@ -15,5 +20,8 @@ export declare function useWebSocket(url: string): {
     setIsLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     setShowControlR: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     showControlR: boolean;
-    setCompleteChatHistory: import("react").Dispatch<import("react").SetStateAction<any[]>>;
+    setCompleteChatHistory: import("react").Dispatch<import("react").SetStateAction<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>>;
+    customMessage: string;
+    graphState: any;
+    setGraphState: import("react").Dispatch<any>;
 };

package/dist/useWebSocket.js

@@ -1,13 +1,17 @@
 import { useCallback, useEffect, useRef, useState } from "react";
+import WebSocket from "ws";
 import { getContextLines } from "./utils.js";
 import { toolFunctionCall } from "./api.js";
 import fs from "fs";
 import os from "os";
 import path from "path";
-// Load Clippy config from ~/.clippy/config
+import { mapChatMessagesToStoredMessages, mapStoredMessagesToChatMessages, SystemMessage, } from "@langchain/core/messages";
+import { ripgrepSearch } from "./helpers/ripgrep-tool.js";
+import { loadProjectMetadata, logd } from "./helpers/cli-helpers.js";
+// Load OnCall config from ~/.oncall/config
 const HOME_DIR = os.homedir();
-const CLIPPY_DIR = path.join(HOME_DIR, ".clippy");
-const CONFIG_PATH = path.join(CLIPPY_DIR, "config");
+const ONCALL_DIR = path.join(HOME_DIR, ".oncall");
+const CONFIG_PATH = path.join(ONCALL_DIR, "config");
 let API_KEY = "";
 try {
     const configText = fs.readFileSync(CONFIG_PATH, "utf8");
@@ -16,33 +20,54 @@ try {
         API_KEY = match[1].trim();
     }
     else {
-        console.log("No API_KEY found in ~/.clippy/config");
+        console.log("No API_KEY found in ~/.oncall/config");
     }
 }
 catch (err) {
-    console.log("Failed to read Clippy config:", err);
+    console.log("Failed to read OnCall config:", err);
 }
-export function useWebSocket(url) {
+export function useWebSocket(url, rawLogData) {
     //refs
     const socketRef = useRef(null);
     const [socketId, setSocketId] = useState(null);
     const [chatResponseMessages, setChatResponseMessages] = useState([]);
     const [trimmedChats, setTrimmedChats] = useState([]);
-    const [visibleChats, setVisibleChats] = useState([]);
+    const initialAssistantMessage = new SystemMessage("I’m watching your app run locally. You can ask me about errors, logs, performance,or anything else related to this run.");
+    const [visibleChats, setVisibleChats] = useState([
+        initialAssistantMessage,
+    ]);
     const [isConnected, setIsConnected] = useState(false);
     const [connectionError, setConnectionError] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     const [showControlR, setShowControlR] = useState(false);
+    const [customMessage, setCustomMessage] = useState(null);
+    const [graphState, setGraphState] = useState(null);
     const authKey = API_KEY;
+    const initialProjectMetadata = loadProjectMetadata();
+    const getProjectMetadata = () => loadProjectMetadata() || initialProjectMetadata;
+    const getServiceId = () => getProjectMetadata()?.window_id;
+    const hasLogsAccess = () => {
+        const value = getProjectMetadata()?.logs_available;
+        return value === undefined ? true : value;
+    };
+    const hasCodeAccess = () => {
+        const value = getProjectMetadata()?.code_available;
+        return value === undefined ? true : value;
+    };
     useEffect(() => {
         if (API_KEY === "") {
-            setConnectionError("No API_KEY found in ~/.clippy/config");
-            console.log("No API_KEY found in ~/.clippy/config");
+            setConnectionError("No API_KEY found in ~/.oncall/config");
+            console.log("No API_KEY found in ~/.oncall/config");
             process.exit();
         }
     }, [API_KEY]);
     //web socket connection
     const connectWebSocket = useCallback(() => {
+        // const d = fs.readFileSync('logs')
+        // fs.writeFileSync('logs', `${d} inside connectWS \n message: ${url} ${authKey} ${serviceId}`)
+        // if (!url || !authKey || serviceId.trim() === "") {
+        //   return;
+        // }
         if (socketRef.current) {
             socketRef.current.close();
         }
@@ -52,7 +77,17 @@ export function useWebSocket(url) {
         setIsConnected(false);
         socket.onopen = () => {
             try {
-                socket.send(JSON.stringify({ type: "recurring_connection", authKey }));
+                const md = getProjectMetadata();
+                if (!md?.window_id) {
+                    setConnectionError("Missing serviceId (window_id) in oncall.yaml");
+                    console.log("Missing serviceId (window_id) in oncall.yaml");
+                    return;
+                }
+                socket.send(JSON.stringify({
+                    type: "recurring_connection",
+                    authKey,
+                    serviceId: md.window_id,
+                }));
             }
             catch (error) {
                 setConnectionError("error");
@@ -83,7 +118,8 @@ export function useWebSocket(url) {
                     return; // ignore non-JSON frames
                 }
                 const data = JSON.parse(text);
-                if (data.type === "user_assigned" && data.socketId) {
+                // if (data.type === "user_assigned" && data.socketId) {
+                if (data.type === "user_assigned") {
                     setIsConnected(true);
                     setSocketId(data.socketId);
                 }
@@ -99,46 +135,126 @@ export function useWebSocket(url) {
                     return;
                 }
                 if (data.type === "tool_function_call") {
-                    if (data.function_name === "get_context_lines") {
+                    if (data.function_name === "read_file") {
+                        logd(`[read_file] 📥 Tool call received: tool_call_id=${data.tool_call_id}, args=${JSON.stringify(data.args)}`);
+                        if (!hasCodeAccess()) {
+                            logd(`[read_file] ⚠️  No code access, denying tool`);
+                            await denyToolAccess("read_file", data);
+                            return;
+                        }
                         const argsData = {
-                            fileName: data.args.fileName,
+                            filePath: data.args.filePath,
                             lineNumber: data.args.lineNumber,
-                            before: data.args.before,
-                            after: data.args.after,
+                            before: data.args.before || 30,
+                            after: data.args.after || 30,
                         };
-                        const result = getContextLines(argsData.fileName, argsData.lineNumber, argsData.before, argsData.after);
-                        try {
-                            await toolFunctionCall(data?.tool_call_id, result, data?.args, "tool_function_call");
+                        logd(`[read_file] 📋 Extracted args: filePath=${argsData.filePath}, lineNumber=${argsData.lineNumber}, before=${argsData.before}, after=${argsData.after}`);
+                        logd(`[read_file] 🔍 Calling getContextLines...`);
+                        const result = getContextLines(argsData.filePath, argsData.lineNumber, argsData.before, argsData.after);
+                        logd(`[read_file] ✅ File content extracted: resultLength=${result.length}, resultLines=${result.split("\n").length}, isEmpty=${result.trim().length === 0}`);
+                        logd(`[read_file] 📄 Result preview (first 300 chars): ${result.substring(0, 300)}${result.length > 300 ? "..." : ""}`);
+                        await postToolCallResult(data, result, setChatResponseMessages);
+                        logd(`[read_file] 📤 Result sent to backend successfully`);
+                        // await redisClient.set(data.tool_call_id, result, { EX: 120 });
+                        return;
+                    }
+                    if (data.function_name === "grep_search") {
+                        if (!hasCodeAccess()) {
+                            await denyToolAccess("grep_search", data);
+                            return;
                         }
-                        catch (error) {
-                            setChatResponseMessages((prev) => [
-                                ...prev,
-                                error?.response?.message || "Error, please try again",
-                            ]);
+                        await grepSearch(data.args.searchTerm, data);
+                        return;
+                    }
+                    if (data.function_name === "read_logs") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("read_logs", data);
+                            return;
                         }
-                        // await redisClient.set(data.tool_call_id, result, { EX: 120 });
+                        await readLogs(data.args.pageNumber, data);
+                        return;
+                    }
+                    if (data.function_name === "tail_logs") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("tail_logs", data);
+                            return;
+                        }
+                        await tailLogs(data.args.n, data);
+                        return;
+                    }
+                    if (data.function_name === "grep_logs") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("grep_logs", data);
+                            return;
+                        }
+                        await grepLogs(data.args.pattern, data.args.before, data.args.after, data);
+                        return;
+                    }
+                    if (data.function_name === "get_recent_errors") {
+                        if (!hasLogsAccess()) {
+                            await denyToolAccess("get_recent_errors", data);
+                            return;
+                        }
+                        await getRecentErrors(data.args.n, data);
+                        return;
                     }
-                    return;
                 }
-                setChatResponseMessages((prev) => [...prev, data]);
-                setVisibleChats((prev) => [...prev, data]);
+                // trimmed - imp msgs
+                // visible - shown
+                // chatresponses - all
                 // add non-progress responses to trimmedChats
-                if (data.type !== "progress") {
-                    setTrimmedChats((prevTrimmed) => {
-                        const updated = [...prevTrimmed, data];
-                        // update visible chats with all trimmed messages
-                        setVisibleChats(updated);
-                        return updated;
-                    });
+                // @todo this is where the messages get trimmed
+                // if (data.type !== "progress") {
+                //   setTrimmedChats((prevTrimmed) => {
+                //     const updated = [...prevTrimmed, data];
+                //     // update visible chats with all trimmed messages
+                //     setVisibleChats(updated);
+                //     return updated;
+                //   });
+                // }
+                if (data.type === "response") {
+                    let messages = data.data.messages ? data.data.messages : [];
+                    messages = mapStoredMessagesToChatMessages(messages);
+                    switch (data.data.type) {
+                        case "messages":
+                            if (data.data.sender !== "toolNode") {
+                                setVisibleChats(old => [...old, ...messages]);
+                            }
+                            // logd(`LOGGING RESPONSE SENDER: ${data.data.sender}`);
+                            break;
+                        case "values":
+                            if (data.data.state) {
+                                setGraphState(data.data.state);
+                            }
+                            break;
+                        case "updates":
+                            if (data.data.sender !== "toolNode" && data.data.sender !== "routerNode") {
+                                setChatResponseMessages(old => [...old, ...messages]);
+                            }
+                            if (data.data.sender === "answerNode") {
+                                setTrimmedChats(prev => {
+                                    setVisibleChats([...prev, ...messages]);
+                                    return [...prev, ...messages];
+                                });
+                                setIsLoading(false);
+                            }
+                            if (data.data.sender === "userNode") {
+                                setIsLoading(false);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
                 }
-                if (data.type === "response" ||
-                    data.type === "error" ||
+                if (data.type === "error" ||
                     data.type === "ask_user") {
                     setIsLoading(false);
+                    setCustomMessage(null);
                 }
             }
             catch (error) {
-                console.warn("WebSocket message handling warning:", error);
+                setIsLoading(false);
+                // console.warn("WebSocket message handling warning:", error);
                 return;
             }
         };
@@ -159,34 +275,160 @@ export function useWebSocket(url) {
         //   };
         // }
     }, [url, authKey]);
-    const sendQuery = useCallback((query, logs, state) => {
+    const sendQuery = useCallback((messages, architecture, logs, planningDoc) => {
         const socket = socketRef.current;
         if (socket && socket.readyState === WebSocket.OPEN) {
             setIsLoading(true);
-            const payload = state
-                ? { type: "query", socketId, logs, query, state }
-                : { type: "query", socketId, logs, query };
+            setCustomMessage("🤔 Thinking...");
+            const md = getProjectMetadata();
+            const payload = {
+                type: "query",
+                authKey,
+                serviceId: md?.window_id,
+                userQuery: {
+                    messages: graphState
+                        ? mapChatMessagesToStoredMessages([messages[messages.length - 1]])
+                        : mapChatMessagesToStoredMessages(messages),
+                    architecture: architecture,
+                    logs,
+                    planningDoc: "",
+                },
+                planningDoc,
+                graphState: graphState || undefined,
+            };
             socket.send(JSON.stringify(payload));
         }
         else {
             setConnectionError("WebSocket not connected");
             throw new Error("Cannot send the message: Web socket not connected");
         }
-    }, [socketId]);
+    }, [socketId, graphState]);
     // Clean up on unmount
     useEffect(() => {
         return () => {
             if (socketRef.current) {
-                socketRef.current.close();
+                // socketRef.current.close();
             }
         };
     }, []);
+    async function grepSearch(searchTerm, data) {
+        logd(`[grepSearch] 🔍 Grep search invoked: searchTerm=${searchTerm}, tool_call_id=${data.tool_call_id}, args=${JSON.stringify(data.args)}`);
+        const projectMetadata = getProjectMetadata();
+        const workingDirectory = projectMetadata?.path || process.cwd();
+        logd(`[grepSearch] 📁 Working directory: workingDirectory=${workingDirectory}, projectPath=${projectMetadata?.path || 'N/A'}, processCwd=${process.cwd()}`);
+        const maxResults = data.args?.max_results || 20;
+        const caseSensitive = data.args?.case_sensitive || false;
+        const fileTypes = data.args?.file_types || [];
+        logd(`[grepSearch] ⚙️  Search options: maxResults=${maxResults}, caseSensitive=${caseSensitive}, fileTypes=${JSON.stringify(fileTypes)}`);
+        try {
+            const results = await ripgrepSearch(searchTerm, {
+                maxResults,
+                caseSensitive,
+                fileTypes,
+                workingDirectory,
+            });
+            logd(`[grepSearch] ✅ Search completed: resultCount=${results.length}, results=${JSON.stringify(results.map((r) => ({
+                filePath: r.filePath,
+                line: r.line,
+                previewLength: r.preview?.length || 0,
+            })))}`);
+            await postToolCallResult(data, results, setChatResponseMessages);
+        }
+        catch (error) {
+            logd(`[grepSearch] ❌ Error during grep search: ${error instanceof Error ? error.message : String(error)}, stack=${error instanceof Error ? error.stack : "N/A"}`);
+            await postToolCallResult(data, [], setChatResponseMessages);
+        }
+    }
+    async function readLogs(pageNumber, data) {
+        logd(`Triggered readLogs: ${pageNumber}`);
+        pageNumber = parseInt(pageNumber.toString());
+        const lines = rawLogData
+            .getLogs()
+            .split("\n")
+            .slice(-50 * pageNumber)
+            .join("\n");
+        logd(`Triggered readLogs - Posting result: ${lines.length}`);
+        await postToolCallResult(data, lines, setChatResponseMessages);
+        logd(`Triggered readLogs - done Posting result`);
+    }
+    async function tailLogs(n, data) {
+        try {
+            logd(`Triggered tailLogs: ${n}`);
+            n = parseInt(n.toString());
+            if (Number.isNaN(n) || n <= 0) {
+                await postToolCallResult(data, "Invalid value for n. Please provide a positive number of log lines to fetch.", setChatResponseMessages);
+                return;
+            }
+            const tail = rawLogData.getTailLogs(n);
+            logd(`Triggered tailLogs - Posting result: ${tail.length}`);
+            await postToolCallResult(data, tail, setChatResponseMessages);
+            logd(`Triggered tailLogs - done Posting result`);
+        }
+        catch (error) {
+            logd(`Triggered tailLogs - error: ${JSON.stringify(error)}`);
+            await postToolCallResult(data, "Failed to fetch tail logs from CLI.", setChatResponseMessages);
+        }
+    }
+    async function grepLogs(pattern, before, after, data) {
+        try {
+            logd(`Triggered grepLogs: pattern=${pattern}, before=${before}, after=${after}`);
+            if (!pattern || !pattern.trim()) {
+                await postToolCallResult(data, "Invalid pattern for grep_logs. Please provide a non-empty pattern.", setChatResponseMessages);
+                return;
+            }
+            const beforeCount = before !== undefined ? parseInt(before.toString()) : 5;
+            const afterCount = after !== undefined ? parseInt(after.toString()) : 5;
+            const result = rawLogData.getGrepLogs(pattern, beforeCount, afterCount);
+            await postToolCallResult(data, result, setChatResponseMessages);
+            logd(`Triggered grepLogs - done Posting result of length ${result.length}`);
+        }
+        catch (error) {
+            logd(`Triggered grepLogs - error: ${JSON.stringify(error)}`);
+            await postToolCallResult(data, "Failed to search logs with grep_logs.", setChatResponseMessages);
+        }
+    }
+    async function getRecentErrors(n, data) {
+        try {
+            logd(`Triggered getRecentErrors: n=${n}`);
+            n = parseInt(n.toString());
+            if (Number.isNaN(n) || n <= 0) {
+                await postToolCallResult(data, "Invalid value for n. Number Provided :" + n.toString(), setChatResponseMessages);
+                return;
+            }
+            const result = rawLogData.getRecentErrors(n);
+            await postToolCallResult(data, result, setChatResponseMessages);
+            logd(`Triggered getRecentErrors - done Posting result of length ${result.length}`);
+        }
+        catch (error) {
+            logd(`Triggered getRecentErrors - error: ${JSON.stringify(error)}`);
+            await postToolCallResult(data, "Failed to fetch recent error logs.", setChatResponseMessages);
+        }
+    }
+    async function postToolCallResult(data, result, setChatResponseMessages) {
+        try {
+            await toolFunctionCall(data?.tool_call_id, result, data?.args, "tool_function_call");
+        }
+        catch (error) {
+            logd(`Triggered readLogs - failer podting: ${JSON.stringify(error)}`);
+            // setChatResponseMessages((prev) => [
+            //   ...prev,
+            //   error?.response?.message || "Error, please try again",
+            // ]);
+        }
+    }
+    async function denyToolAccess(functionName, data) {
+        const serviceId = getServiceId();
+        const message = `No Access to execute ${functionName}. with the serviceId of ${serviceId ?? "unknown"}.`;
+        await postToolCallResult(data, message, setChatResponseMessages);
+    }
     return {
         connectWebSocket,
         socketId,
         sendQuery,
-        chatResponseMessages: visibleChats,
-        setChatResponseMessages: setVisibleChats,
+        chatResponseMessages: chatResponseMessages, // Full history including ToolMessage (needed for backend)
+        visibleChats: visibleChats, // Filtered for UI display (excludes ToolMessage except reflections)
+        setVisibleChats: setVisibleChats,
+        setChatResponseMessages,
         setTrimmedChats,
         isConnected,
         connectionError,
@@ -199,6 +441,9 @@ export function useWebSocket(url) {
         setShowControlR,
         showControlR,
         setCompleteChatHistory: setChatResponseMessages,
+        customMessage,
+        graphState,
+        setGraphState,
     };
 }
 //# sourceMappingURL=useWebSocket.js.map

package/dist/utils/version-check.d.ts

@@ -0,0 +1,2 @@
+export function checkVersionCompatibility(forceCheck?: boolean): Promise<boolean>;
+export function checkVersionAndExit(): Promise<void>;