@talknote/create-talknote-h5 0.1.3 → 0.1.5

package/template/packages/xiaozhi-chat/services/chatApi.ts

@@ -0,0 +1,585 @@
+import type {
+  ChatSession,
+  CreateSessionParams,
+  StreamChatCallbacks,
+  StreamChatParams,
+} from '../types';
+import { DEFAULT_CHAT_VERSION } from '../types';
+
+const API_PREFIX = process.env.API_PREFIX || './server/nes';
+const BOTE_CHAT_CREATE_SESSION_PATH = '/bote/chat/createBoteSession';
+const BOTE_CHAT_EXECUTE_PATH = '/bote/chat/execute';
+const DEFAULT_BOT_ID = '1404742587840745472';
+const DEFAULT_SCENE_ID = '1404655744776425472';
+
+const getBoteChatUrl = (path: string) => `${API_PREFIX}${path}`;
+
+const getSpaceIdFromLocation = (): string | null => {
+  if (typeof window === 'undefined') return null;
+  const fromSearch = new URLSearchParams(window.location.search).get('spaceId');
+  if (fromSearch?.trim()) return fromSearch.trim();
+  const hash = window.location.hash || '';
+  const queryIndex = hash.indexOf('?');
+  if (queryIndex < 0) return null;
+  const fromHash = new URLSearchParams(hash.slice(queryIndex + 1)).get('spaceId');
+  return fromHash?.trim() || null;
+};
+
+// const getDevToken = (): string | null => {
+//   if (process.env.NODE_ENV !== 'development') return null;
+//   try {
+//     const fromStorage =
+//       typeof localStorage !== 'undefined' ? localStorage.getItem('DEV_TOKEN') : null;
+//     return fromStorage || process.env.DEV_TOKEN || null;
+//   } catch {
+//     return process.env.DEV_TOKEN || null;
+//   }
+// };
+
+const buildRequestHeaders = async (): Promise<Record<string, string>> => {
+  const headers: Record<string, string> = {
+    Accept: 'text/event-stream, application/json',
+    'Content-Type': 'application/json',
+    'Cache-Control': 'no-cache',
+  };
+
+  // 使用session: getAuthTicket -> SsoLogin登录 -> set-cookie
+  // try {
+  //   const info = await TalkNoteH5Bridge.getRequestBaseInfo();
+  //   if (info) {
+  //     Object.assign(headers, info.headers || {});
+  //     if (!headers.token && !headers.Authorization && info.token) {
+  //       headers.Authorization = info.token;
+  //     }
+  //   }
+  // } catch {
+  //   const devToken = getDevToken();
+  //   if (devToken) headers.Authorization = devToken;
+  // }
+
+  // if (!headers.Authorization && !headers.token) {
+  //   const devToken = getDevToken();
+  //   if (devToken) headers.Authorization = devToken;
+  // }
+
+  const spaceId = getSpaceIdFromLocation();
+  if (spaceId) headers['X-LX-Space'] = spaceId;
+
+  return headers;
+};
+
+const isAbortError = (error: unknown) =>
+  (error instanceof DOMException && error.name === 'AbortError') ||
+  (error instanceof Error && error.name === 'AbortError');
+
+const unwrapRecord = (value: unknown): Record<string, unknown> | null => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  return value as Record<string, unknown>;
+};
+
+const unwrapPayload = (value: unknown): unknown => {
+  const record = unwrapRecord(value);
+  if (!record) return value;
+  const inner = record.resultObject;
+  const nested = unwrapRecord(inner);
+  if (nested && 'resultObject' in nested) return nested.resultObject ?? nested;
+  if (inner != null && inner !== record) return inner;
+  if (record.data != null && record.data !== record) return record.data;
+  return record;
+};
+
+const pickString = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+const pickText = (value: unknown, depth = 0): string => {
+  if (depth > 6 || value == null) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => pickText(item, depth + 1)).join('');
+  }
+  const record = unwrapRecord(value);
+  if (!record) return '';
+
+  const directKeys = ['delta', 'content', 'text', 'answer', 'output', 'chunk', 'result'];
+  for (const key of directKeys) {
+    const current = record[key];
+    if (typeof current === 'string' && current) return current;
+  }
+
+  if (Array.isArray(record.choices) && record.choices[0]) {
+    const choice = unwrapRecord(record.choices[0]);
+    const fromChoice =
+      pickText(choice?.delta, depth + 1) ||
+      pickText(choice?.message, depth + 1) ||
+      pickText(choice, depth + 1);
+    if (fromChoice) return fromChoice;
+  }
+
+  const nestedKeys = ['resultObject', 'data', 'message', 'payload'];
+  for (const key of nestedKeys) {
+    const nested = pickText(record[key], depth + 1);
+    if (nested) return nested;
+  }
+
+  return '';
+};
+
+const pickSession = (value: unknown): ChatSession | null => {
+  const record = unwrapRecord(unwrapPayload(value)) || unwrapRecord(value);
+  if (!record) return null;
+  const chatId = pickString(record.chatId || record.sessionId || record.conversationId);
+  const contextId = pickString(record.contextId || record.ctxId);
+  if (!chatId && !contextId) return null;
+  return { chatId, contextId };
+};
+
+const isSuccessCode = (code: unknown) => {
+  if (code == null || code === '') return true;
+  const normalized = String(code);
+  return normalized === '0' || normalized === '0000' || normalized === '200';
+};
+
+const pickErrorMessage = (value: unknown): string => {
+  const record = unwrapRecord(value);
+  if (!record) return '';
+  return (
+    pickString(record.resultMsg) ||
+    pickString(record.message) ||
+    pickString(record.error) ||
+    pickString(record.msg) ||
+    pickText(record.resultObject) ||
+    ''
+  );
+};
+
+const isDonePayload = (eventName: string, payload: unknown, raw: string) => {
+  const normalizedEvent = eventName.toLowerCase();
+  if (['done', 'end', 'finish', 'complete', 'message_end', 'stop'].includes(normalizedEvent)) {
+    return true;
+  }
+  const trimmed = raw.trim();
+  if (trimmed === '[DONE]' || trimmed === 'DONE' || trimmed === '[done]') return true;
+  const record = unwrapRecord(payload);
+  if (!record) return false;
+  if (record.done === true || record.finished === true || record.isEnd === true) return true;
+  const marker = String(record.event || record.type || record.status || record.finish_reason || '')
+    .toLowerCase();
+  return ['done', 'end', 'finish', 'complete', 'message_end', 'stop'].includes(marker);
+};
+
+const isErrorPayload = (eventName: string, payload: unknown) => {
+  if (eventName.toLowerCase() === 'error') return true;
+  const record = unwrapRecord(payload);
+  if (!record) return false;
+  const marker = String(record.event || record.type || record.status || '').toLowerCase();
+  if (marker === 'error' || record.error === true) return true;
+  if ('resultCode' in record && !isSuccessCode(record.resultCode)) return true;
+  return false;
+};
+
+const META_EVENT_NAMES = new Set([
+  'contextid',
+  'ctxid',
+  'chatid',
+  'sessionid',
+  'conversationid',
+  'questions',
+  'references',
+  'ping',
+  'heartbeat',
+]);
+
+const TEXT_EVENT_NAMES = new Set([
+  'text',
+  'message',
+  'delta',
+  'answer',
+  'content',
+  'data',
+]);
+
+const isMetaEvent = (eventName: string) => META_EVENT_NAMES.has(eventName.toLowerCase());
+
+const normalizeSSEText = (message: string) => {
+  const raw = message.startsWith('"') && message.endsWith('"')
+    ? message.slice(1, -1)
+    : message;
+  return raw.replace(/\\n/g, '\n');
+};
+
+const parseSessionFromMeta = (eventName: string, raw: string, payload: unknown): ChatSession | null => {
+  const fromPayload = pickSession(payload);
+  if (fromPayload) return fromPayload;
+
+  const fromString = typeof payload === 'string' ? payload : raw;
+  const id = fromString.replace(/^["']|["']$/g, '').trim();
+  if (!id || id.startsWith('{') || id.startsWith('[')) return null;
+
+  const eventKey = eventName.toLowerCase();
+  if (eventKey === 'contextid' || eventKey === 'ctxid') {
+    return { chatId: '', contextId: id };
+  }
+  if (eventKey === 'chatid' || eventKey === 'sessionid' || eventKey === 'conversationid') {
+    return { chatId: id, contextId: '' };
+  }
+  return null;
+};
+
+const sanitizeVisibleText = (text: string, session: ChatSession | null) => {
+  if (!text) return '';
+  const trimmed = text.trim();
+  if (session?.contextId && trimmed === session.contextId) return '';
+  if (session?.chatId && trimmed === session.chatId) return '';
+  return text;
+};
+
+const toDelta = (incoming: string, emitted: string) => {
+  if (!incoming) return '';
+  if (emitted && incoming.startsWith(emitted)) return incoming.slice(emitted.length);
+  return incoming;
+};
+
+const consumePayload = (
+  eventName: string,
+  rawData: string,
+  emitted: string,
+): {
+  delta: string;
+  done: boolean;
+  error?: string;
+  session?: ChatSession | null;
+} => {
+  const trimmed = rawData.trim();
+  if (!trimmed) return { delta: '', done: false };
+
+  let payload: unknown = trimmed;
+  let isJson = false;
+  try {
+    payload = JSON.parse(trimmed);
+    isJson = true;
+  } catch {
+    payload = trimmed;
+  }
+
+  if (isMetaEvent(eventName)) {
+    return {
+      delta: '',
+      done: false,
+      session: parseSessionFromMeta(eventName, trimmed, isJson ? payload : trimmed),
+    };
+  }
+
+  if (!isJson) {
+    if (isDonePayload(eventName, trimmed, trimmed)) {
+      return { delta: '', done: true };
+    }
+    if (!TEXT_EVENT_NAMES.has(eventName.toLowerCase())) {
+      return { delta: '', done: false };
+    }
+    return { delta: toDelta(normalizeSSEText(trimmed), emitted), done: false };
+  }
+
+  if (isErrorPayload(eventName, payload)) {
+    return {
+      delta: '',
+      done: true,
+      error: pickErrorMessage(payload) || '问答服务返回异常',
+    };
+  }
+
+  const record = unwrapRecord(payload) || unwrapRecord(unwrapPayload(payload));
+  const marker = String(record?.event || record?.type || '').toLowerCase();
+  if (marker && isMetaEvent(marker)) {
+    return {
+      delta: '',
+      done: false,
+      session: parseSessionFromMeta(marker, trimmed, payload),
+    };
+  }
+
+  const session = pickSession(payload);
+
+  if (isDonePayload(eventName, payload, trimmed)) {
+    const text = sanitizeVisibleText(pickText(unwrapPayload(payload)), session);
+    return {
+      delta: toDelta(text, emitted),
+      done: true,
+      session,
+    };
+  }
+
+  const text = sanitizeVisibleText(pickText(unwrapPayload(payload)), session);
+  return {
+    delta: toDelta(text, emitted),
+    done: false,
+    session,
+  };
+};
+
+const parseJsonResponse = async (response: Response): Promise<unknown> => {
+  const text = await response.text();
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    throw new Error(text.slice(0, 200) || '接口返回格式异常');
+  }
+};
+
+const assertHttpOk = async (response: Response, fallback: string) => {
+  if (response.ok) return;
+  let message = `${fallback}（${response.status}）`;
+  try {
+    const body = await parseJsonResponse(response);
+    message = pickErrorMessage(body) || message;
+  } catch (error) {
+    if (error instanceof Error) {
+      const { message: errorMessage } = error;
+      if (errorMessage.trim()) message = errorMessage;
+    }
+  }
+  throw new Error(message);
+};
+
+const assertBusinessOk = (value: unknown, fallback: string) => {
+  const record = unwrapRecord(value);
+  if (record && 'resultCode' in record && !isSuccessCode(record.resultCode)) {
+    throw new Error(pickErrorMessage(record) || fallback);
+  }
+  const inner = unwrapRecord(record?.resultObject);
+  if (inner && 'resultCode' in inner && !isSuccessCode(inner.resultCode)) {
+    throw new Error(pickErrorMessage(inner) || fallback);
+  }
+};
+
+/**
+ * 欢迎页首次提问：POST /nes/bote/chat/createBoteSession，拿到 chatId / contextId。
+ */
+export const createSession = async (params: CreateSessionParams): Promise<ChatSession> => {
+  const {
+    query,
+    knowledgeIdList = [],
+    noteIdList = [],
+    chatType = 'knowledge',
+    chatVersion = DEFAULT_CHAT_VERSION,
+    signal,
+  } = params;
+
+  if (signal?.aborted) {
+    throw new DOMException('Aborted', 'AbortError');
+  }
+
+  const headers = await buildRequestHeaders();
+  headers.Accept = 'application/json';
+
+  const response = await fetch(getBoteChatUrl(BOTE_CHAT_CREATE_SESSION_PATH), {
+    method: 'POST',
+    credentials: 'include',
+    headers,
+    body: JSON.stringify({
+      query,
+      stream: false,
+      knowledgeIdList,
+      noteIdList,
+      chatType,
+      chatVersion,
+      botId: DEFAULT_BOT_ID,
+      sceneId: DEFAULT_SCENE_ID,
+    }),
+    signal,
+  });
+
+  if (signal?.aborted) {
+    throw new DOMException('Aborted', 'AbortError');
+  }
+
+  await assertHttpOk(response, '创建会话失败');
+  const payload = await parseJsonResponse(response);
+  assertBusinessOk(payload, '创建会话失败');
+
+  const session = pickSession(payload);
+  if (!session?.chatId) {
+    throw new Error(pickErrorMessage(payload) || '创建会话失败：未返回会话标识');
+  }
+
+  return session;
+};
+
+const readJsonFallback = async (response: Response): Promise<string> => {
+  const text = await response.text();
+  if (!text.trim()) return '';
+  try {
+    const json = JSON.parse(text) as unknown;
+    if (isErrorPayload('message', json)) {
+      throw new Error(pickErrorMessage(json) || '问答服务返回异常');
+    }
+    return pickText(unwrapPayload(json)) || text;
+  } catch (error) {
+    if (error instanceof SyntaxError) return text;
+    throw error;
+  }
+};
+
+/**
+ * 流式问答：POST /nes/bote/chat/execute，按 SSE 逐段回调。
+ */
+export const streamChat = async (
+  params: StreamChatParams,
+  callbacks: StreamChatCallbacks,
+): Promise<void> => {
+  const {
+    query,
+    chatId,
+    contextId,
+    knowledgeIdList = [],
+    noteIdList = [],
+    chatType = 'knowledge',
+    chatVersion = DEFAULT_CHAT_VERSION,
+    signal,
+  } = params;
+
+  if (signal?.aborted) return;
+
+  try {
+    const headers = await buildRequestHeaders();
+    const body: Record<string, unknown> = {
+      query,
+      stream: true,
+      knowledgeIdList,
+      noteIdList,
+      chatType,
+      chatVersion,
+      botId: DEFAULT_BOT_ID,
+      sceneId: DEFAULT_SCENE_ID,
+      chatId: chatId || '',
+      contextId: contextId || '',
+    };
+
+    const response = await fetch(getBoteChatUrl(BOTE_CHAT_EXECUTE_PATH), {
+      method: 'POST',
+      credentials: 'include',
+      headers,
+      body: JSON.stringify(body),
+      signal,
+    });
+
+    if (signal?.aborted) return;
+
+    if (!response.ok) {
+      let message = `问答请求失败（${response.status}）`;
+      try {
+        const errBody = await response.text();
+        if (errBody.trim()) {
+          try {
+            message = pickErrorMessage(JSON.parse(errBody)) || errBody.slice(0, 200) || message;
+          } catch {
+            message = errBody.slice(0, 200);
+          }
+        }
+      } catch {
+        // ignore
+      }
+      callbacks.onError(message);
+      return;
+    }
+
+    const contentType = response.headers.get('content-type') || '';
+    const isJsonBody = contentType.includes('application/json');
+
+    if (!response.body || isJsonBody) {
+      const text = await readJsonFallback(response);
+      if (signal?.aborted) return;
+      if (text) callbacks.onChunk(text);
+      callbacks.onDone();
+      return;
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let emitted = '';
+    let settled = false;
+    let currentEvent = 'message';
+
+    const emitSession = (session: ChatSession | null | undefined) => {
+      if (!session || (!session.chatId && !session.contextId)) return;
+      callbacks.onSession?.({
+        chatId: session.chatId || chatId,
+        contextId: session.contextId || contextId,
+      });
+    };
+
+    const finish = (error?: string) => {
+      if (settled) return;
+      settled = true;
+      if (error) callbacks.onError(error);
+      else callbacks.onDone();
+    };
+
+    const handleData = (eventName: string, rawData: string) => {
+      const result = consumePayload(eventName, rawData, emitted);
+      emitSession(result.session);
+      if (result.delta) {
+        emitted += result.delta;
+        callbacks.onChunk(result.delta);
+      }
+      if (result.error) {
+        finish(result.error);
+        return true;
+      }
+      if (result.done) {
+        finish();
+        return true;
+      }
+      return false;
+    };
+
+    const consumeLine = (rawLine: string) => {
+      const line = rawLine.replace(/^\uFEFF/, '');
+      if (!line) {
+        currentEvent = 'message';
+        return false;
+      }
+      if (line.startsWith(':')) return false;
+      if (line.startsWith('event:')) {
+        currentEvent = line.slice(6).trim() || 'message';
+        return false;
+      }
+      if (line.startsWith('data:')) {
+        return handleData(currentEvent, line.slice(5).trimStart());
+      }
+      if (line.startsWith('{') || line.startsWith('[')) {
+        return handleData(currentEvent, line);
+      }
+      return false;
+    };
+
+    while (!signal?.aborted && !settled) {
+      const { done, value } = await reader.read();
+      if (done) {
+        buffer += decoder.decode();
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (consumeLine(line)) {
+          await reader.cancel().catch(() => undefined);
+          return;
+        }
+      }
+    }
+
+    if (signal?.aborted) {
+      await reader.cancel().catch(() => undefined);
+      return;
+    }
+
+    if (buffer.trim()) consumeLine(buffer.trim());
+    if (!settled) finish();
+  } catch (error) {
+    if (signal?.aborted || isAbortError(error)) return;
+    const message = error instanceof Error && error.message.trim() ? error.message : '流式输出异常';
+    callbacks.onError(message);
+  }
+};

package/template/packages/xiaozhi-chat/types.ts

@@ -0,0 +1,80 @@
+import type { ReactNode } from 'react';
+
+export type ChatRole = 'user' | 'assistant';
+
+export type ChatMessage = {
+  id: string;
+  role: ChatRole;
+  content: string;
+  timestamp: number;
+
+  /** 用户手动停止流式输出 */
+  isStopped?: boolean;
+
+  /** 占位/真实流式异常 */
+  isReplyError?: boolean;
+
+  /** 回复版本：1 快速 / 2 专家 */
+  chatVersion?: '1' | '2';
+};
+
+export type ChatVersion = '1' | '2';
+
+export const DEFAULT_CHAT_VERSION: ChatVersion = '2';
+
+export type ChatSession = {
+  chatId: string;
+  contextId: string;
+};
+
+export type ChatType = 'knowledge' | 'note';
+
+export type CreateSessionParams = {
+  query: string;
+  knowledgeIdList?: string[];
+  noteIdList?: string[];
+  chatType?: ChatType;
+  chatVersion?: ChatVersion;
+  signal?: AbortSignal;
+};
+
+export type StreamChatCallbacks = {
+  onChunk: (text: string) => void;
+  onDone: () => void;
+  onError: (message: string) => void;
+
+  /** execute 流中回写的会话标识 */
+  onSession?: (session: ChatSession) => void;
+};
+
+export type StreamChatParams = {
+  query: string;
+  chatId: string;
+  contextId: string;
+  knowledgeIdList?: string[];
+  noteIdList?: string[];
+  chatType?: ChatType;
+  chatVersion?: ChatVersion;
+  signal?: AbortSignal;
+};
+
+export type XiaozhiChatPageProps = {
+
+  /** 输入框上方快捷菜单插槽 */
+  shortcutSlot?: ReactNode;
+
+  /** 欢迎页主标题 */
+  welcomeTitle?: string;
+
+  /** 欢迎页副文案 */
+  welcomeSubtitle?: string;
+
+  /** 输入框占位符 */
+  placeholder?: string;
+
+  /** 顶部标题 */
+  title?: string;
+
+  /** 自定义返回 */
+  onBack?: () => void;
+};