refactor(completions): restore debouncing and improve MCP error handling

client/src/lib/hooks/useCompletionState.ts

@@ -1,10 +1,24 @@
-import { useState, useCallback, useEffect } from "react";
-import { ResourceReference, PromptReference } from "@modelcontextprotocol/sdk/types.js";
+import { useState, useCallback, useEffect, useRef } from "react";
+import {
+  ResourceReference,
+  PromptReference,
+} from "@modelcontextprotocol/sdk/types.js";
 
 interface CompletionState {
   completions: Record<string, string[]>;
   loading: Record<string, boolean>;
-  error: Record<string, string | null>;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function debounce<T extends (...args: any[]) => PromiseLike<void>>(
+  func: T,
+  wait: number,
+): (...args: Parameters<T>) => void {
+  let timeout: ReturnType<typeof setTimeout>;
+  return function (...args: Parameters<T>) {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
 }
 
 export function useCompletionState(
@@ -12,52 +26,90 @@ export function useCompletionState(
     ref: ResourceReference | PromptReference,
     argName: string,
     value: string,
+    signal?: AbortSignal,
   ) => Promise<string[]>,
   completionsSupported: boolean = true,
+  debounceMs: number = 300,
 ) {
   const [state, setState] = useState<CompletionState>({
     completions: {},
     loading: {},
-    error: {},
   });
 
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const cleanup = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return cleanup;
+  }, [cleanup]);
+
   const clearCompletions = useCallback(() => {
+    cleanup();
     setState({
       completions: {},
       loading: {},
-      error: {},
     });
-  }, []);
+  }, [cleanup]);
 
   const requestCompletions = useCallback(
-    async (ref: ResourceReference | PromptReference, argName: string, value: string) => {
-      if (!completionsSupported) {
-        return;
-      }
+    debounce(
+      async (
+        ref: ResourceReference | PromptReference,
+        argName: string,
+        value: string,
+      ) => {
+        if (!completionsSupported) {
+          return;
+        }
 
-      setState((prev) => ({
-        ...prev,
-        loading: { ...prev.loading, [argName]: true },
-        error: { ...prev.error, [argName]: null },
-      }));
+        cleanup();
+
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
 
-      try {
-        const values = await handleCompletion(ref, argName, value);
         setState((prev) => ({
           ...prev,
-          completions: { ...prev.completions, [argName]: values },
-          loading: { ...prev.loading, [argName]: false },
+          loading: { ...prev.loading, [argName]: true },
         }));
-      } catch (err) {
-        const error = err instanceof Error ? err.message : String(err);
-        setState((prev) => ({
-          ...prev,
-          loading: { ...prev.loading, [argName]: false },
-          error: { ...prev.error, [argName]: error },
-        }));
-      }
-    },
-    [handleCompletion, completionsSupported],
+
+        try {
+          const values = await handleCompletion(
+            ref,
+            argName,
+            value,
+            abortController.signal,
+          );
+
+          if (!abortController.signal.aborted) {
+            setState((prev) => ({
+              ...prev,
+              completions: { ...prev.completions, [argName]: values },
+              loading: { ...prev.loading, [argName]: false },
+            }));
+          }
+        } catch (err) {
+          if (!abortController.signal.aborted) {
+            setState((prev) => ({
+              ...prev,
+              loading: { ...prev.loading, [argName]: false },
+            }));
+          }
+        } finally {
+          if (abortControllerRef.current === abortController) {
+            abortControllerRef.current = null;
+          }
+        }
+      },
+      debounceMs,
+    ),
+    [handleCompletion, completionsSupported, cleanup, debounceMs],
   );
 
   // Clear completions when support status changes