@yushaw/sanqian-chat 0.1.1

package/dist/preload/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/preload/index.ts
+var preload_exports = {};
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+var api = {
+  connect: () => import_electron.ipcRenderer.invoke("sanqian-chat:connect"),
+  isConnected: () => import_electron.ipcRenderer.invoke("sanqian-chat:isConnected"),
+  stream: (params) => import_electron.ipcRenderer.invoke("sanqian-chat:stream", params),
+  cancelStream: (params) => import_electron.ipcRenderer.invoke("sanqian-chat:cancelStream", params),
+  onStreamEvent: (callback) => {
+    const handler = (_, data) => {
+      callback(data.streamId, data.event);
+    };
+    import_electron.ipcRenderer.on("sanqian-chat:streamEvent", handler);
+    return () => import_electron.ipcRenderer.removeListener("sanqian-chat:streamEvent", handler);
+  },
+  sendHitlResponse: (params) => import_electron.ipcRenderer.invoke("sanqian-chat:hitlResponse", params),
+  listConversations: (params) => import_electron.ipcRenderer.invoke("sanqian-chat:listConversations", params),
+  getConversation: (params) => import_electron.ipcRenderer.invoke("sanqian-chat:getConversation", params),
+  deleteConversation: (params) => import_electron.ipcRenderer.invoke("sanqian-chat:deleteConversation", params),
+  hide: () => import_electron.ipcRenderer.invoke("sanqian-chat:hide")
+};
+import_electron.contextBridge.exposeInMainWorld("sanqianChat", api);

package/dist/renderer/index.d.mts

@@ -0,0 +1,340 @@
+import { HitlInterruptPayload, HitlResponse, SanqianSDK } from '@yushaw/sanqian-sdk';
+export { ChatStreamEvent, HitlInterruptPayload, HitlInterruptType, HitlResponse, HitlRiskLevel, ChatMessage as SdkChatMessage, ConversationDetail as SdkConversationDetail, ConversationInfo as SdkConversationInfo, ToolCall as SdkToolCall } from '@yushaw/sanqian-sdk';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * @yushaw/sanqian-chat Core Types
+ *
+ * Re-exports SDK types + chat-specific types
+ */
+
+type MessageRole = 'user' | 'assistant' | 'system';
+type ToolCallStatus = 'pending' | 'running' | 'completed' | 'error' | 'cancelled';
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+type ConnectionErrorCode = 'NOT_FOUND' | 'CONNECTION_FAILED' | 'WEBSOCKET_ERROR' | 'AUTH_ERROR' | 'TIMEOUT' | 'UNKNOWN';
+/** Tool call for UI rendering (extended from SDK) */
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    status: ToolCallStatus;
+    result?: unknown;
+    error?: string;
+}
+/** Message block for structured rendering */
+interface MessageBlock {
+    type: 'thinking' | 'text' | 'tool_call' | 'tool_result';
+    content: string;
+    timestamp: number;
+    toolName?: string;
+    toolArgs?: Record<string, unknown>;
+    toolCallId?: string;
+    toolStatus?: ToolCallStatus;
+    isIntermediate?: boolean;
+}
+/** Chat message for UI rendering */
+interface ChatMessage {
+    id: string;
+    role: MessageRole;
+    content: string;
+    timestamp: string;
+    isStreaming?: boolean;
+    toolCalls?: ToolCall[];
+    thinking?: string;
+    currentThinking?: string;
+    isThinkingStreaming?: boolean;
+    blocks?: MessageBlock[];
+    isComplete?: boolean;
+}
+/** Conversation info for UI */
+interface ConversationInfo {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+}
+interface ConversationDetail extends ConversationInfo {
+    messages: ChatMessage[];
+}
+/** HITL interrupt data for UI (alias for HitlInterruptPayload) */
+type HitlInterruptData = HitlInterruptPayload;
+type WindowPosition = 'center' | 'cursor' | 'remember' | {
+    x: number;
+    y: number;
+};
+interface FloatingWindowConfig {
+    shortcut?: string;
+    position?: WindowPosition;
+    width?: number;
+    height?: number;
+    alwaysOnTop?: boolean;
+    showInTaskbar?: boolean;
+    theme?: 'light' | 'dark' | 'system';
+}
+
+/**
+ * Chat Adapter Interface
+ *
+ * Abstracts the connection to Sanqian backend.
+ * Default implementation uses @yushaw/sanqian-sdk directly.
+ */
+
+/** Stream event callback */
+type StreamEvent = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'thinking';
+    content: string;
+} | {
+    type: 'tool_call';
+    tool_call: {
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    };
+} | {
+    type: 'tool_result';
+    tool_call_id: string;
+    result: unknown;
+} | {
+    type: 'done';
+    conversationId: string;
+    title?: string;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'interrupt';
+    interrupt_type: string;
+    interrupt_payload: HitlInterruptData;
+    run_id?: string;
+};
+/** Message to send */
+interface SendMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+/** Chat adapter interface */
+interface ChatAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionStatus(): ConnectionStatus;
+    onConnectionChange(callback: (status: ConnectionStatus, error?: string, errorCode?: ConnectionErrorCode) => void): () => void;
+    listConversations(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        conversations: ConversationInfo[];
+        total: number;
+    }>;
+    getConversation(id: string, options?: {
+        messageLimit?: number;
+    }): Promise<ConversationDetail>;
+    deleteConversation(id: string): Promise<void>;
+    chatStream(messages: SendMessage[], conversationId: string | undefined, onEvent: (event: StreamEvent) => void): Promise<{
+        cancel: () => void;
+    }>;
+    sendHitlResponse?(response: HitlResponse, runId?: string): void;
+    cleanup?(): void;
+}
+/** SDK adapter config */
+interface SdkAdapterConfig {
+    /** SDK instance getter */
+    getSdk: () => SanqianSDK | null;
+    /** Agent ID getter */
+    getAgentId: () => string | null;
+}
+/**
+ * Create adapter that wraps @yushaw/sanqian-sdk
+ */
+declare function createSdkAdapter(config: SdkAdapterConfig): ChatAdapter;
+
+/**
+ * useChat Hook
+ *
+ * Core hook for managing chat state and interactions.
+ * Simplified from sanqian-notes chat-ui.
+ */
+
+interface UseChatOptions {
+    adapter: ChatAdapter;
+    conversationId?: string;
+    onError?: (error: Error) => void;
+    onConversationChange?: (conversationId: string, title?: string) => void;
+}
+interface UseChatReturn {
+    messages: ChatMessage[];
+    isLoading: boolean;
+    isStreaming: boolean;
+    error: string | null;
+    conversationId: string | null;
+    conversationTitle: string | null;
+    pendingInterrupt: HitlInterruptData | null;
+    sendMessage: (content: string) => Promise<void>;
+    stopStreaming: () => void;
+    clearMessages: () => void;
+    setError: (error: string | null) => void;
+    approveHitl: (remember?: boolean) => void;
+    rejectHitl: (remember?: boolean) => void;
+    submitHitlInput: (response: HitlResponse) => void;
+    loadConversation: (id: string) => Promise<void>;
+    newConversation: () => void;
+}
+declare function useChat(options: UseChatOptions): UseChatReturn;
+
+type ThemeMode = 'light' | 'dark' | 'system';
+type ResolvedTheme = 'light' | 'dark';
+interface ThemeContextValue {
+    theme: ThemeMode;
+    resolvedTheme: ResolvedTheme;
+    setTheme: (theme: ThemeMode) => void;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+    defaultTheme?: ThemeMode;
+    storageKey?: string;
+}
+declare function ThemeProvider({ children, defaultTheme, storageKey, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useTheme(): ThemeContextValue;
+/**
+ * Hook for theme without provider (standalone usage)
+ * Useful when you can't wrap with ThemeProvider
+ */
+declare function useStandaloneTheme(defaultTheme?: ThemeMode): ThemeContextValue;
+
+type Locale = 'en' | 'zh';
+interface Translations {
+    hitl: {
+        approvalRequired: string;
+        inputRequired: string;
+        tool: string;
+        approve: string;
+        reject: string;
+        submit: string;
+        cancel: string;
+    };
+    input: {
+        placeholder: string;
+        send: string;
+        stop: string;
+    };
+    message: {
+        thinking: string;
+        error: string;
+        loading: string;
+    };
+    connection: {
+        connecting: string;
+        connected: string;
+        disconnected: string;
+        reconnecting: string;
+        error: string;
+    };
+    conversation: {
+        new: string;
+        untitled: string;
+        delete: string;
+        deleteConfirm: string;
+    };
+}
+interface I18nContextValue {
+    locale: Locale;
+    setLocale: (locale: Locale) => void;
+    t: Translations;
+}
+interface I18nProviderProps {
+    children: ReactNode;
+    defaultLocale?: Locale;
+    storageKey?: string;
+    /** Custom translations to merge with built-in ones */
+    customTranslations?: Partial<Record<Locale, Partial<Translations>>>;
+}
+declare function I18nProvider({ children, defaultLocale, storageKey, customTranslations, }: I18nProviderProps): react_jsx_runtime.JSX.Element;
+declare function useI18n(): I18nContextValue;
+/**
+ * Hook for i18n without provider (standalone usage)
+ * Returns default English translations if no provider
+ */
+declare function useStandaloneI18n(defaultLocale?: Locale): I18nContextValue;
+/**
+ * Get translations for a specific locale (utility function)
+ */
+declare function getTranslations(locale: Locale): Translations;
+
+/**
+ * IPC Adapter
+ *
+ * Connects to main process via preload API (window.sanqianChat)
+ */
+
+/**
+ * Create IPC adapter that communicates via window.sanqianChat (preload)
+ */
+declare function createIpcAdapter(): ChatAdapter;
+
+interface MessageListProps {
+    messages: ChatMessage[];
+    className?: string;
+    renderMessage: (message: ChatMessage, index: number) => ReactNode;
+    autoScroll?: boolean;
+    scrollBehavior?: ScrollBehavior;
+}
+declare const MessageList: react.NamedExoticComponent<MessageListProps>;
+
+interface MessageBubbleProps {
+    message: ChatMessage;
+    className?: string;
+    children?: ReactNode;
+    renderContent?: (content: string, isStreaming: boolean) => ReactNode;
+}
+declare const MessageBubble: react.NamedExoticComponent<MessageBubbleProps>;
+
+interface ChatInputProps {
+    onSend: (content: string) => void;
+    onStop?: () => void;
+    placeholder?: string;
+    disabled?: boolean;
+    isStreaming?: boolean;
+    isLoading?: boolean;
+    className?: string;
+    textareaClassName?: string;
+    sendButtonClassName?: string;
+    stopButtonClassName?: string;
+    sendButtonContent?: ReactNode;
+    stopButtonContent?: ReactNode;
+    maxRows?: number;
+    autoFocus?: boolean;
+    focusRef?: React.MutableRefObject<(() => void) | null>;
+}
+declare const ChatInput: react.NamedExoticComponent<ChatInputProps>;
+
+interface FloatingChatProps {
+    messages: ChatMessage[];
+    isLoading: boolean;
+    isStreaming: boolean;
+    error: string | null;
+    pendingInterrupt: HitlInterruptData | null;
+    onSendMessage: (content: string) => void;
+    onStopStreaming: () => void;
+    onApproveHitl?: (remember?: boolean) => void;
+    onRejectHitl?: (remember?: boolean) => void;
+    onHide?: () => void;
+    className?: string;
+    placeholder?: string;
+    locale?: Locale;
+    renderMessage?: (message: ChatMessage, index: number) => ReactNode;
+    renderContent?: (content: string, isStreaming: boolean) => ReactNode;
+    renderHitl?: (interrupt: HitlInterruptData, onApprove: () => void, onReject: () => void) => ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+}
+declare const FloatingChat: react.NamedExoticComponent<FloatingChatProps>;
+
+export { type ChatAdapter, ChatInput, type ChatInputProps, type ChatMessage, type ConnectionErrorCode, type ConnectionStatus, type ConversationDetail, type ConversationInfo, FloatingChat, type FloatingChatProps, type FloatingWindowConfig, type HitlInterruptData, I18nProvider, type I18nProviderProps, type Locale, type MessageBlock, MessageBubble, type MessageBubbleProps, MessageList, type MessageListProps, type MessageRole, type ResolvedTheme, type SdkAdapterConfig, type SendMessage, type StreamEvent, type ThemeMode, ThemeProvider, type ThemeProviderProps, type ToolCall, type ToolCallStatus, type Translations, type UseChatOptions, type UseChatReturn, type WindowPosition, createIpcAdapter, createSdkAdapter, getTranslations, useChat, useI18n, useStandaloneI18n, useStandaloneTheme, useTheme };