@yushaw/sanqian-chat 0.1.1

package/dist/renderer/index.mjs

@@ -0,0 +1,1131 @@
+// src/renderer/hooks/useChat.ts
+import { useState, useCallback, useRef, useEffect } from "react";
+var TYPEWRITER_DELAYS = { VERY_FAST: 2, FAST: 5, NORMAL: 10, SLOW: 20 };
+var TYPEWRITER_THRESHOLDS = { VERY_FAST: 100, FAST: 50, NORMAL: 20 };
+function useChat(options) {
+  const { adapter, onError, onConversationChange } = options;
+  const [messages, setMessages] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [error, setError] = useState(null);
+  const [conversationId, setConversationId] = useState(options.conversationId ?? null);
+  const [conversationTitle, setConversationTitle] = useState(null);
+  const [pendingInterrupt, setPendingInterrupt] = useState(null);
+  const cancelRef = useRef(null);
+  const isMountedRef = useRef(true);
+  const messagesRef = useRef(messages);
+  const conversationIdRef = useRef(conversationId);
+  const currentRunIdRef = useRef(null);
+  const currentBlocksRef = useRef([]);
+  const currentTextBlockIndexRef = useRef(-1);
+  const needsContentClearRef = useRef(false);
+  const fullContentRef = useRef("");
+  const tokenQueueRef = useRef([]);
+  const displayedContentRef = useRef("");
+  const typewriterIntervalRef = useRef(null);
+  const currentAssistantMessageIdRef = useRef(null);
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  useEffect(() => {
+    conversationIdRef.current = conversationId;
+  }, [conversationId]);
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      cancelRef.current?.();
+      if (typewriterIntervalRef.current) clearTimeout(typewriterIntervalRef.current);
+    };
+  }, []);
+  const flushTypewriter = useCallback(() => {
+    if (typewriterIntervalRef.current) {
+      clearTimeout(typewriterIntervalRef.current);
+      typewriterIntervalRef.current = null;
+    }
+    if (tokenQueueRef.current.length > 0 && currentAssistantMessageIdRef.current) {
+      displayedContentRef.current += tokenQueueRef.current.join("");
+      tokenQueueRef.current = [];
+      setMessages((prev) => {
+        const idx = prev.findIndex((m) => m.id === currentAssistantMessageIdRef.current);
+        if (idx === -1) return prev;
+        const updated = [...prev];
+        updated[idx] = { ...prev[idx], content: displayedContentRef.current, blocks: [...currentBlocksRef.current] };
+        return updated;
+      });
+    }
+  }, []);
+  const handleStreamEvent = useCallback((event, assistantMessageId) => {
+    if (!isMountedRef.current) return;
+    currentAssistantMessageIdRef.current = assistantMessageId;
+    switch (event.type) {
+      case "text": {
+        const content = event.content;
+        if (!content) break;
+        if (needsContentClearRef.current || fullContentRef.current === "") {
+          flushTypewriter();
+          needsContentClearRef.current = false;
+          fullContentRef.current = "";
+          displayedContentRef.current = "";
+          currentBlocksRef.current.forEach((b) => {
+            if (b.type === "text") b.isIntermediate = true;
+          });
+          currentBlocksRef.current.push({ type: "text", content: "", timestamp: Date.now(), isIntermediate: false });
+          currentTextBlockIndexRef.current = currentBlocksRef.current.length - 1;
+        }
+        const textToAdd = fullContentRef.current === "" ? content.trimStart() : content;
+        fullContentRef.current += textToAdd;
+        if (currentTextBlockIndexRef.current >= 0) {
+          currentBlocksRef.current[currentTextBlockIndexRef.current].content += textToAdd;
+        }
+        tokenQueueRef.current.push(...textToAdd.split(""));
+        if (!typewriterIntervalRef.current) {
+          const tick = () => {
+            const char = tokenQueueRef.current.shift();
+            if (char !== void 0) {
+              displayedContentRef.current += char;
+              setMessages((prev) => {
+                const idx = prev.findIndex((m) => m.id === assistantMessageId);
+                if (idx === -1) return prev;
+                const updated = [...prev];
+                updated[idx] = { ...prev[idx], content: displayedContentRef.current, isStreaming: true, blocks: [...currentBlocksRef.current] };
+                return updated;
+              });
+              const qLen = tokenQueueRef.current.length;
+              const delay = qLen > TYPEWRITER_THRESHOLDS.VERY_FAST ? TYPEWRITER_DELAYS.VERY_FAST : qLen > TYPEWRITER_THRESHOLDS.FAST ? TYPEWRITER_DELAYS.FAST : qLen > TYPEWRITER_THRESHOLDS.NORMAL ? TYPEWRITER_DELAYS.NORMAL : TYPEWRITER_DELAYS.SLOW;
+              if (typewriterIntervalRef.current !== null) {
+                typewriterIntervalRef.current = setTimeout(tick, delay);
+              }
+            } else {
+              typewriterIntervalRef.current = null;
+            }
+          };
+          typewriterIntervalRef.current = setTimeout(tick, TYPEWRITER_DELAYS.SLOW);
+        }
+        break;
+      }
+      case "thinking": {
+        const content = event.content;
+        if (!content) break;
+        let thinkingBlockIdx = currentBlocksRef.current.findIndex((b) => b.type === "thinking" && !b.isIntermediate);
+        if (thinkingBlockIdx === -1) {
+          currentBlocksRef.current.push({ type: "thinking", content: "", timestamp: Date.now(), isIntermediate: false });
+          thinkingBlockIdx = currentBlocksRef.current.length - 1;
+        }
+        currentBlocksRef.current[thinkingBlockIdx].content += content;
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === assistantMessageId);
+          if (idx === -1) return prev;
+          const updated = [...prev];
+          const msg = prev[idx];
+          updated[idx] = {
+            ...msg,
+            thinking: (msg.thinking || "") + content,
+            currentThinking: (msg.currentThinking || "") + content,
+            isThinkingStreaming: true,
+            blocks: [...currentBlocksRef.current]
+          };
+          return updated;
+        });
+        break;
+      }
+      case "tool_call": {
+        flushTypewriter();
+        const tc = event.tool_call;
+        if (!tc) break;
+        needsContentClearRef.current = true;
+        let args = {};
+        try {
+          args = JSON.parse(tc.function?.arguments || "{}");
+        } catch (e) {
+          console.warn("[useChat] Failed to parse tool arguments:", e);
+        }
+        currentBlocksRef.current.push({
+          type: "tool_call",
+          content: "",
+          timestamp: Date.now(),
+          toolName: tc.function?.name || "",
+          toolArgs: args,
+          toolCallId: tc.id,
+          toolStatus: "running",
+          isIntermediate: true
+        });
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === assistantMessageId);
+          if (idx === -1) return prev;
+          const msg = prev[idx];
+          const newTc = { id: tc.id, name: tc.function?.name || "", arguments: args, status: "running" };
+          const updated = [...prev];
+          updated[idx] = { ...msg, toolCalls: [...msg.toolCalls || [], newTc], blocks: [...currentBlocksRef.current] };
+          return updated;
+        });
+        break;
+      }
+      case "tool_result": {
+        flushTypewriter();
+        const toolId = event.tool_call_id;
+        const result = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+        const blockIdx = currentBlocksRef.current.findIndex((b) => b.type === "tool_call" && b.toolCallId === toolId);
+        if (blockIdx !== -1) currentBlocksRef.current[blockIdx].toolStatus = "completed";
+        currentBlocksRef.current.push({ type: "tool_result", content: result, timestamp: Date.now(), toolCallId: toolId, isIntermediate: true });
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === assistantMessageId);
+          if (idx === -1) return prev;
+          const msg = prev[idx];
+          const updated = [...prev];
+          updated[idx] = {
+            ...msg,
+            toolCalls: msg.toolCalls?.map((t) => t.id === toolId ? { ...t, status: "completed", result: event.result } : t),
+            blocks: [...currentBlocksRef.current]
+          };
+          return updated;
+        });
+        break;
+      }
+      case "done": {
+        flushTypewriter();
+        const finalContent = fullContentRef.current;
+        if (currentTextBlockIndexRef.current >= 0 && currentTextBlockIndexRef.current < currentBlocksRef.current.length) {
+          currentBlocksRef.current[currentTextBlockIndexRef.current].content = finalContent;
+          currentBlocksRef.current[currentTextBlockIndexRef.current].isIntermediate = false;
+        }
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === assistantMessageId);
+          if (idx === -1) return prev;
+          const updated = [...prev];
+          const msg = prev[idx];
+          updated[idx] = {
+            ...msg,
+            content: finalContent || msg.content,
+            isStreaming: false,
+            isComplete: true,
+            isThinkingStreaming: false,
+            blocks: [...currentBlocksRef.current]
+          };
+          return updated;
+        });
+        currentBlocksRef.current = [];
+        currentTextBlockIndexRef.current = -1;
+        fullContentRef.current = "";
+        needsContentClearRef.current = false;
+        tokenQueueRef.current = [];
+        displayedContentRef.current = "";
+        setConversationId(event.conversationId);
+        if (event.title) setConversationTitle(event.title);
+        onConversationChange?.(event.conversationId, event.title);
+        setIsStreaming(false);
+        setIsLoading(false);
+        break;
+      }
+      case "error": {
+        flushTypewriter();
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === assistantMessageId);
+          if (idx === -1) return prev;
+          const updated = [...prev];
+          updated[idx] = { ...prev[idx], isStreaming: false, isComplete: true, content: prev[idx].content || `Error: ${event.error}` };
+          return updated;
+        });
+        currentBlocksRef.current = [];
+        currentTextBlockIndexRef.current = -1;
+        fullContentRef.current = "";
+        setError(event.error);
+        onError?.(new Error(event.error));
+        setIsStreaming(false);
+        setIsLoading(false);
+        break;
+      }
+      case "interrupt": {
+        flushTypewriter();
+        currentRunIdRef.current = event.run_id ?? null;
+        const payload = event.interrupt_payload;
+        if (payload) {
+          setPendingInterrupt(payload);
+        }
+        break;
+      }
+    }
+  }, [onError, onConversationChange, flushTypewriter]);
+  const sendMessage = useCallback(async (content) => {
+    if (!content.trim()) return;
+    setError(null);
+    if (typewriterIntervalRef.current) {
+      clearTimeout(typewriterIntervalRef.current);
+      typewriterIntervalRef.current = null;
+    }
+    currentBlocksRef.current = [];
+    currentTextBlockIndexRef.current = -1;
+    fullContentRef.current = "";
+    needsContentClearRef.current = false;
+    tokenQueueRef.current = [];
+    displayedContentRef.current = "";
+    const userMessage = { id: crypto.randomUUID(), role: "user", content: content.trim(), timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    const assistantMessage = { id: crypto.randomUUID(), role: "assistant", content: "", timestamp: (/* @__PURE__ */ new Date()).toISOString(), isStreaming: true, toolCalls: [], blocks: [] };
+    setMessages((prev) => [...prev, userMessage, assistantMessage]);
+    setIsLoading(true);
+    setIsStreaming(true);
+    try {
+      if (!adapter.isConnected()) await adapter.connect();
+      const apiMessages = messagesRef.current.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({ role: m.role, content: m.content })).concat({ role: "user", content: content.trim() });
+      const { cancel } = await adapter.chatStream(apiMessages, conversationIdRef.current ?? void 0, (event) => handleStreamEvent(event, assistantMessage.id));
+      cancelRef.current = cancel;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to send message";
+      setError(errorMessage);
+      onError?.(err instanceof Error ? err : new Error(errorMessage));
+      setMessages((prev) => {
+        const idx = prev.findIndex((m) => m.id === assistantMessage.id);
+        if (idx === -1) return prev;
+        const updated = [...prev];
+        updated[idx] = { ...prev[idx], isStreaming: false, content: `Error: ${errorMessage}` };
+        return updated;
+      });
+      setIsLoading(false);
+      setIsStreaming(false);
+    }
+  }, [adapter, handleStreamEvent, onError]);
+  const stopStreaming = useCallback(() => {
+    cancelRef.current?.();
+    cancelRef.current = null;
+    flushTypewriter();
+    setMessages((prev) => {
+      const last = [...prev].reverse().find((m) => m.role === "assistant");
+      if (!last?.isStreaming) return prev;
+      return prev.map((m) => m.id === last.id ? { ...m, content: fullContentRef.current || m.content, isStreaming: false, isComplete: true } : m);
+    });
+    currentBlocksRef.current = [];
+    fullContentRef.current = "";
+    setIsStreaming(false);
+    setIsLoading(false);
+  }, [flushTypewriter]);
+  const clearMessages = useCallback(() => {
+    cancelRef.current?.();
+    if (typewriterIntervalRef.current) clearTimeout(typewriterIntervalRef.current);
+    setMessages([]);
+    setError(null);
+    setIsLoading(false);
+    setIsStreaming(false);
+    currentBlocksRef.current = [];
+    fullContentRef.current = "";
+  }, []);
+  const loadConversation = useCallback(async (id) => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const detail = await adapter.getConversation(id);
+      if (!isMountedRef.current) return;
+      setMessages(detail.messages);
+      setConversationId(detail.id);
+      setConversationTitle(detail.title);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to load conversation";
+      setError(msg);
+      onError?.(err instanceof Error ? err : new Error(msg));
+    } finally {
+      if (isMountedRef.current) setIsLoading(false);
+    }
+  }, [adapter, onError]);
+  const newConversation = useCallback(() => {
+    cancelRef.current?.();
+    if (typewriterIntervalRef.current) clearTimeout(typewriterIntervalRef.current);
+    setMessages([]);
+    setConversationId(null);
+    setConversationTitle(null);
+    setError(null);
+    setIsLoading(false);
+    setIsStreaming(false);
+    setPendingInterrupt(null);
+    currentBlocksRef.current = [];
+    fullContentRef.current = "";
+  }, []);
+  const sendHitlResponse = useCallback((response) => {
+    adapter.sendHitlResponse?.(response, currentRunIdRef.current ?? void 0);
+  }, [adapter]);
+  const approveHitl = useCallback((remember = false) => {
+    sendHitlResponse({ approved: true, remember });
+    setPendingInterrupt(null);
+  }, [sendHitlResponse]);
+  const rejectHitl = useCallback((remember = false) => {
+    sendHitlResponse({ approved: false, remember });
+    setPendingInterrupt(null);
+    setIsLoading(false);
+  }, [sendHitlResponse]);
+  const submitHitlInput = useCallback((response) => {
+    sendHitlResponse(response);
+    setPendingInterrupt(null);
+    if (response.cancelled || response.timed_out) setIsLoading(false);
+  }, [sendHitlResponse]);
+  return {
+    messages,
+    isLoading,
+    isStreaming,
+    error,
+    conversationId,
+    conversationTitle,
+    pendingInterrupt,
+    sendMessage,
+    stopStreaming,
+    clearMessages,
+    setError,
+    approveHitl,
+    rejectHitl,
+    submitHitlInput,
+    loadConversation,
+    newConversation
+  };
+}
+
+// src/renderer/hooks/useTheme.tsx
+import { createContext, useContext, useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+import { jsx } from "react/jsx-runtime";
+var ThemeContext = createContext(null);
+function ThemeProvider({
+  children,
+  defaultTheme = "system",
+  storageKey = "sanqian-chat-theme"
+}) {
+  const [theme, setThemeState] = useState2(() => {
+    if (typeof window !== "undefined") {
+      const stored = localStorage.getItem(storageKey);
+      if (stored === "light" || stored === "dark" || stored === "system") {
+        return stored;
+      }
+    }
+    return defaultTheme;
+  });
+  const [resolvedTheme, setResolvedTheme] = useState2("light");
+  useEffect2(() => {
+    const applyTheme = (resolved) => {
+      const root = document.documentElement;
+      if (resolved === "dark") {
+        root.classList.add("dark");
+      } else {
+        root.classList.remove("dark");
+      }
+      setResolvedTheme(resolved);
+    };
+    if (theme === "system") {
+      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      applyTheme(mediaQuery.matches ? "dark" : "light");
+      const handler = (e) => {
+        applyTheme(e.matches ? "dark" : "light");
+      };
+      mediaQuery.addEventListener("change", handler);
+      return () => mediaQuery.removeEventListener("change", handler);
+    } else {
+      applyTheme(theme);
+    }
+  }, [theme]);
+  const setTheme = useCallback2((newTheme) => {
+    setThemeState(newTheme);
+    if (typeof window !== "undefined") {
+      localStorage.setItem(storageKey, newTheme);
+    }
+  }, [storageKey]);
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value: { theme, resolvedTheme, setTheme }, children });
+}
+function useTheme() {
+  const context = useContext(ThemeContext);
+  if (!context) {
+    throw new Error("useTheme must be used within a ThemeProvider");
+  }
+  return context;
+}
+function useStandaloneTheme(defaultTheme = "system") {
+  const [theme, setThemeState] = useState2(defaultTheme);
+  const [resolvedTheme, setResolvedTheme] = useState2("light");
+  useEffect2(() => {
+    const applyTheme = (resolved) => {
+      const root = document.documentElement;
+      if (resolved === "dark") {
+        root.classList.add("dark");
+      } else {
+        root.classList.remove("dark");
+      }
+      setResolvedTheme(resolved);
+    };
+    if (theme === "system") {
+      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      applyTheme(mediaQuery.matches ? "dark" : "light");
+      const handler = (e) => {
+        applyTheme(e.matches ? "dark" : "light");
+      };
+      mediaQuery.addEventListener("change", handler);
+      return () => mediaQuery.removeEventListener("change", handler);
+    } else {
+      applyTheme(theme);
+    }
+  }, [theme]);
+  const setTheme = useCallback2((newTheme) => {
+    setThemeState(newTheme);
+  }, []);
+  return { theme, resolvedTheme, setTheme };
+}
+
+// src/renderer/hooks/useI18n.tsx
+import { createContext as createContext2, useContext as useContext2, useState as useState3, useCallback as useCallback3, useMemo } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var translations = {
+  en: {
+    hitl: {
+      approvalRequired: "Approval Required",
+      inputRequired: "Input Required",
+      tool: "Tool",
+      approve: "Approve",
+      reject: "Reject",
+      submit: "Submit",
+      cancel: "Cancel"
+    },
+    input: {
+      placeholder: "Type a message...",
+      send: "Send",
+      stop: "Stop"
+    },
+    message: {
+      thinking: "Thinking...",
+      error: "Error",
+      loading: "Loading..."
+    },
+    connection: {
+      connecting: "Connecting...",
+      connected: "Connected",
+      disconnected: "Disconnected",
+      reconnecting: "Reconnecting...",
+      error: "Connection error"
+    },
+    conversation: {
+      new: "New conversation",
+      untitled: "Untitled",
+      delete: "Delete",
+      deleteConfirm: "Are you sure you want to delete this conversation?"
+    }
+  },
+  zh: {
+    hitl: {
+      approvalRequired: "\u9700\u8981\u5BA1\u6279",
+      inputRequired: "\u9700\u8981\u8F93\u5165",
+      tool: "\u5DE5\u5177",
+      approve: "\u6279\u51C6",
+      reject: "\u62D2\u7EDD",
+      submit: "\u63D0\u4EA4",
+      cancel: "\u53D6\u6D88"
+    },
+    input: {
+      placeholder: "\u8F93\u5165\u6D88\u606F...",
+      send: "\u53D1\u9001",
+      stop: "\u505C\u6B62"
+    },
+    message: {
+      thinking: "\u601D\u8003\u4E2D...",
+      error: "\u9519\u8BEF",
+      loading: "\u52A0\u8F7D\u4E2D..."
+    },
+    connection: {
+      connecting: "\u8FDE\u63A5\u4E2D...",
+      connected: "\u5DF2\u8FDE\u63A5",
+      disconnected: "\u5DF2\u65AD\u5F00",
+      reconnecting: "\u91CD\u65B0\u8FDE\u63A5\u4E2D...",
+      error: "\u8FDE\u63A5\u9519\u8BEF"
+    },
+    conversation: {
+      new: "\u65B0\u5BF9\u8BDD",
+      untitled: "\u672A\u547D\u540D",
+      delete: "\u5220\u9664",
+      deleteConfirm: "\u786E\u5B9A\u8981\u5220\u9664\u8FD9\u4E2A\u5BF9\u8BDD\u5417\uFF1F"
+    }
+  }
+};
+var I18nContext = createContext2(null);
+function I18nProvider({
+  children,
+  defaultLocale = "en",
+  storageKey = "sanqian-chat-locale",
+  customTranslations
+}) {
+  const [locale, setLocaleState] = useState3(() => {
+    if (typeof window !== "undefined") {
+      const stored = localStorage.getItem(storageKey);
+      if (stored === "en" || stored === "zh") {
+        return stored;
+      }
+      const browserLang = navigator.language.toLowerCase();
+      if (browserLang.startsWith("zh")) {
+        return "zh";
+      }
+    }
+    return defaultLocale;
+  });
+  const setLocale = useCallback3((newLocale) => {
+    setLocaleState(newLocale);
+    if (typeof window !== "undefined") {
+      localStorage.setItem(storageKey, newLocale);
+    }
+  }, [storageKey]);
+  const t = useMemo(() => {
+    const base = translations[locale];
+    const custom = customTranslations?.[locale];
+    if (!custom) return base;
+    return {
+      hitl: { ...base.hitl, ...custom.hitl },
+      input: { ...base.input, ...custom.input },
+      message: { ...base.message, ...custom.message },
+      connection: { ...base.connection, ...custom.connection },
+      conversation: { ...base.conversation, ...custom.conversation }
+    };
+  }, [locale, customTranslations]);
+  return /* @__PURE__ */ jsx2(I18nContext.Provider, { value: { locale, setLocale, t }, children });
+}
+function useI18n() {
+  const context = useContext2(I18nContext);
+  if (!context) {
+    throw new Error("useI18n must be used within an I18nProvider");
+  }
+  return context;
+}
+function useStandaloneI18n(defaultLocale = "en") {
+  const [locale, setLocale] = useState3(defaultLocale);
+  const t = useMemo(() => translations[locale], [locale]);
+  return { locale, setLocale, t };
+}
+function getTranslations(locale) {
+  return translations[locale];
+}
+
+// src/renderer/adapters/ipc.ts
+function createIpcAdapter() {
+  let connectionStatus = "disconnected";
+  const connectionListeners = /* @__PURE__ */ new Set();
+  const streamCallbacks = /* @__PURE__ */ new Map();
+  let streamEventCleanup = null;
+  let currentRunId = null;
+  const api = window.sanqianChat;
+  if (!api) {
+    throw new Error("sanqianChat API not available. Ensure preload script is configured.");
+  }
+  const updateStatus = (status, error, errorCode) => {
+    connectionStatus = status;
+    connectionListeners.forEach((cb) => cb(status, error, errorCode));
+  };
+  streamEventCleanup = api.onStreamEvent((streamId, event) => {
+    const callback = streamCallbacks.get(streamId);
+    if (callback && isValidStreamEvent(event)) {
+      callback(event);
+      if (event.type === "done" || event.type === "error") {
+        streamCallbacks.delete(streamId);
+      }
+    }
+  });
+  return {
+    async connect() {
+      updateStatus("connecting");
+      try {
+        const result = await api.connect();
+        if (result.success) {
+          updateStatus("connected");
+        } else {
+          throw new Error(result.error || "Connection failed");
+        }
+      } catch (e) {
+        updateStatus("error", e instanceof Error ? e.message : "Connection failed", "CONNECTION_FAILED");
+        throw e;
+      }
+    },
+    async disconnect() {
+      updateStatus("disconnected");
+    },
+    isConnected() {
+      return connectionStatus === "connected";
+    },
+    getConnectionStatus() {
+      return connectionStatus;
+    },
+    onConnectionChange(callback) {
+      connectionListeners.add(callback);
+      callback(connectionStatus);
+      return () => connectionListeners.delete(callback);
+    },
+    async listConversations(options) {
+      const result = await api.listConversations(options);
+      if (!result.success) throw new Error(result.error || "Failed to list");
+      const data = result.data;
+      return {
+        conversations: data.conversations.map((c) => ({
+          id: c.conversation_id,
+          title: c.title || "Untitled",
+          createdAt: c.created_at || "",
+          updatedAt: c.updated_at || "",
+          messageCount: c.message_count || 0
+        })),
+        total: data.total
+      };
+    },
+    async getConversation(id, options) {
+      const result = await api.getConversation({ conversationId: id, messageLimit: options?.messageLimit });
+      if (!result.success) throw new Error(result.error || "Failed to get");
+      const data = result.data;
+      return {
+        id: data.conversation_id,
+        title: data.title || "Untitled",
+        createdAt: data.created_at || "",
+        updatedAt: data.updated_at || "",
+        messageCount: data.message_count || 0,
+        messages: (data.messages || []).map((m, i) => ({
+          id: `msg-${i}`,
+          role: m.role,
+          content: m.content,
+          timestamp: m.created_at || (/* @__PURE__ */ new Date()).toISOString()
+        }))
+      };
+    },
+    async deleteConversation(id) {
+      const result = await api.deleteConversation({ conversationId: id });
+      if (!result.success) throw new Error(result.error || "Failed to delete");
+    },
+    async chatStream(messages, conversationId, onEvent) {
+      const streamId = crypto.randomUUID();
+      streamCallbacks.set(streamId, (event) => {
+        if (event.type === "interrupt") {
+          currentRunId = event.run_id || null;
+        }
+        onEvent(event);
+      });
+      try {
+        await api.stream({ streamId, messages, conversationId });
+        return {
+          cancel: async () => {
+            await api.cancelStream({ streamId });
+            streamCallbacks.delete(streamId);
+          }
+        };
+      } catch (e) {
+        streamCallbacks.delete(streamId);
+        throw e;
+      }
+    },
+    sendHitlResponse(response, runId) {
+      api.sendHitlResponse({ response, runId: runId || currentRunId || void 0 });
+    },
+    cleanup() {
+      streamEventCleanup?.();
+      connectionListeners.clear();
+      streamCallbacks.clear();
+    }
+  };
+}
+function isValidStreamEvent(event) {
+  if (!event || typeof event !== "object") return false;
+  const e = event;
+  return typeof e.type === "string";
+}
+
+// src/core/adapter.ts
+function createSdkAdapter(config) {
+  let connectionStatus = "disconnected";
+  const connectionListeners = /* @__PURE__ */ new Set();
+  let currentRunId = null;
+  const updateStatus = (status, error, errorCode) => {
+    connectionStatus = status;
+    connectionListeners.forEach((cb) => cb(status, error, errorCode));
+  };
+  return {
+    async connect() {
+      const sdk = config.getSdk();
+      if (!sdk) throw new Error("SDK not available");
+      updateStatus("connecting");
+      try {
+        await sdk.ensureReady();
+        updateStatus("connected");
+      } catch (e) {
+        updateStatus("error", e instanceof Error ? e.message : "Connection failed", "CONNECTION_FAILED");
+        throw e;
+      }
+    },
+    async disconnect() {
+      updateStatus("disconnected");
+    },
+    isConnected() {
+      const sdk = config.getSdk();
+      return sdk?.isConnected() ?? false;
+    },
+    getConnectionStatus() {
+      return connectionStatus;
+    },
+    onConnectionChange(callback) {
+      connectionListeners.add(callback);
+      callback(connectionStatus);
+      return () => connectionListeners.delete(callback);
+    },
+    async listConversations(options) {
+      const sdk = config.getSdk();
+      const agentId = config.getAgentId();
+      if (!sdk || !agentId) throw new Error("SDK or agent not ready");
+      const result = await sdk.listConversations({ agentId, ...options });
+      return {
+        conversations: result.conversations.map((c) => ({
+          id: c.conversation_id,
+          title: c.title || "Untitled",
+          createdAt: c.created_at || "",
+          updatedAt: c.updated_at || "",
+          messageCount: c.message_count
+        })),
+        total: result.total
+      };
+    },
+    async getConversation(id, options) {
+      const sdk = config.getSdk();
+      if (!sdk) throw new Error("SDK not ready");
+      const detail = await sdk.getConversation(id, { messageLimit: options?.messageLimit });
+      return {
+        id: detail.conversation_id,
+        title: detail.title || "Untitled",
+        createdAt: detail.created_at || "",
+        updatedAt: detail.updated_at || "",
+        messageCount: detail.message_count,
+        messages: (detail.messages || []).map((m, i) => ({
+          id: `msg-${i}`,
+          role: m.role,
+          content: m.content,
+          timestamp: m.created_at || (/* @__PURE__ */ new Date()).toISOString()
+        }))
+      };
+    },
+    async deleteConversation(id) {
+      const sdk = config.getSdk();
+      if (!sdk) throw new Error("SDK not ready");
+      await sdk.deleteConversation(id);
+    },
+    async chatStream(messages, conversationId, onEvent) {
+      const sdk = config.getSdk();
+      const agentId = config.getAgentId();
+      if (!sdk || !agentId) throw new Error("SDK or agent not ready");
+      await sdk.ensureReady();
+      const sdkMessages = messages.map((m) => ({ role: m.role, content: m.content }));
+      const stream = sdk.chatStream(agentId, sdkMessages, { conversationId });
+      const controller = new AbortController();
+      const signal = controller.signal;
+      (async () => {
+        try {
+          for await (const event of stream) {
+            if (signal.aborted) break;
+            switch (event.type) {
+              case "text":
+                onEvent({ type: "text", content: event.content || "" });
+                break;
+              case "thinking":
+                onEvent({ type: "thinking", content: event.content || "" });
+                break;
+              case "tool_call":
+                if (event.tool_call) {
+                  onEvent({ type: "tool_call", tool_call: event.tool_call });
+                }
+                break;
+              case "tool_result":
+                onEvent({ type: "tool_result", tool_call_id: event.tool_call_id || "", result: event.result });
+                break;
+              case "done":
+                onEvent({ type: "done", conversationId: event.conversationId || "", title: event.title });
+                break;
+              case "error":
+                onEvent({ type: "error", error: event.error || "Unknown error" });
+                break;
+              default:
+                const evt = event;
+                if (evt.type === "interrupt") {
+                  currentRunId = evt.run_id || null;
+                  onEvent({
+                    type: "interrupt",
+                    interrupt_type: evt.interrupt_type || "",
+                    interrupt_payload: evt.interrupt_payload,
+                    run_id: evt.run_id
+                  });
+                }
+                break;
+            }
+          }
+        } catch (e) {
+          if (!signal.aborted) {
+            onEvent({ type: "error", error: e instanceof Error ? e.message : "Stream error" });
+          }
+        }
+      })();
+      return {
+        cancel: () => {
+          controller.abort();
+        }
+      };
+    },
+    sendHitlResponse(response, runId) {
+      const sdk = config.getSdk();
+      if (!sdk) return;
+      const id = runId || currentRunId;
+      if (id) {
+        sdk.sendHitlResponse(id, response);
+      }
+    }
+  };
+}
+
+// src/renderer/components/MessageList.tsx
+import { memo, useRef as useRef2, useEffect as useEffect3, useCallback as useCallback4 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var SCROLL_THRESHOLD = 100;
+var MessageList = memo(function MessageList2({
+  messages,
+  className = "",
+  renderMessage,
+  autoScroll = true,
+  scrollBehavior = "smooth"
+}) {
+  const containerRef = useRef2(null);
+  const isNearBottomRef = useRef2(true);
+  const checkIfNearBottom = useCallback4(() => {
+    const container = containerRef.current;
+    if (!container) return true;
+    return container.scrollTop <= SCROLL_THRESHOLD;
+  }, []);
+  const handleScroll = useCallback4(() => {
+    isNearBottomRef.current = checkIfNearBottom();
+  }, [checkIfNearBottom]);
+  const scrollToBottom = useCallback4(
+    (behavior = scrollBehavior) => {
+      containerRef.current?.scrollTo({ top: 0, behavior });
+    },
+    [scrollBehavior]
+  );
+  useEffect3(() => {
+    if (autoScroll && isNearBottomRef.current) {
+      scrollToBottom();
+    }
+  }, [messages, autoScroll, scrollToBottom]);
+  useEffect3(() => {
+    scrollToBottom("instant");
+    isNearBottomRef.current = true;
+  }, []);
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: containerRef,
+      className: `${className} flex flex-col-reverse overflow-y-auto`,
+      role: "log",
+      "aria-live": "polite",
+      onScroll: handleScroll,
+      children: /* @__PURE__ */ jsx3("div", { className: "flex flex-col", children: messages.map((message, index) => /* @__PURE__ */ jsx3("div", { children: renderMessage(message, index) }, message.id)) })
+    }
+  );
+});
+
+// src/renderer/components/MessageBubble.tsx
+import { memo as memo2 } from "react";
+import { Fragment, jsx as jsx4, jsxs } from "react/jsx-runtime";
+var MessageBubble = memo2(function MessageBubble2({
+  message,
+  className = "",
+  children,
+  renderContent
+}) {
+  const isStreaming = message.isStreaming ?? false;
+  return /* @__PURE__ */ jsxs("div", { className, "data-role": message.role, "data-streaming": isStreaming, children: [
+    /* @__PURE__ */ jsx4("div", { className: "message-content", children: renderContent ? renderContent(message.content, isStreaming) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      message.content,
+      isStreaming && /* @__PURE__ */ jsx4("span", { className: "streaming-cursor", children: "\u258C" })
+    ] }) }),
+    children
+  ] });
+});
+
+// src/renderer/components/ChatInput.tsx
+import { memo as memo3, useState as useState4, useRef as useRef3, useCallback as useCallback5, useEffect as useEffect4 } from "react";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var ChatInput = memo3(function ChatInput2({
+  onSend,
+  onStop,
+  placeholder = "Type a message...",
+  disabled = false,
+  isStreaming = false,
+  isLoading = false,
+  className = "",
+  textareaClassName = "",
+  sendButtonClassName = "",
+  stopButtonClassName = "",
+  sendButtonContent = "Send",
+  stopButtonContent = "Stop",
+  maxRows = 6,
+  autoFocus = false,
+  focusRef
+}) {
+  const [text, setText] = useState4("");
+  const textareaRef = useRef3(null);
+  const canSend = text.trim().length > 0 && !disabled && !isLoading;
+  const maxHeight = maxRows * 20;
+  useEffect4(() => {
+    if (focusRef) {
+      focusRef.current = () => textareaRef.current?.focus();
+    }
+  }, [focusRef]);
+  useEffect4(() => {
+    if (autoFocus) {
+      const timer = setTimeout(() => textareaRef.current?.focus(), 100);
+      return () => clearTimeout(timer);
+    }
+  }, [autoFocus]);
+  useEffect4(() => {
+    const textarea = textareaRef.current;
+    if (!textarea) return;
+    textarea.style.height = "auto";
+    textarea.style.height = `${Math.min(textarea.scrollHeight, maxHeight)}px`;
+  }, [text, maxHeight]);
+  const handleSubmit = useCallback5(
+    (e) => {
+      e?.preventDefault();
+      if (!canSend) return;
+      onSend(text.trim());
+      setText("");
+      if (textareaRef.current) textareaRef.current.style.height = "auto";
+    },
+    [text, canSend, onSend]
+  );
+  const handleKeyDown = useCallback5(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey && !e.nativeEvent.isComposing) {
+        e.preventDefault();
+        handleSubmit();
+      }
+    },
+    [handleSubmit]
+  );
+  return /* @__PURE__ */ jsxs2("form", { onSubmit: handleSubmit, className, children: [
+    /* @__PURE__ */ jsx5(
+      "textarea",
+      {
+        ref: textareaRef,
+        value: text,
+        onChange: (e) => setText(e.target.value),
+        onKeyDown: handleKeyDown,
+        placeholder,
+        disabled,
+        rows: 1,
+        className: textareaClassName
+      }
+    ),
+    isStreaming ? /* @__PURE__ */ jsx5("button", { type: "button", onClick: onStop, className: stopButtonClassName, children: stopButtonContent }) : /* @__PURE__ */ jsx5("button", { type: "submit", disabled: !canSend, className: sendButtonClassName, children: sendButtonContent })
+  ] });
+});
+
+// src/renderer/components/FloatingChat.tsx
+import { memo as memo4, useCallback as useCallback6 } from "react";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var FloatingChat = memo4(function FloatingChat2({
+  messages,
+  isLoading,
+  isStreaming,
+  error,
+  pendingInterrupt,
+  onSendMessage,
+  onStopStreaming,
+  onApproveHitl,
+  onRejectHitl,
+  onHide,
+  className = "",
+  placeholder,
+  locale = "en",
+  renderMessage,
+  renderContent,
+  renderHitl,
+  header,
+  footer
+}) {
+  const t = getTranslations(locale);
+  const inputPlaceholder = placeholder ?? t.input.placeholder;
+  const defaultRenderMessage = useCallback6(
+    (message) => /* @__PURE__ */ jsx6(
+      MessageBubble,
+      {
+        message,
+        className: `p-3 my-1 rounded-lg ${message.role === "user" ? "bg-blue-100 dark:bg-blue-900 ml-8" : "bg-gray-100 dark:bg-gray-800 mr-8"}`,
+        renderContent
+      }
+    ),
+    [renderContent]
+  );
+  const defaultRenderHitl = useCallback6(
+    (interrupt, onApprove, onReject) => /* @__PURE__ */ jsxs3("div", { className: "p-4 bg-yellow-50 dark:bg-yellow-900/20 border border-yellow-200 dark:border-yellow-800 rounded-lg m-2", children: [
+      /* @__PURE__ */ jsx6("p", { className: "font-medium mb-2", children: interrupt.type === "approval_request" ? t.hitl.approvalRequired : t.hitl.inputRequired }),
+      interrupt.tool && /* @__PURE__ */ jsxs3("p", { className: "text-sm mb-2", children: [
+        t.hitl.tool,
+        ": ",
+        interrupt.tool
+      ] }),
+      interrupt.reason && /* @__PURE__ */ jsx6("p", { className: "text-sm mb-2", children: interrupt.reason }),
+      interrupt.question && /* @__PURE__ */ jsx6("p", { className: "text-sm mb-2", children: interrupt.question }),
+      /* @__PURE__ */ jsxs3("div", { className: "flex gap-2 mt-3", children: [
+        /* @__PURE__ */ jsx6(
+          "button",
+          {
+            onClick: onApprove,
+            className: "px-3 py-1 bg-green-500 text-white rounded hover:bg-green-600",
+            children: t.hitl.approve
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          "button",
+          {
+            onClick: onReject,
+            className: "px-3 py-1 bg-red-500 text-white rounded hover:bg-red-600",
+            children: t.hitl.reject
+          }
+        )
+      ] })
+    ] }),
+    [t]
+  );
+  return /* @__PURE__ */ jsxs3("div", { className: `flex flex-col h-full ${className}`, children: [
+    header && /* @__PURE__ */ jsx6("div", { className: "flex-shrink-0", children: header }),
+    /* @__PURE__ */ jsx6(
+      MessageList,
+      {
+        messages,
+        className: "flex-1 p-2 min-h-0",
+        renderMessage: renderMessage || defaultRenderMessage
+      }
+    ),
+    pendingInterrupt && /* @__PURE__ */ jsx6("div", { className: "flex-shrink-0", children: (renderHitl || defaultRenderHitl)(
+      pendingInterrupt,
+      () => onApproveHitl?.(),
+      () => onRejectHitl?.()
+    ) }),
+    error && /* @__PURE__ */ jsx6("div", { className: "flex-shrink-0 p-2 text-red-500 text-sm bg-red-50 dark:bg-red-900/20", children: error }),
+    /* @__PURE__ */ jsx6("div", { className: "flex-shrink-0 p-2 border-t dark:border-gray-700", children: /* @__PURE__ */ jsx6(
+      ChatInput,
+      {
+        onSend: onSendMessage,
+        onStop: onStopStreaming,
+        placeholder: inputPlaceholder,
+        isStreaming,
+        isLoading,
+        disabled: !!pendingInterrupt,
+        autoFocus: true,
+        className: "flex gap-2",
+        textareaClassName: "flex-1 resize-none rounded-lg border dark:border-gray-600 px-3 py-2 focus:outline-none focus:ring-2 focus:ring-blue-500 dark:bg-gray-800",
+        sendButtonClassName: "px-4 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:opacity-50",
+        stopButtonClassName: "px-4 py-2 bg-red-500 text-white rounded-lg hover:bg-red-600"
+      }
+    ) }),
+    footer && /* @__PURE__ */ jsx6("div", { className: "flex-shrink-0", children: footer })
+  ] });
+});
+export {
+  ChatInput,
+  FloatingChat,
+  I18nProvider,
+  MessageBubble,
+  MessageList,
+  ThemeProvider,
+  createIpcAdapter,
+  createSdkAdapter,
+  getTranslations,
+  useChat,
+  useI18n,
+  useStandaloneI18n,
+  useStandaloneTheme,
+  useTheme
+};