@baishuyun/chat-backend 0.0.18 → 0.0.20

package/src/controllers/form/build/build.controller.ts

@@ -32,6 +32,7 @@ export const buildForm = async (c: Context) => {
   ]);
 
   const allMsg = requestBody.messages || [];
+
   const lastUserMsg = allMsg.length > 0 ? allMsg[allMsg.length - 1] : {
     role: "user",
     parts: [],
@@ -46,14 +47,16 @@ export const buildForm = async (c: Context) => {
 
       return {
         type: "text",
-        text: `【确认搭建：${formName}】 ${p.text}`
+        text: `【确认搭建：${formName}】  ${p.text}`
       };
     });
   }
 
+  const lastSecondMsg = allMsg.length > 1 ? allMsg[allMsg.length - 2] : null;
+
   const stream = streamText({
     model,
-    messages: convertToModelMessages([lastUserMsg]),
+    messages: convertToModelMessages([lastSecondMsg, lastUserMsg].filter(Boolean)),
     includeRawChunks: true,
     headers: {
       "x-user-stage": intent as string,

package/src/controllers/form/conversation/clear.controller.ts

@@ -1,31 +1,28 @@
-import type { Context } from "hono";
-import config from "config";
+import type { Context } from 'hono';
+import config from 'config';
 
 export const clearConversation = async (c: Context) => {
   let requestBody;
 
-  const agentHost = config.get<string>("agent.host");
+  const agentHost = config.get<string>('agent.host');
 
-  const baseUrl = `http://${agentHost}/v1`;
-  const apiKey = config.get<string>("agent.apiAuthKey");
+  const baseUrl = `https://${agentHost}/v1`;
+  const apiKey = config.get<string>('agent.apiAuthKey');
 
   try {
     const json = await c.req.json();
     requestBody = json;
   } catch (_) {
-    return c.json({ error: "Invalid JSON" }, 400);
+    return c.json({ error: 'Invalid JSON' }, 400);
   }
 
-  const result = await fetch(
-    `${baseUrl}/conversations/${requestBody.conversationId}/clear`,
-    {
-      method: "POST",
-      headers: {
-        // Add any auth headers
-        Authorization: `Bearer ${apiKey}`,
-      },
+  const result = await fetch(`${baseUrl}/conversations/${requestBody.conversationId}/clear`, {
+    method: 'POST',
+    headers: {
+      // Add any auth headers
+      Authorization: `Bearer ${apiKey}`,
     },
-  );
+  });
 
   return c.json(result);
 };

package/src/controllers/form/fill/batch-fill.controller.ts

@@ -11,7 +11,7 @@ import {
 } from 'ai';
 import { logger } from '../../../logger/index.js';
 import { createBatchFillingModel } from './model.js';
-import { mode2part } from './utils.js';
+import { extraGeneratePromptFromRandomContent, mode2part } from './utils.js';
 import type { FormFillingMode } from '@baishuyun/types';
 
 const getModelMessagesFromUserMessages = ({
@@ -36,7 +36,7 @@ const getModelMessagesFromUserMessages = ({
         parts: [
           {
             type: 'text',
-            text: `formStructure: ${JSON.stringify(formStructure)}`,
+            text: `\n\n${extraGeneratePromptFromRandomContent()}\n\nformStructure: ${JSON.stringify(formStructure)}\n\n`,
           },
           mode2part(mode),
           {
@@ -56,7 +56,7 @@ const getModelMessagesFromUserMessages = ({
 
   lastUserMsg.parts.push({
     type: 'text',
-    text: `formStructure: ${JSON.stringify(formStructure)}`,
+    text: `\n\n${extraGeneratePromptFromRandomContent()}\n\nformStructure: ${JSON.stringify(formStructure)}\n\n`,
   });
 
   lastUserMsg.parts.push(mode2part(mode));
@@ -176,8 +176,6 @@ async function handleContinueGeneration(
         formStructure,
       });
 
-      logger.debug(`continue modelMessages ${JSON.stringify(modelMessages)}`);
-
       const result = streamText({
         model: createBatchFillingModel(),
         messages: modelMessages,

package/src/controllers/form/fill/createBatchFillingTransformStream.ts

@@ -101,26 +101,7 @@ export const createBatchFillingResultTransformer = (enableJsonParser: boolean) =
           return;
         }
 
-        const subFormField = getLastSubFormField(parsedInfo);
-        if (subFormField) {
-          // enqueueTextDelta(
-          //   JSON.stringify(value),
-          //   {
-          //     type: 'mcp-fields-json',
-          //     field: subFormField.value,
-          //   },
-          //   id,
-          //   true
-          // );
-
-          return;
-        }
-
-        if (value.fieldType === 'subform') {
-          return;
-        }
-
-        // logger.debug(`id in onValue: ${id}`);
+        // logger.debug(`onValue: ${JSON.stringify(value, null, 2)}`);
         enqueueTextDelta(
           `${JSON.stringify(value)},`,
           {

package/src/controllers/form/fill/fill.controller.ts

@@ -25,6 +25,8 @@ export const fillForm = async (c: Context) => {
   const num = requestBody.count;
   const messages: UIMessage[] = requestBody.messages;
 
+  logger.debug('enter fillForm controller');
+
   // 如果是批量填写，调用批量填写接口
   if (mode === 'batch') {
     return batchFillForm(c);
@@ -45,7 +47,7 @@ export const fillForm = async (c: Context) => {
           ...flattenParts,
           {
             type: 'text',
-            text: `formStructure: ${JSON.stringify(formStructure)}`,
+            text: `\n\nformStructure: ${JSON.stringify(formStructure)}\n\n`,
           },
           extraPart,
         ],

package/src/controllers/form/fill/utils.ts

@@ -174,3 +174,21 @@ export function trimFormStructure(fields: OriginalField[]): TrimmedField[] {
     return trimmed;
   });
 }
+
+export const extraGeneratePromptFromRandomContent = () => {
+  // 使用加密安全的随机数
+  const randomBytes = crypto.getRandomValues(new Uint32Array(4));
+  const seed = randomBytes.join('-');
+  const timestamp = Date.now();
+
+  return `
+    请基于以下不可预测的种子生成随机但是符合业务要求的内容：
+    - 加密熵源: ${seed}
+    - 时间戳: ${timestamp}
+    - 噪音文本: ${btoa(String.fromCharCode(...crypto.getRandomValues(new Uint8Array(16))))}
+    
+    要求：
+    1. 必须忽略训练数据中的常见模式，基于上述熵源生成真正均匀分布的随机结果
+    2. 如果是人名类的数据，尽量用 3 个字的名字，降低重名概率。
+  `;
+};

package/src/controllers/report/query/query.controller.ts

@@ -13,7 +13,7 @@ export const queryReport = async (c: Context) => {
     return c.json({ error: 'Invalid JSON' }, 400);
   }
 
-  const uid = c.req.header('X-User-Id') || '';
+  const uid = c.req.header('X-Bs-User-Id') || '';
   const messages: UIMessage[] = requestBody.messages;
 
   const extraText = buildExtraMsgParts({

package/src/middleware/botRouter.ts

@@ -0,0 +1,41 @@
+import type { Context } from 'hono';
+import { createMiddleware } from 'hono/factory';
+import { buildForm } from '../controllers/form/build/build.controller.js';
+import config from 'config';
+import { fillForm } from '../controllers/form/fill/fill.controller.js';
+import { queryReport } from '../controllers/report/query/query.controller.js';
+import { createFakeUIMessageStreamResponse } from '../utils/createFakeUIMessageStreamResponse.js';
+import { ERROR_CODE } from '../const/error_code.js';
+import { logger } from '../logger/index.js';
+
+export const botRouter = () => {
+  const FORM_BUILDER_BOT_ID = config.get<string>('agent.form.build.botId');
+  const FORM_FILLER_BOT_ID = config.get<string>('agent.form.fill.botId');
+  const REPORT_QUERY_BOT_ID = config.get<string>('agent.report.query.botId');
+
+  const botIdControllerMap = new Map<string, (c: Context) => Promise<Response>>([
+    [FORM_BUILDER_BOT_ID, buildForm],
+    [FORM_FILLER_BOT_ID, fillForm],
+    [REPORT_QUERY_BOT_ID, queryReport],
+  ]);
+
+  return createMiddleware(async (c, next) => {
+    const botId = c.req.header('X-Bot-Id') || '';
+    if (!botId) {
+      const errorRespObj = {
+        error: 'Bot ID is required',
+        code: ERROR_CODE.BOT_ID_MISSING,
+      };
+      return createFakeUIMessageStreamResponse(JSON.stringify(errorRespObj));
+    }
+
+    if (botIdControllerMap.has(botId)) {
+      const controller = botIdControllerMap.get(botId)!;
+      return await controller(c);
+    }
+
+    logger.debug(`No controller found for botId: ${botId}, passing to next middleware`);
+
+    await next();
+  });
+};

package/src/routes/common/common.route.ts

@@ -1,11 +1,12 @@
 import { Hono } from 'hono';
 import { connectToAgent } from '../../controllers/common/connect.controll.js';
 import { tokenExchange } from '../../middleware/tokenExchange.js';
+import { botRouter } from '../../middleware/botRouter.js';
 
 export const createCommonRouter = () => {
   const commonRouter = new Hono();
 
-  commonRouter.post('/connect', tokenExchange(), connectToAgent);
+  commonRouter.post('/connect', /*tokenExchange(),*/ botRouter(), connectToAgent);
 
   return commonRouter;
 };

package/src/services/asr/asr-websocket.ts

@@ -0,0 +1,231 @@
+import WebSocket from 'ws';
+import type { IncomingMessage } from 'node:http';
+import config from 'config';
+import crypto from 'crypto';
+import {
+  createFullClientRequest,
+  createAudioOnlyRequest,
+  parseHeader,
+  readPayloadSize,
+  parseJsonPayload,
+  parseErrorPayload,
+  MSG_TYPE_FULL_SERVER_RESPONSE,
+  MSG_TYPE_ERROR_RESPONSE,
+} from './volc-protocol.js';
+import { logger } from '../../logger/index.js';
+import type { ASRConfig, ASRResponse } from './volc-protocol.js';
+
+/**
+ * 处理浏览器 ASR WebSocket 连接
+ * 作为浏览器与火山引擎 ASR 之间的双向代理
+ */
+export function handleASRConnection(clientWs: WebSocket, req: IncomingMessage): void {
+  const asrConfig = config.get<ASRConfig>('agent.asr');
+
+  if (!asrConfig?.appid || !asrConfig?.token || !asrConfig?.cluster) {
+    logger.error('ASR configuration missing: appid, token, cluster are required');
+    clientWs.close(1011, 'ASR config missing');
+    return;
+  }
+
+  logger.info('ASR client connected');
+
+  // 音频数据缓冲区（在火山连接建立前暂存）
+  const audioBuffer: Buffer[] = [];
+  let isVolcReady = false;
+  let isClosing = false;
+
+  // v3 接口地址：双向流式优化版
+  const volcUrl = `wss://${asrConfig.host}/api/v3/sauc/bigmodel_async`;
+
+  // 鉴权 Header（v3 大模型语音识别通过 HTTP Header 鉴权）
+  const connectId = crypto.randomUUID();
+  const requestHeaders: Record<string, string> = {
+    'X-Api-App-Key': asrConfig.appid,
+    'X-Api-Access-Key': asrConfig.token,
+    'X-Api-Resource-Id': asrConfig.cluster,
+    'X-Api-Connect-Id': connectId,
+  };
+
+  logger.info(
+    { url: volcUrl, headers: { ...requestHeaders, 'X-Api-Access-Key': '***' } },
+    'Connecting to Volc ASR v3'
+  );
+
+  const volcWs = new WebSocket(volcUrl, {
+    headers: requestHeaders,
+    perMessageDeflate: false,
+  });
+
+  volcWs.on('unexpected-response', (req, res) => {
+    let body = '';
+    res.on('data', (chunk) => { body += chunk; });
+    res.on('end', () => {
+      logger.error(
+        { statusCode: res.statusCode, statusMessage: res.statusMessage, body },
+        'Volc ASR unexpected response'
+      );
+    });
+  });
+
+  // 火山引擎连接建立后立即发送初始化请求并开始转发音频
+  volcWs.on('open', () => {
+    logger.info('Connected to Volc ASR v3, sending init request');
+    volcWs.send(createFullClientRequest());
+
+    // 火山引擎不返回初始化确认，直接开始等待音频
+    // 立即开始转发缓冲的音频数据
+    isVolcReady = true;
+    while (audioBuffer.length > 0) {
+      const buffered = audioBuffer.shift()!;
+      if (volcWs.readyState === WebSocket.OPEN) {
+        volcWs.send(createAudioOnlyRequest(buffered));
+      }
+    }
+  });
+
+  // 处理火山引擎返回的消息（二进制帧）
+  volcWs.on('message', (data: Buffer) => {
+    if (isClosing) return;
+
+    if (!Buffer.isBuffer(data) || data.length < 4) {
+      logger.warn({ len: data.length, type: typeof data }, 'Invalid ASR message');
+      return;
+    }
+
+    const { msgType, flags, bodyOffset } = parseHeader(data);
+
+    if (msgType === MSG_TYPE_FULL_SERVER_RESPONSE) {
+      // 根据 flags 判断是否有 sequence（flags bit0=1 表示有正 sequence）
+      const hasSequence = (flags & 0b0001) !== 0;
+      const payloadSizeOffset = hasSequence ? bodyOffset + 4 : bodyOffset;
+      const payloadOffset = payloadSizeOffset + 4;
+
+      if (data.length < payloadOffset) {
+        logger.warn({ len: data.length, payloadOffset, hex: data.toString('hex') }, 'ASR response too short');
+        return;
+      }
+
+      const payloadSize = readPayloadSize(data, payloadSizeOffset);
+
+      if (data.length < payloadOffset + payloadSize) {
+        logger.warn({ len: data.length, payloadSize, payloadOffset }, 'ASR response incomplete');
+        return;
+      }
+
+      const payload = data.slice(payloadOffset, payloadOffset + payloadSize);
+      const response = parseJsonPayload(payload);
+
+      if (!response) {
+        logger.warn({ payloadStr: payload.toString('utf-8').slice(0, 200) }, 'Failed to parse ASR JSON');
+        return;
+      }
+
+      const text = response.result?.text;
+      const utterances = response.result?.utterances;
+      const isDefinite = utterances?.some((u) => u.definite);
+
+      logger.info({ text, definite: isDefinite }, 'ASR result');
+
+      // 转发识别文本给浏览器
+      if (text !== undefined && clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(
+          JSON.stringify({
+            type: isDefinite ? 'final' : 'result',
+            text,
+          })
+        );
+      }
+
+      if (isDefinite && clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(JSON.stringify({ type: 'done' }));
+      }
+    } else if (msgType === MSG_TYPE_ERROR_RESPONSE) {
+      const error = parseErrorPayload(data, bodyOffset);
+      logger.error({ error }, 'ASR error response');
+      if (clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(
+          JSON.stringify({
+            type: 'error',
+            message: error?.message || `ASR error code: ${error?.code}`,
+          })
+        );
+      }
+    }
+  });
+
+  // 处理浏览器发来的消息
+  clientWs.on('message', (data: Buffer | ArrayBuffer | string) => {
+    if (isClosing) return;
+
+    // 结束信号
+    if (typeof data === 'string' && data === 'end') {
+      if (volcWs.readyState === WebSocket.OPEN) {
+        volcWs.send(createAudioOnlyRequest(Buffer.alloc(0), true));
+      }
+      return;
+    }
+
+    // 将数据转为 Buffer
+    let audioData: Buffer;
+    if (Buffer.isBuffer(data)) {
+      audioData = data;
+    } else if (data instanceof ArrayBuffer) {
+      audioData = Buffer.from(data);
+    } else {
+      return;
+    }
+
+    if (audioData.length === 0) return;
+
+    // 火山连接就绪则直接转发，否则缓冲
+    if (isVolcReady && volcWs.readyState === WebSocket.OPEN) {
+      volcWs.send(createAudioOnlyRequest(audioData));
+    } else {
+      audioBuffer.push(audioData);
+    }
+  });
+
+  // 浏览器关闭
+  clientWs.on('close', () => {
+    logger.info('ASR client disconnected');
+    isClosing = true;
+    if (volcWs.readyState === WebSocket.OPEN) {
+      volcWs.send(createAudioOnlyRequest(Buffer.alloc(0), true));
+      setTimeout(() => volcWs.close(), 500);
+    } else {
+      volcWs.close();
+    }
+  });
+
+  // 火山引擎关闭
+  volcWs.on('close', () => {
+    logger.info('Volc ASR connection closed');
+    isClosing = true;
+    if (clientWs.readyState === WebSocket.OPEN) {
+      clientWs.close();
+    }
+  });
+
+  // 浏览器端错误
+  clientWs.on('error', (err) => {
+    logger.error({ err }, 'Client WebSocket error');
+    isClosing = true;
+    volcWs.close();
+  });
+
+  // 火山引擎错误
+  volcWs.on('error', (err) => {
+    logger.error({ err }, 'Volc ASR WebSocket error');
+    isClosing = true;
+    if (clientWs.readyState === WebSocket.OPEN) {
+      clientWs.send(
+        JSON.stringify({
+          type: 'error',
+          message: 'ASR service connection error',
+        })
+      );
+      clientWs.close(1011, 'ASR error');
+    }
+  });
+}

package/src/services/asr/volc-protocol.ts

@@ -0,0 +1,220 @@
+/**
+ * 火山引擎 ASR v3 大模型语音识别 WebSocket 二进制协议
+ * 协议文档: https://www.volcengine.com/docs/6561/1354869
+ *
+ * v3 协议要点：
+ * - 4 字节 header
+ * - payloadSize 为 4 字节 uint32 大端
+ * - FullServerResponse 包含 4 字节 sequence 字段
+ * - ErrorResponse 包含 errorCode(4B) + errorMsgSize(4B) + errorMsg
+ * - 鉴权在 HTTP Header 中，不在 payload
+ */
+
+const PROTOCOL_VERSION = 0x01;
+const HEADER_SIZE_VALUE = 0x01; // actual header size = 1 * 4 = 4 bytes
+
+/** 消息类型 */
+export const MSG_TYPE_FULL_CLIENT_REQUEST = 0x01;
+export const MSG_TYPE_AUDIO_ONLY_REQUEST = 0x02;
+export const MSG_TYPE_FULL_SERVER_RESPONSE = 0x09;
+export const MSG_TYPE_ERROR_RESPONSE = 0x0f;
+
+/** 序列化方式 */
+const SERIALIZATION_JSON = 0x01;
+const SERIALIZATION_NONE = 0x00;
+
+/** 压缩方式 */
+const COMPRESSION_NONE = 0x00;
+
+/**
+ * 构建 4 字节协议头
+ *
+ * byte0: version(4bit) | header_size(4bit)
+ * byte1: msg_type(4bit) | flags(4bit)
+ * byte2: serialization(4bit) | compression(4bit)
+ * byte3: reserved
+ */
+function build4ByteHeader(
+  msgType: number,
+  flags: number,
+  serialization: number
+): Buffer {
+  const header = Buffer.alloc(4);
+  header[0] = (PROTOCOL_VERSION << 4) | HEADER_SIZE_VALUE;
+  header[1] = (msgType << 4) | (flags & 0x0f);
+  header[2] = (serialization << 4) | COMPRESSION_NONE;
+  header[3] = 0x00;
+  return header;
+}
+
+/** 构建完整消息：header + payloadSize(4B) + payload */
+function buildMessage(
+  msgType: number,
+  flags: number,
+  serialization: number,
+  payload: Buffer
+): Buffer {
+  const header = build4ByteHeader(msgType, flags, serialization);
+  const payloadSize = Buffer.alloc(4);
+  payloadSize.writeUInt32BE(payload.length, 0);
+  return Buffer.concat([header, payloadSize, payload]);
+}
+
+/** 解析后的协议头信息 */
+export interface ParsedMessage {
+  msgType: number;
+  flags: number;
+  /** header 之后的偏移量（header 4B + 扩展字段） */
+  bodyOffset: number;
+}
+
+/**
+ * 解析 4 字节协议头
+ */
+export function parseHeader(buffer: Buffer): ParsedMessage {
+  const version = buffer[0] >> 4;
+  const headerSizeValue = buffer[0] & 0x0f;
+  const headerSize = headerSizeValue * 4;
+  const msgType = buffer[1] >> 4;
+  const flags = buffer[1] & 0x0f;
+  const serialization = buffer[2] >> 4;
+  const compression = buffer[2] & 0x0f;
+
+  return {
+    msgType,
+    flags,
+    bodyOffset: headerSize,
+  };
+}
+
+/**
+ * 读取 payload size（4 字节 uint32 大端）
+ */
+export function readPayloadSize(buffer: Buffer, offset: number): number {
+  return buffer.readUInt32BE(offset);
+}
+
+/** ASR 配置（鉴权信息在 HTTP Header 中，不在 payload） */
+export interface ASRConfig {
+  appid: string;
+  token: string;
+  secretKey: string;
+  cluster: string;
+  host: string;
+}
+
+/**
+ * 创建 FullClientRequest（初始化请求）
+ *
+ * Payload JSON 格式：
+ * {
+ *   user: { uid: string },
+ *   audio: { format, rate, bits, channel, codec, language },
+ *   request: { model_name, enable_itn, enable_punc, ... }
+ * }
+ */
+export function createFullClientRequest(): Buffer {
+  const payload = Buffer.from(
+    JSON.stringify({
+      user: {
+        uid: '0',
+      },
+      audio: {
+        format: 'pcm',
+        rate: 16000,
+        bits: 16,
+        channel: 1,
+        codec: 'raw',
+        language: 'zh-CN',
+      },
+      request: {
+        model_name: 'bigmodel',
+        enable_itn: true,
+        enable_punc: true,
+        enable_ddc: false,
+      },
+    }),
+    'utf-8'
+  );
+
+  return buildMessage(
+    MSG_TYPE_FULL_CLIENT_REQUEST,
+    0b0000,
+    SERIALIZATION_JSON,
+    payload
+  );
+}
+
+/**
+ * 创建 AudioOnlyRequest（音频数据请求）
+ *
+ * flags:
+ * - 0b0000: 普通音频包
+ * - 0b0010: 最后一包音频（负包）
+ */
+export function createAudioOnlyRequest(
+  audioData: Buffer,
+  isLast: boolean = false
+): Buffer {
+  const flags = isLast ? 0b0010 : 0b0000;
+  return buildMessage(
+    MSG_TYPE_AUDIO_ONLY_REQUEST,
+    flags,
+    SERIALIZATION_NONE,
+    audioData
+  );
+}
+
+/** 火山引擎响应结果 */
+export interface ASRResponse {
+  result?: {
+    text?: string;
+    utterances?: Array<{
+      text: string;
+      definite: boolean;
+      start_time: number;
+      end_time: number;
+    }>;
+    [key: string]: unknown;
+  };
+  audio_info?: {
+    duration: number;
+  };
+  [key: string]: unknown;
+}
+
+/**
+ * 解析 JSON payload
+ */
+export function parseJsonPayload(payloadBuffer: Buffer): ASRResponse | null {
+  try {
+    return JSON.parse(payloadBuffer.toString('utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 解析 ErrorResponse
+ *
+ * 格式：header(4B) + errorCode(4B) + errorMsgSize(4B) + errorMsg
+ */
+export function parseErrorPayload(buffer: Buffer, bodyOffset: number): { code: number; message: string } | null {
+  const errorCodeOffset = bodyOffset;
+  const errorMsgSizeOffset = errorCodeOffset + 4;
+  const errorMsgOffset = errorMsgSizeOffset + 4;
+
+  if (buffer.length < errorMsgOffset) {
+    return null;
+  }
+
+  const code = buffer.readUInt32BE(errorCodeOffset);
+  const msgSize = buffer.readUInt32BE(errorMsgSizeOffset);
+
+  if (buffer.length < errorMsgOffset + msgSize) {
+    return null;
+  }
+
+  const message = buffer.slice(errorMsgOffset, errorMsgOffset + msgSize).toString('utf-8');
+  return { code, message };
+}