@talknote/create-talknote-h5 0.1.4 → 0.1.5

package/template/packages/xiaozhi-chat/utils/bridge.ts

@@ -0,0 +1,131 @@
+/** 直接使用 App 注入的 window.vibeNoteBridge */
+
+export type KeyboardAvoidMode = 'adjust' | 'resize' | 'none';
+
+export type TranscriptionResultData = {
+  text?: string;
+  isFinal?: boolean;
+  translations?: Record<string, string>;
+  startMs?: number;
+  endMs?: number;
+};
+
+export type TranscriptionStatusData = {
+  status?: 'idle' | 'connecting' | 'streaming' | 'closed' | 'error';
+};
+
+export type TranscriptionErrorData = {
+  code?: string;
+  message?: string;
+};
+
+export type NativeBridgeEvent<T = unknown> = {
+  type?: string;
+  data?: T;
+};
+
+export type StartRealtimeTranscriptionOptions = {
+  wsUrl: string;
+  targetLanguages?: string[];
+  translationMode?: 'fast' | 'normal';
+  headers?: Record<string, string>;
+  onlineTransBatchId?: string;
+};
+
+export type RequestBaseInfo = {
+  baseUrl?: string;
+  token?: string;
+  headers?: Record<string, string>;
+  env?: string;
+};
+
+export type VibeNoteBridgeLike = {
+  canIUse?: (name: string) => boolean;
+  goBack?: () => Promise<unknown> | unknown;
+  setKeyboardAvoidMode?: (data: {
+    mode: KeyboardAvoidMode;
+    cursorSpacing?: number;
+  }) => Promise<{ mode?: KeyboardAvoidMode; cursorSpacing?: number }>;
+  hideKeyboard?: () => Promise<unknown>;
+  getRequestBaseInfo?: () => Promise<RequestBaseInfo>;
+  canVoiceInput?: () => Promise<{ canVoiceInput?: boolean }>;
+  startVoiceRecording?: () => Promise<unknown>;
+  cancelVoiceRecording?: () => Promise<unknown>;
+  stopVoiceRecording?: () => Promise<{ text?: string; uri?: string }>;
+  startRealtimeTranscription?: (
+    options: StartRealtimeTranscriptionOptions,
+  ) => Promise<{ success?: boolean }>;
+  stopRealtimeTranscription?: () => Promise<{ success?: boolean }>;
+  addListener?: (
+    type: string,
+    handler: (event: NativeBridgeEvent) => void,
+  ) => () => void;
+  getAuthTicket?: () => Promise<{ ticket?: string }>;
+};
+
+declare global {
+  interface Window {
+    vibeNoteBridge?: VibeNoteBridgeLike;
+  }
+}
+
+export const getVibeNoteBridge = (): VibeNoteBridgeLike | undefined =>
+  typeof window !== 'undefined' ? window.vibeNoteBridge : undefined;
+
+export const isVibeNoteBridgeAvailable = (): boolean => Boolean(getVibeNoteBridge());
+
+export const vibeNoteCanIUse = (name: string): boolean => {
+  const bridge = getVibeNoteBridge();
+  if (!bridge?.canIUse) return false;
+  try {
+    return Boolean(bridge.canIUse(name));
+  } catch {
+    return false;
+  }
+};
+
+export const setKeyboardAvoidMode = async (mode: KeyboardAvoidMode, cursorSpacing?: number) => {
+  if (!vibeNoteCanIUse('setKeyboardAvoidMode')) return false;
+  const bridge = getVibeNoteBridge();
+  if (!bridge?.setKeyboardAvoidMode) return false;
+  const data = cursorSpacing === undefined ? { mode } : { mode, cursorSpacing };
+  await bridge.setKeyboardAvoidMode(data);
+  return true;
+};
+
+export const hideVibeNoteKeyboard = () => {
+  const el = typeof document !== 'undefined' ? document.activeElement : null;
+  if (el instanceof HTMLElement) {
+    el.blur();
+  }
+  if (!vibeNoteCanIUse('hideKeyboard')) return;
+  void getVibeNoteBridge()?.hideKeyboard?.();
+};
+
+const ASR_WS_BY_ENV: Record<string, string> = {
+  PRO: 'wss://www.zzjilu.com/ws/realtime/transcribe',
+  TEST: 'wss://lingxi.iwhalecloud.com/zzjl/ws/realtime/transcribe',
+  DEV: 'wss://lingxi.iwhalecloud.com/LCDP-RECORD/ws/realtime/transcribe',
+  STAGING: 'wss://www.zzjilu.com:9001/ws/realtime/transcribe',
+};
+
+/** 由请求基址或环境推导实时转写 WebSocket 地址 */
+export const resolveAsrWsUrl = (baseUrl?: string, env?: string): string => {
+  const envKey = String(env || '')
+    .trim()
+    .toUpperCase();
+  if (ASR_WS_BY_ENV[envKey]) return ASR_WS_BY_ENV[envKey];
+
+  if (baseUrl) {
+    try {
+      const url = new URL(baseUrl);
+      const protocol = url.protocol === 'http:' ? 'ws:' : 'wss:';
+      const prefix = url.pathname.replace(/\/lcdp-app(?:\/.*)?$/i, '').replace(/\/$/, '');
+      return `${protocol}//${url.host}${prefix}/ws/realtime/transcribe`;
+    } catch {
+      /* ignore */
+    }
+  }
+
+  return ASR_WS_BY_ENV.PRO;
+};

package/template/packages/xiaozhi-chat/utils/deepThinking.ts

@@ -0,0 +1,200 @@
+import type { ChatVersion } from '../types';
+
+/** Chat V1：打字机输出时保持完整，避免半截标签被当成思考阶段判断 */
+export const KNOWLEDGE_CHAT_TYPEWRITER_ATOMIC_TOKENS = [
+  '<|THINKING_START|>',
+  '<|THINKING_END|>',
+  '<think>',
+  '</think>',
+] as const;
+
+export const KNOWLEDGE_CHAT_TYPEWRITER_ATOMIC_CLOSED_TAGS = [
+  'toolCall',
+  'toolCallResult',
+] as const;
+
+const THINKING_BLOCK_REGEX = /<think>[\s\S]*?<\/think>/g;
+const THINKING_BLOCK_CAPTURE_REGEX = /<think>([\s\S]*?)<\/think>/g;
+const THINKING_STAGE_BLOCK_REGEX = /<\|THINKING_START\|>[\s\S]*?<\|THINKING_END\|>/g;
+const THINKING_START = '<|THINKING_START|>';
+const THINKING_END = '<|THINKING_END|>';
+
+export type MessageContentView = {
+  isDeepThinking: boolean;
+  isFinishDeepThink: boolean;
+  thinkingContent: string;
+  answerContent: string;
+};
+
+/** 根据打字机 content 判断是否处于深度思考流式阶段（标记需完整，依赖 atomicTokens） */
+export const isDeepThinkingStreamContent = (content: string): boolean => {
+  const thinkingStarted = content.includes('<think>') || content.includes(THINKING_START);
+  const thinkingEnded = content.includes(THINKING_END);
+  return thinkingStarted && !thinkingEnded;
+};
+
+/** 从原始流式文本中去除思考块与阶段标记，得到可展示的回答正文 */
+export const stripAnswerContentFromRaw = (content: string): string =>
+  content
+    .replace(THINKING_BLOCK_REGEX, '')
+    .replace(THINKING_STAGE_BLOCK_REGEX, '')
+    .replace(/<\|THINKING_START\|>/g, '')
+    .replace(/<\|THINKING_END\|>/g, '')
+    .replace(/<think>/g, '')
+    .replace(/<\/think>/g, '')
+    .trim();
+
+/** 流式思考阶段：仅剥除标签，保留思考正文（思考块可能尚未闭合） */
+export const stripThinkingMarkersFromStream = (content: string): string =>
+  content
+    .replace(/<think>/g, '')
+    .replace(/<\/think>/g, '')
+    .replace(/<\/redacted_thinking>/g, '')
+    .replace(/<\|THINKING_START\|>/g, '')
+    .replace(/<\|THINKING_END\|>/g, '');
+
+/** 从已闭合的思考块中提取思考正文 */
+export const extractThinkingBlocksFromRaw = (content: string): string => {
+  const contents: string[] = [];
+  const matches = content.matchAll(THINKING_BLOCK_CAPTURE_REGEX);
+  for (const match of matches) {
+    if (match[1]?.trim()) {
+      contents.push(match[1].trim());
+    }
+  }
+  if (contents.length > 0) {
+    return contents.join('\n');
+  }
+
+  const start = content.indexOf(THINKING_START);
+  const end = content.indexOf(THINKING_END);
+  if (start >= 0 && end > start) {
+    return content.slice(start + THINKING_START.length, end).trim();
+  }
+  return '';
+};
+
+/** Chat V1：使用 <|THINKING_*|> / <think> 标记拆分思考过程与回答 */
+export const resolveMessageContentV1 = (
+  content: string,
+  isStreamingMessage: boolean,
+  isReplyError: boolean,
+): MessageContentView => {
+  const streamText = content || '';
+  const isDeepThinking = isStreamingMessage && isDeepThinkingStreamContent(streamText);
+
+  let thinkingContent = '';
+  if (streamText) {
+    thinkingContent =
+      isStreamingMessage && isDeepThinking
+        ? stripThinkingMarkersFromStream(streamText).trim()
+        : extractThinkingBlocksFromRaw(streamText);
+  }
+
+  const isFinishDeepThink = !isDeepThinking && thinkingContent.length > 0;
+
+  let answerContent = '';
+  if (isReplyError) {
+    answerContent = content;
+  } else {
+    answerContent = streamText && !isDeepThinking ? stripAnswerContentFromRaw(streamText) : '';
+  }
+
+  return {
+    isDeepThinking,
+    isFinishDeepThink,
+    thinkingContent,
+    answerContent,
+  };
+};
+
+/** Markdown 分割线：独立成行的 --- / *** / ___ */
+const MARKDOWN_HR_REGEX = /^ {0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/m;
+
+/** Markdown 标题：行首 # ~ ###### */
+const MARKDOWN_HEADING_REGEX = /^#{1,6}\s+.+/m;
+
+/**
+ * 将紧贴正文的分割线规范为独立成行形式：
+ * `---\n\n` / `***\n\n` / `___\n\n` → `\n\n---\n\n`
+ */
+const normalizeMarkdownHr = (content: string): string =>
+  content.replace(/(?:-{3,}|\*{3,}|_{3,})\r?\n\r?\n/g, '\n\n---\n\n');
+
+/**
+ * Chat V2：按第一条分割线或第一个标题拆分思考与回答。
+ * 尚无分隔标记时，整段视为思考内容。
+ */
+export const stripContentFromRawV2 = (content: string): [string, string] => {
+  if (!content) {
+    return ['', ''];
+  }
+
+  const normalized = normalizeMarkdownHr(content);
+
+  const hrMatch = normalized.match(MARKDOWN_HR_REGEX);
+  if (hrMatch?.index !== undefined) {
+    const thinkContent = normalized.slice(0, hrMatch.index).replace(/\r?\n+$/, '');
+    const answerContent = normalized.slice(hrMatch.index + hrMatch[0].length).replace(/^\r?\n+/, '');
+    return [thinkContent, answerContent];
+  }
+
+  const headingMatch = normalized.match(MARKDOWN_HEADING_REGEX);
+  if (headingMatch?.index !== undefined) {
+    const thinkContent = normalized.slice(0, headingMatch.index).replace(/\r?\n+$/, '');
+    const answerContent = normalized.slice(headingMatch.index);
+    return [thinkContent, answerContent];
+  }
+
+  return [content, ''];
+};
+
+/** Chat V2：自主规划，按分割线/标题拆分思考过程 */
+export const resolveMessageContentV2 = (
+  content: string,
+  isStreamingMessage: boolean,
+  isReplyError: boolean,
+): MessageContentView => {
+  const streamText = content || '';
+
+  let thinkingContent = '';
+  let answerContent = '';
+  if (isReplyError) {
+    answerContent = content;
+  } else {
+    [thinkingContent, answerContent] = stripContentFromRawV2(streamText);
+  }
+
+  if (!isStreamingMessage && !answerContent) {
+    answerContent = streamText;
+    thinkingContent = '';
+  }
+
+  return {
+    isDeepThinking: !!thinkingContent && !answerContent && isStreamingMessage,
+    isFinishDeepThink: !!answerContent || !isStreamingMessage,
+    thinkingContent,
+    answerContent,
+  };
+};
+
+export const normalizeChatVersion = (chatVersion?: ChatVersion | number): ChatVersion => {
+  if (chatVersion === 2 || chatVersion === '2') {
+    return '2';
+  }
+  return '1';
+};
+
+/** 按 chatVersion 解析消息 content */
+export const resolveMessageContent = (
+  content: string,
+  isStreamingMessage: boolean,
+  isReplyError: boolean,
+  chatVersion?: ChatVersion | number,
+): MessageContentView => {
+  const version = normalizeChatVersion(chatVersion);
+  if (version === '2') {
+    return resolveMessageContentV2(content, isStreamingMessage, isReplyError);
+  }
+  return resolveMessageContentV1(content, isStreamingMessage, isReplyError);
+};

package/template/packages/xiaozhi-chat/utils/parseAssistantContent.ts

@@ -0,0 +1,233 @@
+export type ToolCallGroup = {
+  toolNameAlias: string;
+  total: number;
+  executed: number;
+  hasError: boolean;
+};
+
+export type AssistantContentSegment =
+  | { type: 'markdown'; content: string }
+  | { type: 'toolCalls'; groups: ToolCallGroup[] };
+
+type ToolCallPayload = {
+  toolNameAlias?: string;
+  toolCallId?: string;
+  toolName?: string;
+};
+
+type ToolCallResultPayload = {
+  toolNameAlias?: string;
+  toolCallId?: string;
+  toolName?: string;
+  success?: boolean;
+};
+
+type ParsedTag =
+  | {
+      kind: 'toolCall';
+      start: number;
+      end: number;
+      toolNameAlias: string;
+      toolCallId: string;
+    }
+  | {
+      kind: 'toolCallResult';
+      start: number;
+      end: number;
+      toolNameAlias: string;
+      toolCallId: string;
+      success: boolean;
+    };
+
+type ToolRegion = {
+  start: number;
+  end: number;
+  tags: ParsedTag[];
+};
+
+const TOOL_TAG_REGEX = /<(toolCall|toolCallResult)>([\s\S]*?)<\/\1>/g;
+
+const isWhitespaceOnly = (value: string): boolean => /^\s*$/.test(value);
+
+const safeParseJson = <T>(raw: string): T | null => {
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return null;
+  }
+};
+
+const parseAllTags = (content: string): ParsedTag[] => {
+  const tags: ParsedTag[] = [];
+  TOOL_TAG_REGEX.lastIndex = 0;
+
+  let match = TOOL_TAG_REGEX.exec(content);
+  while (match) {
+    const kind = match[1] as 'toolCall' | 'toolCallResult';
+    const rawJson = match[2] || '';
+    const start = match.index;
+    const end = match.index + match[0].length;
+
+    if (kind === 'toolCall') {
+      const data = safeParseJson<ToolCallPayload>(rawJson);
+      const toolNameAlias = data?.toolNameAlias?.trim();
+      if (toolNameAlias) {
+        tags.push({
+          kind: 'toolCall',
+          start,
+          end,
+          toolNameAlias,
+          toolCallId: data?.toolCallId || `${toolNameAlias}-${start}`,
+        });
+      }
+    } else {
+      const data = safeParseJson<ToolCallResultPayload>(rawJson);
+      const toolNameAlias = data?.toolNameAlias?.trim();
+      if (toolNameAlias) {
+        tags.push({
+          kind: 'toolCallResult',
+          start,
+          end,
+          toolNameAlias,
+          toolCallId: data?.toolCallId || `${toolNameAlias}-${start}`,
+          success: data?.success !== false,
+        });
+      }
+    }
+
+    match = TOOL_TAG_REGEX.exec(content);
+  }
+
+  return tags;
+};
+
+const buildRegions = (content: string, tags: ParsedTag[]): ToolRegion[] => {
+  if (!tags.length) {
+    return [];
+  }
+
+  const regions: ToolRegion[] = [];
+  let current: ToolRegion | null = null;
+
+  tags.forEach((tag) => {
+    if (current && isWhitespaceOnly(content.slice(current.end, tag.start))) {
+      current.tags.push(tag);
+      current.end = tag.end;
+      return;
+    }
+    current = { start: tag.start, end: tag.end, tags: [tag] };
+    regions.push(current);
+  });
+
+  return regions;
+};
+
+const buildResultsByCallId = (tags: ParsedTag[]): Map<string, { success: boolean }> => {
+  const results = new Map<string, { success: boolean }>();
+  tags.forEach((tag) => {
+    if (tag.kind !== 'toolCallResult') {
+      return;
+    }
+    const prev = results.get(tag.toolCallId);
+    results.set(tag.toolCallId, {
+      success: prev ? prev.success && tag.success : tag.success,
+    });
+  });
+  return results;
+};
+
+const buildRegionGroups = (
+  region: ToolRegion,
+  resultsByCallId: Map<string, { success: boolean }>,
+): ToolCallGroup[] => {
+  const aliasOrder: string[] = [];
+  const callIdsByAlias = new Map<string, string[]>();
+
+  region.tags.forEach((tag) => {
+    if (tag.kind !== 'toolCall') {
+      return;
+    }
+    let ids = callIdsByAlias.get(tag.toolNameAlias);
+    if (!ids) {
+      ids = [];
+      callIdsByAlias.set(tag.toolNameAlias, ids);
+      aliasOrder.push(tag.toolNameAlias);
+    }
+    if (!ids.includes(tag.toolCallId)) {
+      ids.push(tag.toolCallId);
+    }
+  });
+
+  return aliasOrder.map((alias) => {
+    const callIds = callIdsByAlias.get(alias) || [];
+    let executed = 0;
+    let hasError = false;
+
+    callIds.forEach((callId) => {
+      const result = resultsByCallId.get(callId);
+      if (!result) {
+        return;
+      }
+      executed += 1;
+      if (!result.success) {
+        hasError = true;
+      }
+    });
+
+    return {
+      toolNameAlias: alias,
+      total: callIds.length,
+      executed,
+      hasError,
+    };
+  });
+};
+
+const stripIncompleteToolTags = (content: string): string =>
+  content.replace(/<(toolCall|toolCallResult)>(?:(?!<\/\1>)[\s\S])*$/, '');
+
+/**
+ * 将消息内容拆成 markdown 段与工具调用段。
+ * 相同 toolNameAlias 仅在相邻（仅空白分隔）时合并。
+ */
+export const parseAssistantContentSegments = (content: string): AssistantContentSegment[] => {
+  if (!content) {
+    return [];
+  }
+
+  const normalized = stripIncompleteToolTags(content);
+  const tags = parseAllTags(normalized);
+  if (!tags.length) {
+    return [{ type: 'markdown', content: normalized }];
+  }
+
+  const resultsByCallId = buildResultsByCallId(tags);
+  const regions = buildRegions(normalized, tags);
+  const segments: AssistantContentSegment[] = [];
+  let cursor = 0;
+
+  regions.forEach((region) => {
+    if (region.start > cursor) {
+      const markdown = normalized.slice(cursor, region.start);
+      if (markdown) {
+        segments.push({ type: 'markdown', content: markdown });
+      }
+    }
+
+    const groups = buildRegionGroups(region, resultsByCallId);
+    if (groups.length) {
+      segments.push({ type: 'toolCalls', groups });
+    }
+
+    cursor = region.end;
+  });
+
+  if (cursor < normalized.length) {
+    const markdown = normalized.slice(cursor);
+    if (markdown) {
+      segments.push({ type: 'markdown', content: markdown });
+    }
+  }
+
+  return segments.length ? segments : [{ type: 'markdown', content: normalized }];
+};