@huyooo/ai-chat-frontend-react 0.2.11 → 0.2.13

package/dist/index.js

@@ -842,7 +842,7 @@ var RenderersProvider = ({
 };
 
 // src/components/ChatPanel.tsx
-import { useEffect as useEffect14, useRef as useRef9, useCallback as useCallback13, useMemo as useMemo12, useState as useState18, forwardRef as forwardRef8, useImperativeHandle as useImperativeHandle8 } from "react";
+import { useEffect as useEffect16, useRef as useRef11, useCallback as useCallback15, useMemo as useMemo14, useState as useState19, forwardRef as forwardRef8, useImperativeHandle as useImperativeHandle8 } from "react";
 import { Icon as Icon22 } from "@iconify/react";
 
 // src/components/header/ChatHeader.tsx
@@ -1192,7 +1192,7 @@ var WelcomeMessage = ({ config: propsConfig, onQuickAction }) => {
 };
 
 // src/components/message/MessageBubble.tsx
-import { useMemo as useMemo10 } from "react";
+import { useMemo as useMemo12 } from "react";
 import { Icon as Icon18 } from "@iconify/react";
 
 // src/components/message/parts/CollapsibleCard.tsx
@@ -1918,7 +1918,7 @@ var PartsRenderer = ({
 };
 
 // src/components/input/ChatInput.tsx
-import { useState as useState15, useRef as useRef7, useCallback as useCallback10, useEffect as useEffect10, forwardRef as forwardRef7, useImperativeHandle as useImperativeHandle7, useLayoutEffect, useMemo as useMemo9 } from "react";
+import { useState as useState16, useRef as useRef9, useCallback as useCallback12, useEffect as useEffect12, forwardRef as forwardRef7, useImperativeHandle as useImperativeHandle7, useLayoutEffect, useMemo as useMemo11 } from "react";
 import { Icon as Icon17 } from "@iconify/react";
 
 // src/components/input/AtFilePicker.tsx
@@ -2785,6 +2785,421 @@ function useImageUpload(options = {}) {
   };
 }
 
+// src/hooks/useVoiceToTextInput.ts
+import { useCallback as useCallback11, useEffect as useEffect11, useMemo as useMemo10, useRef as useRef8 } from "react";
+
+// src/hooks/useVoiceInput.ts
+import { useCallback as useCallback10, useEffect as useEffect10, useMemo as useMemo9, useRef as useRef7, useState as useState15 } from "react";
+function float32ToInt16(float32Array) {
+  const int16Array = new Int16Array(float32Array.length);
+  for (let i = 0; i < float32Array.length; i++) {
+    const s = Math.max(-1, Math.min(1, float32Array[i]));
+    int16Array[i] = s < 0 ? s * 32768 : s * 32767;
+  }
+  return int16Array;
+}
+function resample(audioData, fromSampleRate, toSampleRate) {
+  if (fromSampleRate === toSampleRate) return audioData;
+  const ratio = fromSampleRate / toSampleRate;
+  const newLength = Math.round(audioData.length / ratio);
+  const result = new Float32Array(newLength);
+  for (let i = 0; i < newLength; i++) {
+    const srcIndex = i * ratio;
+    const srcIndexFloor = Math.floor(srcIndex);
+    const srcIndexCeil = Math.min(srcIndexFloor + 1, audioData.length - 1);
+    const t = srcIndex - srcIndexFloor;
+    result[i] = audioData[srcIndexFloor] * (1 - t) + audioData[srcIndexCeil] * t;
+  }
+  return result;
+}
+var asrWarmupDone = false;
+async function setupAudioWorkletCapture(opts) {
+  const { audioContext, source, chunkSize, onChunk } = opts;
+  const workletCode = `
+class PcmCaptureProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const size = (options && options.processorOptions && options.processorOptions.chunkSize) || 4096;
+    this._chunkSize = size;
+    this._buf = new Float32Array(size);
+    this._offset = 0;
+  }
+  process(inputs, outputs) {
+    const input = inputs && inputs[0] && inputs[0][0];
+    const output = outputs && outputs[0] && outputs[0][0];
+    if (!input) return true;
+    if (output) output.set(input);
+
+    let i = 0;
+    while (i < input.length) {
+      const remain = this._chunkSize - this._offset;
+      const take = Math.min(remain, input.length - i);
+      this._buf.set(input.subarray(i, i + take), this._offset);
+      this._offset += take;
+      i += take;
+      if (this._offset >= this._chunkSize) {
+        const out = this._buf;
+        this.port.postMessage(out, [out.buffer]);
+        this._buf = new Float32Array(this._chunkSize);
+        this._offset = 0;
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('pcm-capture', PcmCaptureProcessor);
+`;
+  const blob = new Blob([workletCode], { type: "text/javascript" });
+  const url = URL.createObjectURL(blob);
+  await audioContext.audioWorklet.addModule(url);
+  URL.revokeObjectURL(url);
+  const workletNode = new AudioWorkletNode(audioContext, "pcm-capture", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    channelCount: 1,
+    processorOptions: { chunkSize }
+  });
+  const silentGain = audioContext.createGain();
+  silentGain.gain.value = 0;
+  const onMessage = (event) => {
+    const data = event.data;
+    if (data instanceof Float32Array) {
+      onChunk(data);
+      return;
+    }
+    if (data instanceof ArrayBuffer) {
+      onChunk(new Float32Array(data));
+    }
+  };
+  workletNode.port.addEventListener("message", onMessage);
+  workletNode.port.start();
+  source.connect(workletNode);
+  workletNode.connect(silentGain);
+  silentGain.connect(audioContext.destination);
+  return {
+    cleanup: () => {
+      try {
+        workletNode.port.removeEventListener("message", onMessage);
+      } catch {
+      }
+      try {
+        workletNode.disconnect();
+      } catch {
+      }
+      try {
+        silentGain.disconnect();
+      } catch {
+      }
+    }
+  };
+}
+function useVoiceInput(adapter, config = {}) {
+  const { sampleRate = 16e3, sendInterval = 200, enablePunc = true, enableItn = true } = config;
+  useEffect10(() => {
+    if (adapter && !asrWarmupDone && typeof adapter.asrWarmup === "function") {
+      asrWarmupDone = true;
+      const timer = setTimeout(() => {
+        adapter.asrWarmup?.().catch(() => {
+        });
+      }, 800);
+      return () => clearTimeout(timer);
+    }
+  }, [adapter]);
+  const [status, setStatus] = useState15("idle");
+  const [currentText, setCurrentText] = useState15("");
+  const [finalText, setFinalText] = useState15("");
+  const [error, setError] = useState15(null);
+  const statusRef = useRef7("idle");
+  const currentTextRef = useRef7("");
+  const finalTextRef = useRef7("");
+  const mediaStreamRef = useRef7(null);
+  const audioContextRef = useRef7(null);
+  const workletCleanupRef = useRef7(null);
+  const sourceRef = useRef7(null);
+  const audioBufferRef = useRef7([]);
+  const sendTimerRef = useRef7(null);
+  const cleanupFnsRef = useRef7([]);
+  const isRecording = useMemo9(() => status === "connecting" || status === "recording", [status]);
+  useEffect10(() => {
+    statusRef.current = status;
+  }, [status]);
+  useEffect10(() => {
+    currentTextRef.current = currentText;
+  }, [currentText]);
+  useEffect10(() => {
+    finalTextRef.current = finalText;
+  }, [finalText]);
+  const setStatusSafe = useCallback10((next) => {
+    statusRef.current = next;
+    setStatus(next);
+  }, []);
+  const cleanup = useCallback10(() => {
+    if (sendTimerRef.current) {
+      clearInterval(sendTimerRef.current);
+      sendTimerRef.current = null;
+    }
+    if (workletCleanupRef.current) {
+      workletCleanupRef.current();
+      workletCleanupRef.current = null;
+    }
+    if (sourceRef.current) {
+      try {
+        sourceRef.current.disconnect();
+      } catch {
+      }
+      sourceRef.current = null;
+    }
+    if (audioContextRef.current) {
+      audioContextRef.current.close().catch(() => {
+      });
+      audioContextRef.current = null;
+    }
+    if (mediaStreamRef.current) {
+      mediaStreamRef.current.getTracks().forEach((t) => t.stop());
+      mediaStreamRef.current = null;
+    }
+    cleanupFnsRef.current.forEach((fn) => fn());
+    cleanupFnsRef.current = [];
+    audioBufferRef.current = [];
+  }, []);
+  const sendAudioChunk = useCallback10(async () => {
+    if (!adapter?.asrSendAudio) return;
+    const buf = audioBufferRef.current;
+    if (!buf.length) return;
+    const totalLength = buf.reduce((sum, arr) => sum + arr.length, 0);
+    const merged = new Float32Array(totalLength);
+    let offset = 0;
+    for (const chunk of buf) {
+      merged.set(chunk, offset);
+      offset += chunk.length;
+    }
+    audioBufferRef.current = [];
+    const pcmData = float32ToInt16(merged);
+    const result = await adapter.asrSendAudio(pcmData.buffer);
+    if (!result.success) {
+      console.error("[VoiceInput] \u53D1\u9001\u97F3\u9891\u5931\u8D25:", result.error);
+    }
+  }, [adapter]);
+  const start = useCallback10(async () => {
+    if (statusRef.current === "connecting" || statusRef.current === "recording") return;
+    if (!adapter) {
+      setError("Adapter \u672A\u521D\u59CB\u5316");
+      setStatusSafe("error");
+      return;
+    }
+    if (!adapter.asrStart) {
+      setError("\u8BED\u97F3\u8BC6\u522B\u529F\u80FD\u4E0D\u53EF\u7528");
+      setStatusSafe("error");
+      return;
+    }
+    setError(null);
+    setCurrentText("");
+    setFinalText("");
+    setStatusSafe("connecting");
+    try {
+      mediaStreamRef.current = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          channelCount: 1,
+          sampleRate: { ideal: sampleRate },
+          echoCancellation: true,
+          noiseSuppression: true
+        }
+      });
+      audioContextRef.current = new AudioContext({ sampleRate });
+      const actualSampleRate = audioContextRef.current.sampleRate;
+      if (adapter.onAsrResult) {
+        const off2 = adapter.onAsrResult((data) => {
+          const text = data.result.result?.text || "";
+          setCurrentText(text);
+          if (data.isLast) setFinalText(text);
+        });
+        cleanupFnsRef.current.push(off2);
+      }
+      if (adapter.onAsrError) {
+        const off2 = adapter.onAsrError((err) => {
+          console.error("[VoiceInput] ASR \u9519\u8BEF:", err.message);
+          setError(err.message);
+          setStatusSafe("error");
+        });
+        cleanupFnsRef.current.push(off2);
+      }
+      if (adapter.onAsrClosed) {
+        const off2 = adapter.onAsrClosed(() => {
+          if (statusRef.current === "recording") {
+            setStatusSafe("idle");
+          }
+        });
+        cleanupFnsRef.current.push(off2);
+      }
+      const ctx = audioContextRef.current;
+      const stream = mediaStreamRef.current;
+      if (!ctx || !stream) throw new Error("AudioContext \u6216 MediaStream \u521D\u59CB\u5316\u5931\u8D25");
+      const startResult = await adapter.asrStart({
+        format: "pcm",
+        sampleRate,
+        enablePunc,
+        enableItn,
+        showUtterances: true
+      });
+      if (!startResult.success) {
+        throw new Error(startResult.error || "ASR \u542F\u52A8\u5931\u8D25");
+      }
+      sourceRef.current = ctx.createMediaStreamSource(stream);
+      if (typeof AudioWorkletNode === "undefined" || !ctx.audioWorklet) {
+        throw new Error("\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 AudioWorkletNode\uFF08\u65E0\u6CD5\u542F\u52A8\u8BED\u97F3\u5F55\u5236\uFF09");
+      }
+      const { cleanup: off } = await setupAudioWorkletCapture({
+        audioContext: ctx,
+        source: sourceRef.current,
+        chunkSize: 4096,
+        onChunk: (chunk) => {
+          if (statusRef.current !== "recording") return;
+          const resampled = resample(chunk, actualSampleRate, sampleRate);
+          audioBufferRef.current.push(new Float32Array(resampled));
+        }
+      });
+      workletCleanupRef.current = off;
+      sendTimerRef.current = setInterval(() => {
+        sendAudioChunk().catch(() => {
+        });
+      }, sendInterval);
+      setStatusSafe("recording");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      setError(msg);
+      setStatusSafe("error");
+      cleanup();
+    }
+  }, [adapter, cleanup, enableItn, enablePunc, sampleRate, sendAudioChunk, sendInterval, setStatusSafe]);
+  const stop = useCallback10(async () => {
+    if (statusRef.current === "connecting") {
+      if (adapter?.asrStop) {
+        adapter.asrStop().catch(() => {
+        });
+      }
+      cleanup();
+      setCurrentText("");
+      setFinalText("");
+      setError(null);
+      setStatusSafe("idle");
+      return "";
+    }
+    if (statusRef.current !== "recording") return finalTextRef.current || currentTextRef.current;
+    setStatusSafe("processing");
+    try {
+      await sendAudioChunk();
+      if (adapter?.asrFinish) {
+        await adapter.asrFinish();
+      }
+      await new Promise((resolve) => {
+        const startAt = Date.now();
+        const timer = setInterval(() => {
+          if (Date.now() - startAt > 3e3) {
+            clearInterval(timer);
+            resolve();
+            return;
+          }
+          if (finalTextRef.current) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 100);
+      });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      setError(msg);
+    } finally {
+      cleanup();
+      setStatusSafe("idle");
+    }
+    return finalTextRef.current || currentTextRef.current;
+  }, [adapter, cleanup, sendAudioChunk, setStatusSafe]);
+  const cancel = useCallback10(() => {
+    if (adapter?.asrStop) {
+      adapter.asrStop().catch(() => {
+      });
+    }
+    cleanup();
+    setCurrentText("");
+    setFinalText("");
+    setError(null);
+    setStatusSafe("idle");
+  }, [adapter, cleanup, setStatusSafe]);
+  useEffect10(() => {
+    return () => cancel();
+  }, [cancel]);
+  return {
+    status,
+    isRecording,
+    currentText,
+    finalText,
+    error,
+    start,
+    stop,
+    cancel
+  };
+}
+
+// src/hooks/useVoiceToTextInput.ts
+function useVoiceToTextInput(opts) {
+  const { adapter, inputText, setInputText, hasImages, isLoading } = opts;
+  const voiceInput = useVoiceInput(adapter);
+  const prefixRef = useRef8("");
+  const isVoiceActive = useMemo10(
+    () => voiceInput.status === "connecting" || voiceInput.status === "recording",
+    [voiceInput.status]
+  );
+  useEffect11(() => {
+    if (!isVoiceActive) return;
+    const prefix = prefixRef.current;
+    const t = voiceInput.currentText;
+    const next = prefix ? t ? `${prefix} ${t}` : prefix : t;
+    setInputText(next);
+  }, [isVoiceActive, setInputText, voiceInput.currentText]);
+  const toggleVoice = useCallback11(async () => {
+    if (isLoading) return;
+    if (!adapter) return;
+    if (voiceInput.status === "connecting") {
+      voiceInput.cancel();
+      setInputText(prefixRef.current);
+      prefixRef.current = "";
+      return;
+    }
+    if (voiceInput.status === "recording") {
+      await voiceInput.stop();
+      prefixRef.current = "";
+      return;
+    }
+    prefixRef.current = inputText.trim();
+    await voiceInput.start();
+  }, [adapter, inputText, isLoading, setInputText, voiceInput]);
+  const sendDisabled = useMemo10(() => {
+    if (isLoading) return false;
+    if (isVoiceActive) return true;
+    return !inputText.trim() && !hasImages;
+  }, [hasImages, inputText, isLoading, isVoiceActive]);
+  const handleKeyDownForVoice = useCallback11(
+    (e) => {
+      if (!isVoiceActive) return false;
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        toggleVoice().catch(() => {
+        });
+        return true;
+      }
+      return false;
+    },
+    [isVoiceActive, toggleVoice]
+  );
+  return {
+    voiceInput,
+    isVoiceActive,
+    toggleVoice,
+    sendDisabled,
+    handleKeyDownForVoice
+  };
+}
+
 // src/components/input/ChatInput.tsx
 import { jsx as jsx24, jsxs as jsxs17 } from "react/jsx-runtime";
 var MODE_OPTIONS = [
@@ -2811,22 +3226,22 @@ var ChatInput = forwardRef7(
     const isMessageVariant = variant === "message";
     const inputContext = useChatInputContext();
     const adapter = inputContext?.adapter;
-    const [inputText, setInputText] = useState15(value);
-    const [isFocused, setIsFocused] = useState15(false);
+    const [inputText, setInputText] = useState16(value);
+    const [isFocused, setIsFocused] = useState16(false);
     const imageUpload = useImageUpload();
-    const imageInputRef = useRef7(null);
-    const inputRef = useRef7(null);
-    const containerRef = useRef7(null);
-    const atSelectorRef = useRef7(null);
-    const [atPickerVisible, setAtPickerVisible] = useState15(false);
-    const replaceRangeRef = useRef7(null);
-    const pendingCaretRef = useRef7(null);
-    const pendingFocusRef = useRef7(false);
-    const prevValueRef = useRef7(value);
-    const triggerImageUpload = useCallback10(() => {
+    const imageInputRef = useRef9(null);
+    const inputRef = useRef9(null);
+    const containerRef = useRef9(null);
+    const atSelectorRef = useRef9(null);
+    const [atPickerVisible, setAtPickerVisible] = useState16(false);
+    const replaceRangeRef = useRef9(null);
+    const pendingCaretRef = useRef9(null);
+    const pendingFocusRef = useRef9(false);
+    const prevValueRef = useRef9(value);
+    const triggerImageUpload = useCallback12(() => {
       imageInputRef.current?.click();
     }, []);
-    const groupedModelOptions = useMemo9(() => {
+    const groupedModelOptions = useMemo11(() => {
       const groups = {};
       models.forEach((m) => {
         const groupName = m.group;
@@ -2843,12 +3258,12 @@ var ChatInput = forwardRef7(
       });
       return groups;
     }, [models]);
-    const closeAtPicker = useCallback10(() => {
+    const closeAtPicker = useCallback12(() => {
       setAtPickerVisible(false);
       replaceRangeRef.current = null;
       pendingFocusRef.current = true;
     }, []);
-    const applyAtPath = useCallback10(
+    const applyAtPath = useCallback12(
       (path) => {
         const el = inputRef.current;
         const current = el?.value ?? inputText;
@@ -2876,22 +3291,37 @@ var ChatInput = forwardRef7(
       },
       [closeAtPicker, inputText]
     );
-    const toggleAtPicker = useCallback10(() => {
+    const toggleAtPicker = useCallback12(() => {
       if (!adapter) return;
       if (!atPickerVisible) {
         replaceRangeRef.current = null;
       }
       setAtPickerVisible((prev) => !prev);
     }, [adapter, atPickerVisible]);
-    useEffect10(() => {
+    useEffect12(() => {
       setInputText(value);
     }, [value]);
     const showToolbar = !isMessageVariant || isFocused;
     const placeholder = mode === "ask" ? "\u6709\u4EC0\u4E48\u95EE\u9898\u60F3\u95EE\u6211\uFF1F" : "\u63CF\u8FF0\u4EFB\u52A1\uFF0C@ \u6DFB\u52A0\u4E0A\u4E0B\u6587";
-    const hasContent = useMemo9(() => {
+    const hasContent = useMemo11(() => {
       return inputText.trim() || imageUpload.hasImages;
     }, [inputText, imageUpload.hasImages]);
-    const adjustTextareaHeight = useCallback10(() => {
+    const voiceCtl = useVoiceToTextInput({
+      adapter,
+      inputText,
+      setInputText,
+      hasImages: imageUpload.hasImages,
+      isLoading
+    });
+    const voiceInput = voiceCtl.voiceInput;
+    const toggleVoiceInput = useCallback12(async () => {
+      await voiceCtl.toggleVoice();
+      if (voiceInput.status === "recording" || voiceInput.status === "connecting") {
+        pendingFocusRef.current = true;
+        pendingCaretRef.current = null;
+      }
+    }, [voiceCtl, voiceInput.status]);
+    const adjustTextareaHeight = useCallback12(() => {
       if (inputRef.current) {
         inputRef.current.style.height = "auto";
         const scrollHeight = inputRef.current.scrollHeight;
@@ -2953,7 +3383,7 @@ var ChatInput = forwardRef7(
       }),
       [inputText, imageUpload]
     );
-    const handleSendOrCancel = useCallback10(() => {
+    const handleSendOrCancel = useCallback12(() => {
       if (isLoading) {
         onCancel?.();
         return;
@@ -2974,16 +3404,17 @@ var ChatInput = forwardRef7(
         setIsFocused(false);
       }
     }, [isLoading, inputText, imageUpload, isMessageVariant, onCancel, onSend]);
-    const handleKeyDown = useCallback10(
+    const handleKeyDown = useCallback12(
       (e) => {
+        if (voiceCtl.handleKeyDownForVoice(e)) return;
         if (e.key === "Enter" && !e.shiftKey) {
           e.preventDefault();
           handleSendOrCancel();
         }
       },
-      [handleSendOrCancel]
+      [handleSendOrCancel, voiceCtl]
     );
-    useEffect10(() => {
+    useEffect12(() => {
       const handleClickOutside = (event) => {
         const target = event.target;
         if (!target.closest(".at-picker-wrapper")) {
@@ -3007,7 +3438,7 @@ var ChatInput = forwardRef7(
           "div",
           {
             ref: containerRef,
-            className: `input-container${isFocused ? " focused" : ""}${imageUpload.isDragOver ? " drag-over" : ""}`.trim(),
+            className: `input-container${isFocused ? " focused" : ""}${imageUpload.isDragOver ? " drag-over" : ""}${voiceInput.status === "connecting" ? " connecting" : ""}${voiceInput.isRecording ? " recording" : ""}`.trim(),
             children: [
               imageUpload.hasImages && /* @__PURE__ */ jsx24("div", { className: "images-preview", children: imageUpload.images.map((img, i) => /* @__PURE__ */ jsxs17("div", { className: "image-preview-item", children: [
                 /* @__PURE__ */ jsx24(
@@ -3050,6 +3481,7 @@ var ChatInput = forwardRef7(
                   placeholder,
                   rows: 1,
                   className: "input-field chat-scrollbar",
+                  readOnly: voiceInput.isRecording,
                   spellCheck: false,
                   autoCorrect: "off",
                   autoComplete: "off",
@@ -3148,15 +3580,27 @@ var ChatInput = forwardRef7(
                       ]
                     }
                   ),
-                  hasContent || isLoading ? /* @__PURE__ */ jsx24(
+                  /* @__PURE__ */ jsx24(
+                    "button",
+                    {
+                      className: `voice-btn${voiceInput.status === "connecting" ? " connecting" : ""}${voiceInput.isRecording ? " recording" : ""}`,
+                      title: voiceInput.status === "connecting" ? "\u6B63\u5728\u8FDE\u63A5\uFF0C\u70B9\u51FB\u53D6\u6D88" : voiceInput.isRecording ? "\u70B9\u51FB\u505C\u6B62" : "\u70B9\u51FB\u5F55\u97F3",
+                      onClick: () => toggleVoiceInput().catch(() => {
+                      }),
+                      disabled: isLoading || !adapter,
+                      children: voiceInput.status === "connecting" ? /* @__PURE__ */ jsx24(Icon17, { icon: "lucide:loader-2", width: 18, className: "spin" }) : voiceInput.isRecording ? /* @__PURE__ */ jsx24(Icon17, { icon: "streamline-flex:button-pause-circle-remix", width: 18 }) : /* @__PURE__ */ jsx24(Icon17, { icon: "lucide:mic", width: 18 })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx24(
                     "button",
                     {
                       className: `send-btn${isLoading ? " loading" : ""}`,
-                      title: isLoading ? "\u505C\u6B62" : isMessageVariant ? "\u91CD\u65B0\u53D1\u9001" : "\u53D1\u9001",
+                      title: isLoading ? "\u505C\u6B62" : voiceInput.status === "connecting" ? "\u8BED\u97F3\u8FDE\u63A5\u4E2D\uFF0C\u5148\u53D6\u6D88/\u505C\u6B62" : voiceInput.isRecording ? "\u5F55\u97F3\u4E2D\uFF0C\u5148\u505C\u6B62" : isMessageVariant ? "\u91CD\u65B0\u53D1\u9001" : "\u53D1\u9001",
                       onClick: handleSendOrCancel,
+                      disabled: !hasContent && !isLoading || voiceInput.isRecording || voiceInput.status === "connecting",
                       children: isLoading ? /* @__PURE__ */ jsx24(Icon17, { icon: "streamline-flex:button-pause-circle-remix", width: 18 }) : /* @__PURE__ */ jsx24(Icon17, { icon: "streamline-flex:mail-send-email-message-circle-remix", width: 18 })
                     }
-                  ) : /* @__PURE__ */ jsx24("button", { className: "icon-btn", title: "\u8BED\u97F3\u8F93\u5165", children: /* @__PURE__ */ jsx24(Icon17, { icon: "lucide:mic", width: 18 }) })
+                  )
                 ] })
               ] })
             ]
@@ -3205,15 +3649,15 @@ var MessageBubble = ({
   const isUser = role === "user";
   const formattedTime = formatTime2(timestamp);
   const inputContext = useChatInputContext();
-  const userText = useMemo10(() => {
+  const userText = useMemo12(() => {
     return parts.filter((p) => p.type === "text").map((p) => p.text).join("");
   }, [parts]);
-  const hasContent = useMemo10(() => {
+  const hasContent = useMemo12(() => {
     return parts.some(
       (p) => p.type === "text" && p.text || p.type === "tool_result" || p.type === "thinking" || p.type === "search"
     );
   }, [parts]);
-  const loadingState = useMemo10(() => {
+  const loadingState = useMemo12(() => {
     if (!loading) {
       return { type: "none" };
     }
@@ -3301,7 +3745,7 @@ var MessageBubble = ({
 };
 
 // src/components/common/ConfirmDialog.tsx
-import { useEffect as useEffect11 } from "react";
+import { useEffect as useEffect13 } from "react";
 import { createPortal as createPortal3 } from "react-dom";
 import { Icon as Icon19 } from "@iconify/react";
 import { jsx as jsx26, jsxs as jsxs19 } from "react/jsx-runtime";
@@ -3315,7 +3759,7 @@ var ConfirmDialog = ({
   onConfirm,
   onCancel
 }) => {
-  useEffect11(() => {
+  useEffect13(() => {
     const handleKeyDown = (e) => {
       if (e.key === "Escape" && visible) {
         onCancel?.();
@@ -3324,7 +3768,7 @@ var ConfirmDialog = ({
     document.addEventListener("keydown", handleKeyDown);
     return () => document.removeEventListener("keydown", handleKeyDown);
   }, [visible, onCancel]);
-  useEffect11(() => {
+  useEffect13(() => {
     if (visible) {
       document.body.style.overflow = "hidden";
     } else {
@@ -3357,7 +3801,7 @@ var ConfirmDialog = ({
 };
 
 // src/components/common/Toast.tsx
-import { useEffect as useEffect12 } from "react";
+import { useEffect as useEffect14 } from "react";
 import { createPortal as createPortal4 } from "react-dom";
 import { jsx as jsx27 } from "react/jsx-runtime";
 var Toast = ({
@@ -3367,7 +3811,7 @@ var Toast = ({
   duration = 2e3,
   onClose
 }) => {
-  useEffect12(() => {
+  useEffect14(() => {
     if (visible && duration > 0) {
       const timer = setTimeout(() => {
         onClose();
@@ -3383,32 +3827,32 @@ var Toast = ({
 };
 
 // src/components/common/SettingsPanel.tsx
-import { useState as useState17, useCallback as useCallback12, useMemo as useMemo11 } from "react";
+import { useState as useState18, useCallback as useCallback14, useMemo as useMemo13 } from "react";
 import { Icon as Icon21 } from "@iconify/react";
 
 // src/components/common/IndexingSettings.tsx
-import { useState as useState16, useEffect as useEffect13, useCallback as useCallback11, useRef as useRef8 } from "react";
+import { useState as useState17, useEffect as useEffect15, useCallback as useCallback13, useRef as useRef10 } from "react";
 import { Icon as Icon20 } from "@iconify/react";
 import { jsx as jsx28, jsxs as jsxs20 } from "react/jsx-runtime";
 function IndexingSettings() {
-  const [indexedFiles, setIndexedFiles] = useState16(0);
-  const [isIndexing, setIsIndexing] = useState16(false);
-  const [currentFile, setCurrentFile] = useState16(null);
-  const [progressPercentage, setProgressPercentage] = useState16(100);
-  const [progressIndexed, setProgressIndexed] = useState16(0);
-  const [progressTotal, setProgressTotal] = useState16(0);
-  const [currentStage, setCurrentStage] = useState16(null);
-  const [showDeleteConfirm, setShowDeleteConfirm] = useState16(false);
-  const [indexSize, setIndexSize] = useState16("0 B");
-  const [lastUpdated, setLastUpdated] = useState16(null);
-  const cancelIndexingRef = useRef8(false);
-  const formatSize = useCallback11((bytes) => {
+  const [indexedFiles, setIndexedFiles] = useState17(0);
+  const [isIndexing, setIsIndexing] = useState17(false);
+  const [currentFile, setCurrentFile] = useState17(null);
+  const [progressPercentage, setProgressPercentage] = useState17(100);
+  const [progressIndexed, setProgressIndexed] = useState17(0);
+  const [progressTotal, setProgressTotal] = useState17(0);
+  const [currentStage, setCurrentStage] = useState17(null);
+  const [showDeleteConfirm, setShowDeleteConfirm] = useState17(false);
+  const [indexSize, setIndexSize] = useState17("0 B");
+  const [lastUpdated, setLastUpdated] = useState17(null);
+  const cancelIndexingRef = useRef10(false);
+  const formatSize = useCallback13((bytes) => {
     if (bytes < 1024) return `${bytes} B`;
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
     if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
     return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
   }, []);
-  const formatDate = useCallback11((date) => {
+  const formatDate = useCallback13((date) => {
     const now = /* @__PURE__ */ new Date();
     const diff = now.getTime() - date.getTime();
     const days = Math.floor(diff / (1e3 * 60 * 60 * 24));
@@ -3426,7 +3870,7 @@ function IndexingSettings() {
     if (days < 365) return `${Math.floor(days / 30)} \u4E2A\u6708\u524D`;
     return date.toLocaleDateString("zh-CN", { year: "numeric", month: "short", day: "numeric" });
   }, []);
-  const fetchIndexStats = useCallback11(async () => {
+  const fetchIndexStats = useCallback13(async () => {
     try {
       const bridge = window.aiChatBridge;
       if (bridge?.getIndexStats) {
@@ -3447,8 +3891,8 @@ function IndexingSettings() {
       setLastUpdated(null);
     }
   }, [formatSize, formatDate]);
-  const progressCleanupRef = useRef8(null);
-  const setupProgressListener = useCallback11(() => {
+  const progressCleanupRef = useRef10(null);
+  const setupProgressListener = useCallback13(() => {
     if (progressCleanupRef.current) {
       progressCleanupRef.current();
       progressCleanupRef.current = null;
@@ -3493,7 +3937,7 @@ function IndexingSettings() {
       }
     });
   }, [fetchIndexStats]);
-  const checkIndexStatus = useCallback11(async () => {
+  const checkIndexStatus = useCallback13(async () => {
     const bridge = window.aiChatBridge;
     if (!bridge?.getIndexStatus) {
       return;
@@ -3519,7 +3963,7 @@ function IndexingSettings() {
       console.error("\u68C0\u67E5\u7D22\u5F15\u72B6\u6001\u5931\u8D25:", error);
     }
   }, []);
-  const handleSync = useCallback11(async () => {
+  const handleSync = useCallback13(async () => {
     if (isIndexing) return;
     const bridge = window.aiChatBridge;
     if (!bridge?.syncIndex) {
@@ -3546,7 +3990,7 @@ function IndexingSettings() {
       setCurrentFile(null);
     }
   }, [isIndexing, setupProgressListener]);
-  const handleCancelIndex = useCallback11(async () => {
+  const handleCancelIndex = useCallback13(async () => {
     cancelIndexingRef.current = true;
     setIsIndexing(false);
     setCurrentFile(null);
@@ -3559,7 +4003,7 @@ function IndexingSettings() {
       }
     }
   }, []);
-  const handleDeleteIndex = useCallback11(async () => {
+  const handleDeleteIndex = useCallback13(async () => {
     if (isIndexing) return;
     setShowDeleteConfirm(false);
     const bridge = window.aiChatBridge;
@@ -3574,7 +4018,7 @@ function IndexingSettings() {
       console.error("\u5220\u9664\u7D22\u5F15\u5931\u8D25:", error);
     }
   }, [isIndexing, fetchIndexStats]);
-  useEffect13(() => {
+  useEffect15(() => {
     const init = async () => {
       const bridge = window.aiChatBridge;
       if (bridge?.registerIndexListener) {
@@ -3590,7 +4034,7 @@ function IndexingSettings() {
     };
     init();
   }, [fetchIndexStats, setupProgressListener, checkIndexStatus]);
-  useEffect13(() => {
+  useEffect15(() => {
     return () => {
       const bridge = window.aiChatBridge;
       if (bridge?.unregisterIndexListener) {
@@ -3717,8 +4161,8 @@ var sections = [
   { id: "indexing", label: "\u7D22\u5F15\u4E0E\u6587\u6863", icon: "lucide:database" }
 ];
 function SettingsPanel({ visible, config, onClose, onChange }) {
-  const [currentSection, setCurrentSection] = useState17("agent");
-  const currentSectionLabel = useMemo11(
+  const [currentSection, setCurrentSection] = useState18("agent");
+  const currentSectionLabel = useMemo13(
     () => sections.find((s) => s.id === currentSection)?.label ?? "",
     [currentSection]
   );
@@ -3726,13 +4170,13 @@ function SettingsPanel({ visible, config, onClose, onChange }) {
     { value: "run-everything", label: "\u8FD0\u884C\u6240\u6709\u5185\u5BB9\uFF08\u81EA\u52A8\u6267\u884C\uFF09" },
     { value: "manual", label: "\u624B\u52A8\u6279\u51C6\uFF08\u6BCF\u6B21\u6267\u884C\u524D\u8BE2\u95EE\uFF09" }
   ];
-  const updateConfig = useCallback12((key, value) => {
+  const updateConfig = useCallback14((key, value) => {
     onChange({ ...config, [key]: value });
   }, [config, onChange]);
-  const handleModeChange = useCallback12((value) => {
+  const handleModeChange = useCallback14((value) => {
     updateConfig("mode", value);
   }, [updateConfig]);
-  const handleOverlayClick = useCallback12((e) => {
+  const handleOverlayClick = useCallback14((e) => {
     if (e.target === e.currentTarget) {
       onClose();
     }
@@ -3796,13 +4240,13 @@ var ChatPanel = forwardRef8(({
   toolRenderers = {},
   stepsExpandedType = "auto"
 }, ref) => {
-  const messagesRef = useRef9(null);
-  const inputRef = useRef9(null);
-  const [shouldAutoScroll, setShouldAutoScroll] = useState18(true);
+  const messagesRef = useRef11(null);
+  const inputRef = useRef11(null);
+  const [shouldAutoScroll, setShouldAutoScroll] = useState19(true);
   const SCROLL_THRESHOLD = 100;
-  const [settingsPanelVisible, setSettingsPanelVisible] = useState18(false);
-  const [models, setModels] = useState18(propModels || []);
-  const [confirmDialog, setConfirmDialog] = useState18({
+  const [settingsPanelVisible, setSettingsPanelVisible] = useState19(false);
+  const [models, setModels] = useState19(propModels || []);
+  const [confirmDialog, setConfirmDialog] = useState19({
     visible: false,
     title: "\u786E\u8BA4",
     message: "",
@@ -3811,7 +4255,7 @@ var ChatPanel = forwardRef8(({
     onConfirm: () => {
     }
   });
-  const showConfirm = useCallback13((options) => {
+  const showConfirm = useCallback15((options) => {
     setConfirmDialog({
       visible: true,
       title: options.title || "\u786E\u8BA4",
@@ -3821,8 +4265,8 @@ var ChatPanel = forwardRef8(({
       onConfirm: options.onConfirm
     });
   }, []);
-  const [toast, setToast] = useState18({ visible: false, message: "", type: "info" });
-  const showToast = useCallback13((message, type = "info") => {
+  const [toast, setToast] = useState19({ visible: false, message: "", type: "info" });
+  const showToast = useCallback15((message, type = "info") => {
     setToast({ visible: true, message, type });
   }, []);
   const {
@@ -3874,61 +4318,61 @@ var ChatPanel = forwardRef8(({
     },
     setCwd: setWorkingDirectory
   }), [sendMessage, setWorkingDirectory]);
-  useEffect14(() => {
+  useEffect16(() => {
     loadSessions();
   }, [loadSessions]);
-  useEffect14(() => {
+  useEffect16(() => {
     adapter.getModels().then(setModels).catch((err) => console.warn("\u83B7\u53D6\u6A21\u578B\u5217\u8868\u5931\u8D25:", err));
   }, [adapter]);
-  const isNearBottom = useCallback13(() => {
+  const isNearBottom = useCallback15(() => {
     if (!messagesRef.current) return true;
     const { scrollTop, scrollHeight, clientHeight } = messagesRef.current;
     return scrollHeight - scrollTop - clientHeight < SCROLL_THRESHOLD;
   }, []);
-  const handleScroll = useCallback13(() => {
+  const handleScroll = useCallback15(() => {
     setShouldAutoScroll(isNearBottom());
   }, [isNearBottom]);
-  const scrollToBottom = useCallback13((force = false) => {
+  const scrollToBottom = useCallback15((force = false) => {
     if (messagesRef.current && (force || shouldAutoScroll)) {
       messagesRef.current.scrollTop = messagesRef.current.scrollHeight;
       setShouldAutoScroll(true);
     }
   }, [shouldAutoScroll]);
-  useEffect14(() => {
+  useEffect16(() => {
     scrollToBottom();
   }, [messages, scrollToBottom]);
-  const prevIsLoadingRef = useRef9(isLoading);
-  useEffect14(() => {
+  const prevIsLoadingRef = useRef11(isLoading);
+  useEffect16(() => {
     if (isLoading && !prevIsLoadingRef.current) {
       scrollToBottom(true);
     }
     prevIsLoadingRef.current = isLoading;
   }, [isLoading, scrollToBottom]);
-  const handleSend = useCallback13((text) => {
+  const handleSend = useCallback15((text) => {
     sendMessage(text);
   }, [sendMessage]);
-  const handleAtContext = useCallback13(() => {
+  const handleAtContext = useCallback15(() => {
     console.log("@ \u4E0A\u4E0B\u6587");
   }, []);
-  const handleQuickAction = useCallback13(
+  const handleQuickAction = useCallback15(
     (text) => {
       sendMessage(text);
     },
     [sendMessage]
   );
-  const handleResend = useCallback13(
+  const handleResend = useCallback15(
     (_index, text) => {
       sendMessage(text);
     },
     [sendMessage]
   );
-  const handleClose = useCallback13(() => {
+  const handleClose = useCallback15(() => {
     onClose?.();
   }, [onClose]);
-  const handleSettings = useCallback13(() => {
+  const handleSettings = useCallback15(() => {
     setSettingsPanelVisible(true);
   }, []);
-  const handleSaveSettings = useCallback13(async (config) => {
+  const handleSaveSettings = useCallback15(async (config) => {
     try {
       await saveAutoRunConfig(config);
     } catch (error) {
@@ -3936,7 +4380,7 @@ var ChatPanel = forwardRef8(({
       showToast("\u4FDD\u5B58\u8BBE\u7F6E\u5931\u8D25", "error");
     }
   }, [saveAutoRunConfig, showToast]);
-  const handleClearAll = useCallback13(() => {
+  const handleClearAll = useCallback15(() => {
     showConfirm({
       title: "\u6E05\u7A7A\u6240\u6709\u5BF9\u8BDD",
       message: "\u786E\u5B9A\u8981\u6E05\u7A7A\u6240\u6709\u5BF9\u8BDD\u5417\uFF1F\u6B64\u64CD\u4F5C\u4E0D\u53EF\u6062\u590D\u3002",
@@ -3945,10 +4389,10 @@ var ChatPanel = forwardRef8(({
       onConfirm: () => clearAllSessions()
     });
   }, [showConfirm, clearAllSessions]);
-  const handleCloseOthers = useCallback13(async () => {
+  const handleCloseOthers = useCallback15(async () => {
     await hideOtherSessions();
   }, [hideOtherSessions]);
-  const handleExport = useCallback13(() => {
+  const handleExport = useCallback15(() => {
     const data = exportCurrentSession();
     if (!data) {
       showToast("\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5185\u5BB9\u53EF\u5BFC\u51FA", "warning");
@@ -3966,7 +4410,7 @@ var ChatPanel = forwardRef8(({
     document.body.removeChild(a);
     URL.revokeObjectURL(url);
   }, [exportCurrentSession, sessions, currentSessionId, showToast]);
-  const handleCopyId = useCallback13(async () => {
+  const handleCopyId = useCallback15(async () => {
     if (!currentSessionId) return;
     try {
       await navigator.clipboard.writeText(currentSessionId);
@@ -3975,10 +4419,10 @@ var ChatPanel = forwardRef8(({
       console.error("\u590D\u5236\u5931\u8D25:", error);
     }
   }, [currentSessionId, showToast]);
-  const handleFeedback = useCallback13(() => {
+  const handleFeedback = useCallback15(() => {
     console.log("\u53CD\u9988");
   }, []);
-  const inputContextValue = useMemo12(
+  const inputContextValue = useMemo14(
     () => ({
       mode,
       model,
@@ -4106,7 +4550,7 @@ var ChatPanel = forwardRef8(({
 ChatPanel.displayName = "ChatPanel";
 
 // src/components/message/ContentRenderer.tsx
-import { useMemo as useMemo14, useContext as useContext3 } from "react";
+import { useMemo as useMemo16, useContext as useContext3 } from "react";
 import { parseContent } from "@huyooo/ai-chat-shared";
 
 // src/components/message/blocks/TextBlock.tsx
@@ -4116,21 +4560,21 @@ var TextBlock = ({ block }) => {
 };
 
 // src/components/message/blocks/CodeBlock.tsx
-import { useState as useState19, useCallback as useCallback14, useMemo as useMemo13 } from "react";
+import { useState as useState20, useCallback as useCallback16, useMemo as useMemo15 } from "react";
 import { Icon as Icon23 } from "@iconify/react";
 import { highlightCode, getLanguageDisplayName } from "@huyooo/ai-chat-shared";
 import { jsx as jsx32, jsxs as jsxs23 } from "react/jsx-runtime";
 var CodeBlock = ({ block, onCopy }) => {
-  const [copied, setCopied] = useState19(false);
-  const languageDisplay = useMemo13(
+  const [copied, setCopied] = useState20(false);
+  const languageDisplay = useMemo15(
     () => getLanguageDisplayName(block.language),
     [block.language]
   );
-  const highlightedCode = useMemo13(
+  const highlightedCode = useMemo15(
     () => highlightCode(block.content, block.language),
     [block.content, block.language]
   );
-  const handleCopy = useCallback14(async () => {
+  const handleCopy = useCallback16(async () => {
     try {
       await navigator.clipboard.writeText(block.content);
       setCopied(true);
@@ -4157,7 +4601,7 @@ var ContentRenderer = ({
   onCodeCopy
 }) => {
   const customRenderers = useContext3(BlockRenderersContext);
-  const blocks = useMemo14(() => {
+  const blocks = useMemo16(() => {
     if (preBlocks?.length) {
       return preBlocks;
     }
@@ -4181,13 +4625,13 @@ var ContentRenderer = ({
 };
 
 // src/components/message/ToolResultRenderer.tsx
-import { useContext as useContext4, useMemo as useMemo18 } from "react";
+import { useContext as useContext4, useMemo as useMemo20 } from "react";
 
 // src/components/message/tool-results/DefaultToolResult.tsx
-import { useMemo as useMemo15 } from "react";
+import { useMemo as useMemo17 } from "react";
 import { jsx as jsx34 } from "react/jsx-runtime";
 var DefaultToolResult = ({ toolResult }) => {
-  const formattedResult = useMemo15(() => {
+  const formattedResult = useMemo17(() => {
     if (typeof toolResult === "string") {
       return toolResult;
     }
@@ -4201,11 +4645,11 @@ var DefaultToolResult = ({ toolResult }) => {
 };
 
 // src/components/message/tool-results/WeatherCard.tsx
-import { useMemo as useMemo16 } from "react";
+import { useMemo as useMemo18 } from "react";
 import { Icon as Icon24 } from "@iconify/react";
 import { jsx as jsx35, jsxs as jsxs24 } from "react/jsx-runtime";
 var WeatherCard = ({ toolResult }) => {
-  const weather = useMemo16(() => {
+  const weather = useMemo18(() => {
     if (typeof toolResult === "object" && toolResult !== null) {
       return toolResult;
     }
@@ -4254,11 +4698,11 @@ var WeatherCard = ({ toolResult }) => {
 };
 
 // src/components/message/tool-results/SearchResults.tsx
-import { useMemo as useMemo17, useCallback as useCallback15 } from "react";
+import { useMemo as useMemo19, useCallback as useCallback17 } from "react";
 import { Icon as Icon25 } from "@iconify/react";
 import { jsx as jsx36, jsxs as jsxs25 } from "react/jsx-runtime";
 var SearchResults = ({ toolResult }) => {
-  const results = useMemo17(() => {
+  const results = useMemo19(() => {
     if (Array.isArray(toolResult)) {
       return toolResult;
     }
@@ -4267,14 +4711,14 @@ var SearchResults = ({ toolResult }) => {
     }
     return [];
   }, [toolResult]);
-  const getDomain = useCallback15((url) => {
+  const getDomain = useCallback17((url) => {
     try {
       return new URL(url).hostname;
     } catch {
       return url;
     }
   }, []);
-  const openExternal = useCallback15((url) => {
+  const openExternal = useCallback17((url) => {
     const bridge = window.aiChatBridge;
     if (bridge?.openExternal) {
       bridge.openExternal(url);
@@ -4317,7 +4761,7 @@ var SearchResults = ({ toolResult }) => {
 import { jsx as jsx37 } from "react/jsx-runtime";
 var ToolResultRenderer = (props) => {
   const customRenderers = useContext4(ToolRenderersContext);
-  const Component = useMemo18(() => {
+  const Component = useMemo20(() => {
     return customRenderers[props.toolName] || DefaultToolResult;
   }, [customRenderers, props.toolName]);
   return /* @__PURE__ */ jsx37(Component, { ...props });