@unif/react-native-chat-sdk 0.1.0

package/src/providers/AbstractChatProvider.ts

@@ -0,0 +1,74 @@
+/**
+ * AbstractChatProvider — Provider 抽象基类
+ *
+ * 3 个抽象方法：transformParams / transformLocalMessage / transformMessage
+ */
+
+import type {XRequest, XRequestCallbacks} from '../tools/XRequest';
+import type {ChatMessage} from '../types/message';
+import type {RequestParams, SSEOutput, ProviderCallbacks} from '../types/provider';
+
+export abstract class AbstractChatProvider<
+  Message = ChatMessage,
+  Input = RequestParams<Message>,
+  Output = SSEOutput,
+> {
+  protected request: XRequest;
+
+  constructor(config: { request: XRequest }) {
+    this.request = config.request;
+  }
+
+  /**
+   * 转换请求参数
+   * 将 useXChat.onRequest() 传入的参数转换为 XRequest 需要的格式
+   */
+  abstract transformParams(input: Input): Record<string, unknown>;
+
+  /**
+   * 转换本地消息
+   * 将请求参数转换为用户发送的本地 ChatMessage（用于消息列表渲染）
+   */
+  abstract transformLocalMessage(input: Input): Message;
+
+  /**
+   * 转换响应消息
+   * 将 XRequest 返回的流数据转换为 ChatMessage（用于 assistant 消息渲染）
+   */
+  abstract transformMessage(output: Output, current?: Message): Message;
+
+  /**
+   * 发起请求（内部调用 XRequest）
+   */
+  sendMessage(input: Input, callbacks: ProviderCallbacks<Message>): void {
+    const params = this.transformParams(input);
+    let currentMessage: Message | undefined;
+
+    const requestCallbacks: XRequestCallbacks = {
+      onStream: (chunk) => {
+        currentMessage = this.transformMessage(
+          chunk as unknown as Output,
+          currentMessage
+        );
+        callbacks.onUpdate(currentMessage);
+      },
+      onSuccess: () => {
+        if (currentMessage) {
+          callbacks.onSuccess(currentMessage);
+        }
+      },
+      onError: (error) => {
+        callbacks.onError(new Error(error.message));
+      },
+    };
+
+    this.request.create(params, requestCallbacks);
+  }
+
+  /**
+   * 中止请求
+   */
+  abort(): void {
+    this.request.abort();
+  }
+}

package/src/providers/DeepSeekChatProvider.ts

@@ -0,0 +1,105 @@
+/**
+ * DeepSeekChatProvider — DeepSeek Provider
+ *
+ * 继承 OpenAIChatProvider（DeepSeek API 兼容 OpenAI 格式）
+ * 额外处理 reasoning_content 字段（DeepSeek 的思考过程）→ 映射到 <think> 标签
+ */
+
+import {OpenAIChatProvider} from './OpenAIChatProvider';
+import type {ChatMessage} from '../types/message';
+import type {SSEOutput} from '../types/provider';
+
+export interface DeepSeekChatProviderConfig {
+  apiKey?: string;
+  model?: string;
+  getToken?: () => Promise<string | null>;
+  baseURL?: string;
+}
+
+export class DeepSeekChatProvider extends OpenAIChatProvider {
+  constructor(config: DeepSeekChatProviderConfig) {
+    super({
+      baseURL: config.baseURL ?? 'https://api.deepseek.com',
+      apiKey: config.apiKey,
+      model: config.model ?? 'deepseek-chat',
+      getToken: config.getToken,
+    });
+  }
+
+  /**
+   * 覆写 transformMessage，处理 DeepSeek reasoning_content
+   */
+  override transformMessage(
+    output: SSEOutput,
+    current?: ChatMessage
+  ): ChatMessage {
+    const raw = output.data;
+
+    if (raw.trim() === '[DONE]') {
+      return {
+        ...(current ?? {
+          id: '',
+          text: '',
+          role: 'assistant' as const,
+          createdAt: new Date(),
+          messageType: 'text' as const,
+          status: 'success' as const,
+          turnId: '',
+        }),
+        status: 'success',
+      };
+    }
+
+    try {
+      const parsed = JSON.parse(raw);
+      const delta = parsed.choices?.[0]?.delta;
+      const content = delta?.content ?? '';
+      const reasoningContent = delta?.reasoning_content ?? '';
+      const finishReason = parsed.choices?.[0]?.finish_reason;
+
+      const prevText = current?.text ?? '';
+      let newText = prevText;
+
+      // 将 reasoning_content 映射为 <think> 标签包裹
+      if (reasoningContent) {
+        // 如果还没有开始 think 标签，添加开始标签
+        if (!prevText.includes('<think>')) {
+          newText += '<think>';
+        }
+        newText += reasoningContent;
+      }
+
+      if (content) {
+        // 如果有未关闭的 think 标签，先关闭
+        if (
+          newText.includes('<think>') &&
+          !newText.includes('</think>')
+        ) {
+          newText += '</think>';
+        }
+        newText += content;
+      }
+
+      // 完成时确保 think 标签闭合
+      if (
+        finishReason &&
+        newText.includes('<think>') &&
+        !newText.includes('</think>')
+      ) {
+        newText += '</think>';
+      }
+
+      return {
+        id: current?.id ?? `msg-${Date.now()}`,
+        text: newText,
+        role: 'assistant',
+        createdAt: current?.createdAt ?? new Date(),
+        messageType: 'text',
+        status: finishReason ? 'success' : 'updating',
+        turnId: current?.turnId ?? `turn-${Date.now()}`,
+      };
+    } catch {
+      return current ?? super.transformMessage(output, current);
+    }
+  }
+}

package/src/providers/OpenAIChatProvider.ts

@@ -0,0 +1,130 @@
+/**
+ * OpenAIChatProvider — OpenAI 兼容 Provider
+ *
+ * 兼容所有 OpenAI 标准 API（OpenAI、Azure、Moonshot、通义千问兼容模式等）
+ */
+
+import {AbstractChatProvider} from './AbstractChatProvider';
+import {XRequest} from '../tools/XRequest';
+import type {ChatMessage, MessageStatus} from '../types/message';
+import type {RequestParams, SSEOutput} from '../types/provider';
+
+export interface OpenAIChatProviderConfig {
+  baseURL: string;
+  apiKey?: string;
+  model?: string;
+  getToken?: () => Promise<string | null>;
+  endpoint?: string;
+}
+
+let _idCounter = 0;
+const genId = () => `msg-${Date.now()}-${++_idCounter}`;
+
+export class OpenAIChatProvider extends AbstractChatProvider<
+  ChatMessage,
+  RequestParams<ChatMessage>,
+  SSEOutput
+> {
+  private model: string;
+
+  constructor(config: OpenAIChatProviderConfig) {
+    const headers: Record<string, string> = {};
+    if (config.apiKey) {
+      headers['Authorization'] = `Bearer ${config.apiKey}`;
+    }
+
+    const request = new XRequest({
+      baseURL: config.baseURL,
+      endpoint: config.endpoint ?? '/v1/chat/completions',
+      headers,
+      getToken: config.getToken,
+    });
+
+    super({ request });
+    this.model = config.model ?? 'gpt-4o';
+  }
+
+  /**
+   * 将消息转为 OpenAI messages 格式: [{role, content}]
+   */
+  transformParams(input: RequestParams<ChatMessage>): Record<string, unknown> {
+    const messages = (input.messages ?? []).map((m) => ({
+      role: m.role,
+      content: m.text,
+    }));
+
+    messages.push({
+      role: input.message.role,
+      content: input.message.text,
+    });
+
+    return {
+      model: input.model ?? this.model,
+      messages,
+      stream: true,
+    };
+  }
+
+  /**
+   * 创建本地用户消息
+   */
+  transformLocalMessage(input: RequestParams<ChatMessage>): ChatMessage {
+    return {
+      id: genId(),
+      text: input.message.text,
+      role: 'user',
+      createdAt: new Date(),
+      messageType: 'text',
+      status: 'local' as MessageStatus,
+      turnId: input.extra?.turnId as string ?? genId(),
+    };
+  }
+
+  /**
+   * 将 SSE delta 转为 ChatMessage（累积 content）
+   */
+  transformMessage(output: SSEOutput, current?: ChatMessage): ChatMessage {
+    const raw = output.data;
+
+    // OpenAI 结束标记
+    if (raw.trim() === '[DONE]') {
+      return {
+        ...(current ?? this.createEmptyAssistant()),
+        status: 'success' as MessageStatus,
+      };
+    }
+
+    try {
+      const parsed = JSON.parse(raw);
+      const delta = parsed.choices?.[0]?.delta;
+      const content = delta?.content ?? '';
+      const finishReason = parsed.choices?.[0]?.finish_reason;
+
+      const prevText = current?.text ?? '';
+
+      return {
+        id: current?.id ?? genId(),
+        text: prevText + content,
+        role: 'assistant',
+        createdAt: current?.createdAt ?? new Date(),
+        messageType: 'text',
+        status: finishReason ? 'success' : 'updating',
+        turnId: current?.turnId ?? genId(),
+      };
+    } catch {
+      return current ?? this.createEmptyAssistant();
+    }
+  }
+
+  private createEmptyAssistant(): ChatMessage {
+    return {
+      id: genId(),
+      text: '',
+      role: 'assistant',
+      createdAt: new Date(),
+      messageType: 'text',
+      status: 'updating',
+      turnId: genId(),
+    };
+  }
+}

package/src/stores/chatStore.ts

@@ -0,0 +1,79 @@
+/**
+ * Chat 消息状态管理（Zustand）
+ * 内部 store，通过 useXChat hook 封装后对外暴露
+ */
+
+import {create} from 'zustand';
+import type {ChatMessage} from '../types/message';
+import type {SuggestionItem} from '../types/sse';
+
+interface ChatState {
+  messages: ChatMessage[];
+  streamingText: string;
+  suggestions: SuggestionItem[];
+  isRequesting: boolean;
+  error: string | null;
+
+  addMessage: (message: ChatMessage) => void;
+  updateMessage: (id: string, updater: (msg: ChatMessage) => ChatMessage) => void;
+  upsertMessage: (message: ChatMessage) => void;
+  setSuggestions: (items: SuggestionItem[]) => void;
+  setRequesting: (v: boolean) => void;
+  setError: (error: string | null) => void;
+  resetChat: () => void;
+  loadSession: (messages: ChatMessage[]) => void;
+}
+
+export const createChatStore = () =>
+  create<ChatState>((set, get) => ({
+    messages: [],
+    streamingText: '',
+    suggestions: [],
+    isRequesting: false,
+    error: null,
+
+    addMessage: (message) =>
+      set((state) => ({
+        messages: [message, ...state.messages],
+      })),
+
+    updateMessage: (id, updater) =>
+      set((state) => ({
+        messages: state.messages.map((m) => (m.id === id ? updater(m) : m)),
+      })),
+
+    upsertMessage: (message) => {
+      const state = get();
+      const existingIdx = state.messages.findIndex((m) => m.id === message.id);
+
+      if (existingIdx >= 0) {
+        const newMessages = [...state.messages];
+        newMessages[existingIdx] = message;
+        set({ messages: newMessages });
+      } else {
+        set({ messages: [message, ...state.messages] });
+      }
+    },
+
+    setSuggestions: (items) => set({ suggestions: items }),
+    setRequesting: (v) => set({ isRequesting: v }),
+    setError: (error) => set({ error }),
+
+    resetChat: () =>
+      set({
+        messages: [],
+        streamingText: '',
+        suggestions: [],
+        isRequesting: false,
+        error: null,
+      }),
+
+    loadSession: (messages) =>
+      set({
+        messages,
+        streamingText: '',
+        suggestions: [],
+        isRequesting: false,
+        error: null,
+      }),
+  }));

package/src/stores/historyStore.ts

@@ -0,0 +1,117 @@
+/**
+ * 历史会话持久化
+ * 使用 ChatStorage 抽象，不直接依赖 AsyncStorage
+ */
+
+import type {ChatMessage} from '../types/message';
+import type {ChatStorage} from './storage';
+
+const MAX_SESSIONS = 50;
+const MESSAGE_KEY_PREFIX = 'chat-session-';
+
+export interface SessionSummary {
+  id: string;
+  title: string;
+  lastMessage: string;
+  timestamp: number;
+  messageCount: number;
+}
+
+export interface HistoryStore {
+  sessions: SessionSummary[];
+  archiveSession: (
+    id: string,
+    title: string,
+    messages: ChatMessage[]
+  ) => Promise<void>;
+  loadSessionMessages: (id: string) => Promise<ChatMessage[]>;
+  deleteSession: (id: string) => Promise<void>;
+  clearAll: () => Promise<void>;
+}
+
+export function createHistoryStore(storage: ChatStorage): HistoryStore {
+  let sessions: SessionSummary[] = [];
+  let initialized = false;
+
+  const loadIndex = async () => {
+    if (initialized) return;
+    try {
+      const raw = await storage.getItem('chat-history-index');
+      if (raw) {
+        sessions = JSON.parse(raw);
+      }
+    } catch {
+      sessions = [];
+    }
+    initialized = true;
+  };
+
+  const saveIndex = async () => {
+    await storage.setItem('chat-history-index', JSON.stringify(sessions));
+  };
+
+  return {
+    get sessions() {
+      return sessions;
+    },
+
+    archiveSession: async (id, title, messages) => {
+      await loadIndex();
+      if (messages.length === 0) return;
+
+      await storage.setItem(
+        `${MESSAGE_KEY_PREFIX}${id}`,
+        JSON.stringify(messages)
+      );
+
+      const lastMsg = messages[0];
+      const summary: SessionSummary = {
+        id,
+        title,
+        lastMessage: lastMsg?.text?.slice(0, 50) ?? '',
+        timestamp: Date.now(),
+        messageCount: messages.length,
+      };
+
+      // 去重（如果已存在则更新）
+      sessions = sessions.filter((s) => s.id !== id);
+      sessions = [summary, ...sessions];
+
+      // FIFO 淘汰
+      if (sessions.length > MAX_SESSIONS) {
+        const removed = sessions.splice(MAX_SESSIONS);
+        await Promise.all(
+          removed.map((s) =>
+            storage.removeItem(`${MESSAGE_KEY_PREFIX}${s.id}`)
+          )
+        );
+      }
+
+      await saveIndex();
+    },
+
+    loadSessionMessages: async (id) => {
+      const raw = await storage.getItem(`${MESSAGE_KEY_PREFIX}${id}`);
+      if (!raw) return [];
+      return JSON.parse(raw) as ChatMessage[];
+    },
+
+    deleteSession: async (id) => {
+      await loadIndex();
+      await storage.removeItem(`${MESSAGE_KEY_PREFIX}${id}`);
+      sessions = sessions.filter((s) => s.id !== id);
+      await saveIndex();
+    },
+
+    clearAll: async () => {
+      await loadIndex();
+      await Promise.all(
+        sessions.map((s) =>
+          storage.removeItem(`${MESSAGE_KEY_PREFIX}${s.id}`)
+        )
+      );
+      sessions = [];
+      await saveIndex();
+    },
+  };
+}

package/src/stores/modelStore.ts

@@ -0,0 +1,17 @@
+/**
+ * 模型选择状态（Zustand）
+ * 内部 store，通过 useXModel hook 封装后对外暴露
+ */
+
+import {create} from 'zustand';
+
+interface ModelState {
+  selectedModel: string;
+  setSelectedModel: (id: string) => void;
+}
+
+export const createModelStore = (defaultModel: string) =>
+  create<ModelState>((set) => ({
+    selectedModel: defaultModel,
+    setSelectedModel: (id) => set({ selectedModel: id }),
+  }));

package/src/stores/sessionStore.ts

@@ -0,0 +1,21 @@
+/**
+ * 会话状态管理（Zustand）
+ * 内部 store，通过 useXConversations hook 封装后对外暴露
+ */
+
+import {create} from 'zustand';
+
+interface SessionState {
+  sessionId: string;
+  sessionTitle: string;
+  setSessionId: (id: string) => void;
+  setSessionTitle: (title: string) => void;
+}
+
+export const createSessionStore = (generateId: () => string) =>
+  create<SessionState>((set) => ({
+    sessionId: generateId(),
+    sessionTitle: '',
+    setSessionId: (id) => set({ sessionId: id }),
+    setSessionTitle: (title) => set({ sessionTitle: title }),
+  }));

package/src/stores/storage.ts

@@ -0,0 +1,10 @@
+/**
+ * ChatStorage — 存储抽象接口
+ * 不绑定 AsyncStorage，支持注入任意存储实现
+ */
+
+export interface ChatStorage {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+}

package/src/tools/SSEParser.ts

@@ -0,0 +1,52 @@
+/**
+ * SSE 解析器
+ * - event_id 幂等去重
+ * - seq 严格排序（乱序缓冲，顺序到达后 flush）
+ * - 每轮对话调用 reset() 重置
+ */
+
+import type {SSEEnvelope} from '../types/sse';
+
+export class SSEParser {
+  private processedIds = new Set<string>();
+  private buffer = new Map<number, SSEEnvelope>();
+  private nextSeq = 1;
+
+  reset(): void {
+    this.processedIds.clear();
+    this.buffer.clear();
+    this.nextSeq = 1;
+  }
+
+  /**
+   * 解析原始 SSE data 字符串，返回按 seq 排序的事件数组
+   * 已处理的 event_id 会被自动跳过（幂等）
+   */
+  process(raw: string): SSEEnvelope[] {
+    let envelope: SSEEnvelope;
+    try {
+      envelope = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+
+    // 幂等去重
+    if (this.processedIds.has(envelope.event_id)) {
+      return [];
+    }
+    this.processedIds.add(envelope.event_id);
+
+    // 缓冲排序
+    this.buffer.set(envelope.seq, envelope);
+
+    // flush 连续的事件
+    const result: SSEEnvelope[] = [];
+    while (this.buffer.has(this.nextSeq)) {
+      result.push(this.buffer.get(this.nextSeq)!);
+      this.buffer.delete(this.nextSeq);
+      this.nextSeq++;
+    }
+
+    return result;
+  }
+}

package/src/tools/XRequest.ts

@@ -0,0 +1,99 @@
+/**
+ * XRequest — 面向 LLM 的 HTTP 请求工具
+ *
+ * 组合 XStream + SSEParser 实现完整 SSE 请求链路
+ */
+
+import {XStream} from './XStream';
+import {SSEParser} from './SSEParser';
+import type {SSEOutput} from '../types/provider';
+
+export interface XRequestConfig {
+  baseURL: string;
+  endpoint?: string;
+  model?: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+  getToken?: () => Promise<string | null>;
+}
+
+export interface XRequestCallbacks {
+  onStream?: (chunk: SSEOutput) => void;
+  onSuccess?: (message: string) => void;
+  onError?: (error: { type: string; message: string }) => void;
+  onAbort?: () => void;
+}
+
+export class XRequest {
+  private config: XRequestConfig;
+  private stream: XStream | null = null;
+  private parser = new SSEParser();
+
+  constructor(config: XRequestConfig) {
+    this.config = config;
+  }
+
+  async create(
+    params: Record<string, unknown>,
+    callbacks: XRequestCallbacks
+  ): Promise<void> {
+    this.abort();
+    this.parser.reset();
+
+    const {
+      baseURL,
+      endpoint = '/v1/chat/completions',
+      headers = {},
+      timeout,
+      getToken,
+    } = this.config;
+
+    // 注入 auth token
+    if (getToken) {
+      try {
+        const token = await getToken();
+        if (token) {
+          headers['Authorization'] = `Bearer ${token}`;
+        }
+      } catch {
+        // token 获取失败，继续无认证请求
+      }
+    }
+
+    const url = `${baseURL}${endpoint}`;
+
+    this.stream = new XStream({
+      url,
+      method: 'POST',
+      headers,
+      body: params,
+      timeout,
+    });
+
+    this.stream.connect({
+      onMessage: (output: SSEOutput) => {
+        callbacks.onStream?.(output);
+      },
+      onError: (error: Error) => {
+        callbacks.onError?.({
+          type: 'stream_error',
+          message: error.message,
+        });
+      },
+      onComplete: () => {
+        callbacks.onSuccess?.('');
+      },
+    });
+  }
+
+  abort(): void {
+    if (this.stream) {
+      this.stream.abort();
+      this.stream = null;
+    }
+  }
+
+  dispose(): void {
+    this.abort();
+  }
+}