@baishuyun/chat-backend 0.0.8 → 0.0.9

package/.env.example

@@ -15,3 +15,6 @@ BUILD_BOT_ID=xxxxx
 
 # fill bot id
 FILL_BOT_ID=xxxxx
+
+# query bot id
+QUERY_BOT_ID=xxxxx

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @baishuyun/chat-backend
 
+## 0.0.9
+
+### Patch Changes
+
+- Updated dependencies
+  - @baishuyun/coze-provider@0.0.9
+  - @baishuyun/types@1.0.9
+
 ## 0.0.8
 
 ### Patch Changes

package/config/default.ts

@@ -1,34 +1,43 @@
-import { asyncConfig } from "config/async.js";
+import { asyncConfig } from 'config/async.js';
 // load async configurations
 const fetchRemoteConfig = async () => {
   return {
     // mock remote config
-    foo: "bar",
+    foo: 'bar',
   };
 };
 
 export default {
   app: {
     port: process.env.PORT || 3001,
-    host: process.env.HOST || "localhost",
+    host: process.env.HOST || 'localhost',
   },
+
   agent: {
-    host: process.env.AGENT_HOST || "47.99.202.157",
+    host: process.env.AGENT_HOST || '47.99.202.157',
 
     apiAuthKey: process.env.COZE_API_KEY,
 
     form: {
       build: {
-        botId: process.env.BUILD_BOT_ID || "7579927677256073216",
+        botId: process.env.BUILD_BOT_ID || '7579927677256073216',
         baseUrl: `http://${process.env.AGENT_HOST}/v3/`,
         apiKey: process.env.BOT_API_KEY, // load from env
       },
 
       fill: {
-        botId: process.env.FILL_BOT_ID || "7586483957357608960",
+        botId: process.env.FILL_BOT_ID || '7586483957357608960',
+        baseUrl: `http://${process.env.AGENT_HOST}/v3/`,
+        apiKey: process.env.BOT_API_KEY, // load from env
+        ocrApiKey: process.env.OCR_API_KEY || '', // load from env
+      },
+    },
+
+    report: {
+      query: {
+        botId: process.env.QUERY_BOT_ID || '7595888372090929152',
         baseUrl: `http://${process.env.AGENT_HOST}/v3/`,
         apiKey: process.env.BOT_API_KEY, // load from env
-        ocrApiKey: process.env.OCR_API_KEY || "", // load from env
       },
     },
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baishuyun/chat-backend",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,8 +22,8 @@
     "parse-sse": "^0.1.0",
     "pino": "^10.1.0",
     "zod": "^4.1.13",
-    "@baishuyun/coze-provider": "0.0.8",
-    "@baishuyun/types": "1.0.8"
+    "@baishuyun/coze-provider": "0.0.9",
+    "@baishuyun/types": "1.0.9"
   },
   "devDependencies": {
     "@types/config": "^3.3.5",
@@ -34,7 +34,7 @@
     "pm2": "^6.0.14",
     "tsx": "^4.7.1",
     "typescript": "^5.8.3",
-    "@baishuyun/typescript-config": "0.0.8"
+    "@baishuyun/typescript-config": "0.0.9"
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development tsx watch src/index.ts",

package/src/app/main.ts

@@ -7,9 +7,11 @@ import app from '../config/hono.config.js';
 
 // 子路由
 import { createFormRouter } from '../routes/form/form.route.js';
+import { createReportRouter } from '../routes/report/report.route.js';
 
 // 挂载子路由
 app.route('web/api/form', createFormRouter());
+app.route('web/api/report', createReportRouter());
 
 // add test route
 app.get('web/api/test', (c) => {

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

@@ -0,0 +1,121 @@
+import { type LanguageModelV2StreamPart } from '@ai-sdk/provider';
+import { JSONParser } from '@streamparser/json';
+import { type IQueryResult } from '@baishuyun/types';
+import {
+  createJsonStreamTransformer,
+  type IParserCtx,
+} from '../../../utils/createJsonStreamTransformer.js';
+import { isArrayElement } from './utils.js';
+
+export const createQueryResultTransformer = (): TransformStream<LanguageModelV2StreamPart, any> => {
+  return createJsonStreamTransformer<IQueryResult>({
+    createJSONParser: createJSONParser,
+    onParseValue: handleParsedValue,
+    onParseError(error) {
+      console.error('JSON parsing error in query transformer:', error);
+      return '数据解析异常，请重试';
+    },
+    onErrorChunk(chunk) {
+      console.log('Unsupported chunk encountered in query transformer:', chunk);
+      return '';
+    },
+  });
+};
+
+function createJSONParser(): JSONParser {
+  return new JSONParser({
+    stringBufferSize: undefined,
+    numberBufferSize: undefined,
+    separator: '', // 使用默认路径分隔符 '.'
+    paths: [
+      '$', // 根对象（可选，如果需要完整对象）
+      '$.title', // 报表名称
+      '$.userID', // 用户ID
+      '$.forms', // 表单ID
+      '$.formIds.*', // 表单ID数组中的每个元素
+      '$.fields.*', // fields数组中的每个对象
+      '$.xFields.*', // xFields数组中的每个对象
+      '$.metrics.*', // metrics数组中的每个对象
+      '$.formulas.*', // 公式字段数组中的每个对象
+      '$.filter.rel', // 过滤条件关系
+      '$.filter.conds.*', // 过滤条件数组中的每个对象
+      '$.limit', // 限制条数
+    ],
+    keepStack: true, // 保持栈信息以便获取父级上下文
+  });
+}
+
+function handleParsedValue(ctx: IParserCtx<IQueryResult>): void {
+  const { parsedInfo, parsedResult, currentChunkId, deltaChunkEnqueuer: enqueueTextDelta } = ctx;
+  const { key, value, stack, parent } = parsedInfo;
+
+  // 快速提取顶层字段
+  // @ts-ignore
+  if (key === 'title') parsedResult.title = value;
+  // @ts-ignore
+  if (key === 'userID') parsedResult.userID = value;
+  // @ts-ignore
+  if (key === 'limit') parsedResult.limit = value;
+  // @ts-ignore
+  if (key === 'forms') parsedResult.formIds = [value];
+
+  // 处理数组类型
+  // @ts-ignore
+  if (key === 'rel' && stack.length >= 1 && stack[stack.length - 1]?.key === 'filter') {
+    if (!parsedResult.filter) parsedResult.filter = { rel: 'and', conds: [] };
+    parsedResult.filter.rel = value as any;
+  }
+
+  if (isArrayElement('fields', parsedInfo)) {
+    if (!parsedResult.fields) {
+      parsedResult.fields = [];
+    }
+    // @ts-ignore
+    parsedResult.fields?.push(value);
+  }
+
+  if (isArrayElement('formulas', parsedInfo)) {
+    if (!parsedResult.formulas) {
+      parsedResult.formulas = [];
+    }
+    // @ts-ignore
+    parsedResult.formulas.push(value);
+  }
+
+  if (isArrayElement('conds', parsedInfo)) {
+    console.log('✅ Parsed filter cond object:', value);
+    if (!parsedResult.filter) {
+      parsedResult.filter = { rel: 'and', conds: [] };
+    }
+    // @ts-ignore
+    parsedResult.filter.conds.push(value);
+  }
+
+  if (isArrayElement('metrics', parsedInfo)) {
+    if (!parsedResult.metrics) {
+      parsedResult.metrics = [];
+    }
+    // @ts-ignore
+    parsedResult.metrics.push(value);
+  }
+
+  if (isArrayElement('xFields', parsedInfo)) {
+    if (!parsedResult.xFields) {
+      parsedResult.xFields = [];
+    }
+    // @ts-ignore
+    parsedResult.xFields.push(value);
+  }
+
+  const validResult = JSON.stringify(parsedResult);
+
+  enqueueTextDelta(
+    `${JSON.stringify(value)},`,
+    {
+      type: 'query-stream-parsed-info',
+      result: validResult,
+    },
+    currentChunkId,
+    true
+  );
+}

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

@@ -0,0 +1,17 @@
+import { createCoze } from '@baishuyun/coze-provider';
+
+import config from 'config';
+import { createQueryResultTransformer } from './createQueryTransformStream.js';
+
+export const createReportQueryModel = () => {
+  const reportQuery = createCoze({
+    apiKey: config.get<string>('agent.report.query.apiKey'),
+    baseURL: config.get<string>('agent.report.query.baseUrl'),
+    botId: config.get<string>('agent.report.query.botId'),
+    extraStreamTransformers: [createQueryResultTransformer],
+  });
+
+  const reportQueryModel = reportQuery.chat('chat');
+
+  return reportQueryModel;
+};

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

@@ -0,0 +1,50 @@
+import { type Context } from 'hono';
+import { convertToModelMessages, streamText, type UIMessage, generateId } from 'ai';
+import { createReportQueryModel } from './model.js';
+import { buildExtraMsgParts } from './utils.js';
+
+export const queryReport = async (c: Context) => {
+  let requestBody;
+
+  try {
+    const json = await c.req.json();
+    requestBody = json;
+  } catch (_) {
+    return c.json({ error: 'Invalid JSON' }, 400);
+  }
+
+  const uid = c.req.header('X-User-Id') || '';
+  const messages: UIMessage[] = requestBody.messages;
+
+  const extraText = buildExtraMsgParts({
+    appId: requestBody.appId,
+    userId: uid,
+    textOnly: true,
+  }) as string;
+
+  const lastUserTextPartOfMessage = messages
+    .slice()
+    .reverse()
+    .find((msg) => msg.role === 'user')
+    ?.parts.findLast((part) => part.type === 'text') as { type: 'text'; text: string } | undefined;
+
+  if (lastUserTextPartOfMessage) {
+    lastUserTextPartOfMessage.text = `${extraText}${lastUserTextPartOfMessage.text}`;
+  }
+
+  const modelMessages = convertToModelMessages(messages);
+  console.log('Final messages for report query:', JSON.stringify(modelMessages, null, 2));
+
+  const stream = streamText({
+    model: createReportQueryModel(),
+    messages: modelMessages,
+    includeRawChunks: true,
+    headers: {
+      'x-user-id': uid,
+    },
+  });
+
+  return stream.toUIMessageStreamResponse({
+    originalMessages: messages, // 建议添加，便于消息 ID 管理
+  });
+};

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

@@ -0,0 +1,54 @@
+import type { LanguageModelV2StreamPart } from '@ai-sdk/provider';
+import type { ParsedElementInfo } from '@streamparser/json/utils/types/parsedElementInfo.js';
+import type { TextUIPart, UIMessagePart } from 'ai';
+
+export const buildExtraMsgParts = ({
+  appId,
+  userId,
+  textOnly,
+}: {
+  appId: string;
+  userId: string;
+  textOnly?: boolean;
+}): Array<TextUIPart> | string => {
+  if (textOnly) {
+    return `appID为${appId}；用户ID为${userId}；`;
+  }
+
+  return [
+    {
+      type: 'text',
+      text: `appID为${appId}；`,
+    },
+    {
+      type: 'text',
+      text: `用户ID为${userId}；`,
+    },
+  ];
+};
+
+export const queryChunkGuard = (chunk: LanguageModelV2StreamPart) => {
+  if (chunk.type !== 'text-delta' || !('delta' in chunk)) {
+    return false;
+  }
+
+  return true;
+};
+
+// JSON Parser 处理数组元素
+// 当解析 $.elementKey.* 时:
+// - key 是数组索引（number）
+// - parent 是数组 []
+// - stack 的最后一个元素的 key 是 elementKey
+export const isArrayElement = (elementKey: string, parsedInfo: ParsedElementInfo): boolean => {
+  const { key, value, stack, parent } = parsedInfo;
+  return (
+    typeof key === 'number' &&
+    Array.isArray(parent) &&
+    stack.length >= 1 &&
+    stack[stack.length - 1]?.key === elementKey &&
+    typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value)
+  );
+};

package/src/routes/report/report.route.ts

@@ -0,0 +1,11 @@
+import { Hono } from 'hono';
+import { queryReport } from '../../controllers/report/query/query.controller.js';
+
+export const createReportRouter = () => {
+  const reportRouter = new Hono();
+
+  // 智能问数
+  reportRouter.post('/query', queryReport);
+
+  return reportRouter;
+};

package/src/utils/createJsonStreamTransformer.ts

@@ -0,0 +1,240 @@
+import { type LanguageModelV2StreamPart } from '@ai-sdk/provider';
+import { createTextInfoEnqueuer } from '@baishuyun/coze-provider';
+import { JSONParser } from '@streamparser/json';
+import type { ParsedElementInfo } from '@streamparser/json/utils/types/parsedElementInfo.js';
+import { logger } from '../logger/index.js';
+
+/** onParseValue 回调接收的上下文 */
+export interface IParserCtx<T> {
+  /** 累积的解析结果，可直接修改 */
+  parsedResult: T;
+  /** 当前触发 onValue 的解析信息 */
+  parsedInfo: ParsedElementInfo;
+  /** 向下游推送 text-delta chunk 的工具函数 */
+  deltaChunkEnqueuer: ReturnType<typeof createTextInfoEnqueuer>;
+  /** 当前正在处理的 chunk id */
+  currentChunkId: string;
+}
+
+/** 创建 JSON 流转换器的选项 */
+export interface JsonStreamTransformerOptions<T> {
+  /** 创建 JSONParser 实例（由使用者决定路径、分隔符等解析细节） */
+  createJSONParser: () => JSONParser;
+  /** 每次解析出值时的回调 */
+  onParseValue: (ctx: IParserCtx<T>) => void;
+  /** chunk 过滤，返回 true 表示需要解析，默认检查 text-delta 类型 */
+  chunkGuard?: (chunk: LanguageModelV2StreamPart) => boolean;
+  /** 收到 error 类型 chunk 时的回调（可选） */
+  onErrorChunk?: (chunk: LanguageModelV2StreamPart) => void;
+  /** JSON 解析出错时的回调，返回要展示的错误消息（可选） */
+  onParseError?: (error: any) => string;
+}
+
+/**
+ * 创建一个 TransformStream，将 AI 流式响应中的 JSON 片段解析为结构化数据。
+ *
+ * 使用者只需关心：
+ * 1. `createJSONParser` — 决定 JSON 解析的路径 / 选项
+ * 2. `onParseValue`     — 处理每个解析出的值
+ * 3. 错误处理（均可选）
+ */
+export const createJsonStreamTransformer = <T>(
+  options: JsonStreamTransformerOptions<T>
+): TransformStream<LanguageModelV2StreamPart, any> => {
+  const processor = new JsonStreamProcessor<T>(options);
+  return new TransformStream<LanguageModelV2StreamPart, any>({
+    start: (ctrl) => processor.start(ctrl),
+    transform: (chunk, ctrl) => processor.transform(chunk, ctrl),
+    flush: (ctrl) => processor.flush(ctrl),
+  });
+};
+
+const BACKTICK_RE = /`?`?`?/g;
+const JSON_PREFIX = 'json';
+
+const ERROR_MESSAGES = {
+  PARSE_ERROR: '解析异常，请刷新重试',
+  TIMEOUT: '操作超时，请刷新重试',
+  GENERAL_ERROR: '发生错误，请刷新重试',
+} as const;
+
+type Controller = TransformStreamDefaultController<any>;
+type ChunkWithIdDelta = Extract<LanguageModelV2StreamPart, { id: string; delta: string }>;
+
+class JsonStreamProcessor<T> {
+  // -- 配置 --
+  private readonly options: JsonStreamTransformerOptions<T>;
+
+  // -- 运行时状态 --
+  private parser: JSONParser | null = null;
+  private result: T = {} as T;
+  private currentChunkId = '';
+  private parseCompleted: Promise<void> | null = null;
+  private resolveParseCompleted: (() => void) | null = null;
+  private terminated = false;
+
+  constructor(options: JsonStreamTransformerOptions<T>) {
+    this.options = options;
+  }
+
+  // ===================== 生命周期 =====================
+
+  /** TransformStream start：创建 parser、绑定回调 */
+  start(controller: Controller): void {
+    this.parser = this.options.createJSONParser();
+    this.parseCompleted = this.createCompletionPromise();
+    this.bindParserCallbacks(controller);
+  }
+
+  /** TransformStream transform：逐 chunk 处理 */
+  transform(chunk: LanguageModelV2StreamPart, controller: Controller): void {
+    if (this.terminated || !this.parser) {
+      logger.warn('JSON parser not initialized or stream already terminated');
+      return;
+    }
+
+    try {
+      // 1) error chunk → 通知下游后终止
+      if (chunk.type === 'error') {
+        this.options.onErrorChunk?.(chunk);
+        this.enqueueError(controller, ERROR_MESSAGES.GENERAL_ERROR);
+        return;
+      }
+
+      // 2) 不需要解析的 chunk → 透传
+      const guard = this.options.chunkGuard ?? defaultChunkGuard;
+      if (!guard(chunk)) {
+        controller.enqueue(chunk);
+        return;
+      }
+
+      // 3) 提取 delta 写入 parser
+      if (isChunkWithDelta(chunk)) {
+        this.currentChunkId = chunk.id;
+        this.parser.write(stripCodeFence(chunk.delta));
+      }
+    } catch (error) {
+      this.enqueueError(controller, error);
+    }
+  }
+
+  /** TransformStream flush：结束 parser 并等待所有回调完成 */
+  async flush(controller: Controller): Promise<void> {
+    try {
+      if (this.parser) {
+        this.parser.end();
+        if (this.parseCompleted) await this.parseCompleted;
+        logger.debug('Parser stopped gracefully');
+      }
+      if (!this.terminated) controller.terminate();
+    } catch (error) {
+      controller.error(`Cleanup error: ${error}`);
+    }
+  }
+
+  // ===================== Parser 回调 =====================
+
+  private bindParserCallbacks(controller: Controller): void {
+    if (!this.parser) return;
+
+    const enqueue = createTextInfoEnqueuer(controller);
+
+    this.parser.onValue = (parsedInfo: ParsedElementInfo) => {
+      logger.debug('enter onValue');
+
+      // 超时错误特殊处理
+      if (isTimeoutError(parsedInfo.value)) {
+        if (!this.terminated) {
+          enqueue(JSON.stringify(parsedInfo.value), {
+            type: 'agent-error',
+            error: ERROR_MESSAGES.TIMEOUT,
+          });
+          this.terminateStream(controller);
+        }
+        return;
+      }
+
+      this.options.onParseValue({
+        parsedResult: this.result,
+        parsedInfo,
+        deltaChunkEnqueuer: enqueue,
+        currentChunkId: this.currentChunkId,
+      });
+    };
+
+    this.parser.onError = (err: any) => {
+      logger.debug('enter onError: ' + err);
+      if (!this.terminated) {
+        const msg = this.options.onParseError
+          ? this.options.onParseError(err)
+          : ERROR_MESSAGES.GENERAL_ERROR;
+        logger.debug(msg);
+        enqueue('error', { type: 'agent-error', error: msg });
+        this.terminateStream(controller);
+      }
+    };
+
+    this.parser.onEnd = () => {
+      logger.debug('Parsing completed');
+      enqueue(' ', JSON.stringify({ appendConfirm: 'save-fields' }));
+      this.completeParsing();
+    };
+  }
+
+  /** 创建可外部 resolve 的 Promise，用于 flush 等待 parser 回调结束 */
+  private createCompletionPromise(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      this.resolveParseCompleted = () => {
+        resolve();
+        logger.debug('Parsing completion promise resolved');
+      };
+    });
+  }
+
+  /** 标记解析完成，重置状态 */
+  private completeParsing(): void {
+    this.resolveParseCompleted?.();
+    this.parser = null;
+    this.result = {} as T;
+    this.currentChunkId = '';
+    this.parseCompleted = null;
+    this.resolveParseCompleted = null;
+  }
+
+  /** 安全地终止流并清理状态 */
+  private terminateStream(controller: Controller): void {
+    this.completeParsing();
+    this.terminated = true;
+    controller.terminate();
+  }
+
+  /** 向下游推送 agent-error 并终止流 */
+  private enqueueError(controller: Controller, error: unknown): void {
+    if (this.terminated) return;
+    const enqueue = createTextInfoEnqueuer(controller);
+    const msg = typeof error === 'string' ? error : ERROR_MESSAGES.PARSE_ERROR;
+    logger.error('JsonStreamProcessor error: ' + error);
+    // 先 enqueue 错误信息让下游能收到，再 terminate
+    // 注意：不能调 controller.error()，否则流进入 errored 状态，enqueue 不再生效
+    enqueue('error', { type: 'agent-error', error: msg });
+    this.terminateStream(controller);
+  }
+}
+
+/** 默认 chunkGuard：只处理带 delta 的 text-delta chunk */
+function defaultChunkGuard(chunk: LanguageModelV2StreamPart): boolean {
+  return chunk.type === 'text-delta' && 'delta' in chunk;
+}
+
+function isChunkWithDelta(chunk: LanguageModelV2StreamPart): chunk is ChunkWithIdDelta {
+  return 'id' in chunk && 'delta' in chunk;
+}
+
+/** 去掉 AI 返回的代码围栏标记 (```) 和 json 前缀 */
+function stripCodeFence(delta: string): string {
+  return delta.replace(BACKTICK_RE, '').replace(JSON_PREFIX, '');
+}
+
+function isTimeoutError(value: any): boolean {
+  return value?.error === true && value?.errorMessage === 'timeout';
+}