@baishuyun/chat-backend 0.0.14 → 0.0.16

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @baishuyun/chat-backend
 
+## 0.0.16
+
+### Patch Changes
+
+- Updated dependencies
+  - @baishuyun/coze-provider@0.0.16
+  - @baishuyun/types@1.0.16
+
+## 0.0.15
+
+### Patch Changes
+
+- Updated dependencies
+  - @baishuyun/coze-provider@0.0.15
+  - @baishuyun/types@1.0.15
+
 ## 0.0.14
 
 ### Patch Changes

package/dist/config/default.js

@@ -1,30 +1,37 @@
-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/dist/src/app/main.js

@@ -5,9 +5,16 @@
 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());
-// add test route
-app.get('web/api/test', (c) => {
-    return c.json({ message: 'Test route is working!' });
+app.route('web/api/report', createReportRouter());
+// 基础健康检查
+app.get('/web/api/health', (c) => {
+    return c.json({
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime(),
+        service: 'hono-app',
+    });
 });

package/dist/src/config/hono.config.js

@@ -12,6 +12,18 @@ const app = new Hono();
 app.use('web/api/*', cors());
 // Logging middleware
 app.use(logMiddleware);
+// SSE keep-alive middleware - adds headers to prevent proxy timeouts during streaming
+app.use('web/api/*', async (c, next) => {
+    await next();
+    // Add keep-alive headers to streaming responses (SSE/text-streaming)
+    const contentType = c.res.headers.get('content-type');
+    if (contentType?.includes('text/plain') || contentType?.includes('text/event-stream')) {
+        c.header('Connection', 'keep-alive');
+        c.header('Keep-Alive', 'timeout=300'); // 5 minutes
+        c.header('X-Accel-Buffering', 'no'); // Disable nginx buffering
+        c.header('Cache-Control', 'no-cache, no-transform');
+    }
+});
 // 全局错误处理中间件（捕获所有路由/中间件异常）
 app.onError((err, c) => {
     // 记录错误日志（error 级别，包含异常堆栈）

package/dist/src/controllers/form/build/build.controller.js

@@ -17,12 +17,25 @@ export const buildForm = async (c) => {
         return c.json({ error: "Invalid JSON" }, 400);
     }
     const isBuildStage = requestBody.stage === "build";
+    const formName = requestBody.name || "未命名表单";
+    const allMessages = [...requestBody.messages];
+    if (isBuildStage) {
+        allMessages.push({
+            role: "user",
+            parts: [
+                {
+                    type: "text",
+                    text: `确认搭建：${formName}`,
+                },
+            ],
+        });
+    }
     const stream = streamText({
         model: createModel([
             () => createFieldsJsonTransformStream(isBuildStage),
             () => new SuggestionTransformStream(isBuildStage),
         ]),
-        messages: convertToModelMessages(requestBody.messages),
+        messages: convertToModelMessages(allMessages),
         includeRawChunks: true,
         headers: {
             "x-user-stage": requestBody.stage,
@@ -30,5 +43,17 @@ export const buildForm = async (c) => {
             "x-user-token": c.req.header("authorization") || "",
         },
     });
-    return stream.toUIMessageStreamResponse();
+    const response = stream.toUIMessageStreamResponse();
+    // Add SSE keep-alive headers to prevent proxy timeouts during streaming
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: {
+            ...Object.fromEntries(response.headers),
+            'Connection': 'keep-alive',
+            'Keep-Alive': 'timeout=300',
+            'X-Accel-Buffering': 'no',
+            'Cache-Control': 'no-cache, no-transform',
+        },
+    });
 };

package/dist/src/controllers/form/fill/createBatchFillingTransformStream.js

@@ -41,6 +41,15 @@ export const createBatchFillingResultTransformer = (enableJsonParser) => {
                 }
                 else {
                     // logger.debug(`bypass chunk in batch filling transformer: ${JSON.stringify(chunk)}`);
+                    if (chunk.type === 'error') {
+                        enqueueTextDelta('error', {
+                            type: 'agent-error',
+                            error: '操作超时，请刷新重试',
+                        });
+                        resolveParseCompleted?.();
+                        controller.terminate(); // 信号通知下游可读流已关闭
+                        return;
+                    }
                     controller.enqueue(chunk);
                 }
             }

package/dist/src/controllers/form/fill/createFieldsFillingResultTransformStream.js

@@ -40,18 +40,28 @@ export const createFieldsFillingResultTransformer = (enableJsonParser) => {
                     }
                 }
                 else {
+                    if (chunk.type === 'error') {
+                        enqueueTextDelta('error', {
+                            type: 'agent-error',
+                            error: '操作超时，请刷新重试',
+                        });
+                        resolveParseCompleted?.();
+                        controller.terminate(); // 信号通知下游可读流已关闭
+                        return;
+                    }
                     controller.enqueue(chunk);
                 }
             }
             catch (e) {
                 logger.debug('exception in transform while processing filling chunk');
-                controller.error(e);
+                // Enqueue error message before closing to allow client to receive it
                 enqueueTextDelta('error', {
                     type: 'agent-error',
                     error: '解析异常，请刷新重试',
                 });
                 resolveParseCompleted?.();
-                controller.terminate(); // 信号通知下游可读流已关闭
+                // Graceful close after error notification
+                controller.terminate();
             }
         },
         start: (controller) => {
@@ -97,12 +107,14 @@ export const createFieldsFillingResultTransformer = (enableJsonParser) => {
                     console.error('JsonWidgetStream: JSON Parsing Error:', err);
                     errorLogged = true;
                 }
+                // Enqueue error message before closing to allow client to receive it
                 enqueueTextDelta('error', {
                     type: 'agent-error',
                     error: '操作超时，请刷新重试',
                 });
                 resolveParseCompleted?.();
-                controller.terminate(); // 信号通知下游可读流已关闭
+                // Graceful close after error notification
+                controller.terminate();
             };
             parser.onEnd = () => {
                 enqueueTextDelta(' ', JSON.stringify({

package/dist/src/controllers/form/fill/fill.controller.js

@@ -2,7 +2,7 @@ import {} from 'hono';
 import { convertToModelMessages, streamText, generateId } from 'ai';
 import { logger } from '../../../logger/index.js';
 import { createFillingModel } from './model.js';
-import { mode2part } from './utils.js';
+import { mode2part, trimFormStructure } from './utils.js';
 import { batchFillForm } from './batch-fill.controller.js';
 /**
  * 表单填写
@@ -18,7 +18,7 @@ export const fillForm = async (c) => {
     catch (_) {
         return c.json({ error: 'Invalid JSON' }, 400);
     }
-    const formStructure = requestBody.formStructure;
+    const formStructure = trimFormStructure(requestBody.formStructure || []);
     const mode = requestBody.mode;
     const num = requestBody.count;
     const messages = requestBody.messages;
@@ -26,13 +26,16 @@ export const fillForm = async (c) => {
     if (mode === 'batch') {
         return batchFillForm(c);
     }
+    const flattenParts = messages.flatMap((msg) => msg.parts);
+    const msg = [];
     if (formStructure) {
         const extraPart = mode2part(mode, num);
         try {
-            messages.push({
+            msg.push({
                 id: generateId(),
                 role: 'user',
                 parts: [
+                    ...flattenParts,
                     {
                         type: 'text',
                         text: `formStructure: ${JSON.stringify(formStructure)}`,
@@ -45,9 +48,10 @@ export const fillForm = async (c) => {
             logger.error('Failed to append form structure');
         }
     }
+    const modelMessages = convertToModelMessages(msg);
     const stream = streamText({
         model: createFillingModel(),
-        messages: convertToModelMessages(messages),
+        messages: modelMessages,
         includeRawChunks: true,
         headers: {
             'x-user-stage': requestBody.stage,
@@ -57,7 +61,19 @@ export const fillForm = async (c) => {
             'x-user-token': c.req.header('authorization') || '',
         },
     });
-    return stream.toUIMessageStreamResponse({
+    const response = stream.toUIMessageStreamResponse({
         originalMessages: messages, // 建议添加，便于消息 ID 管理
     });
+    // Add SSE keep-alive headers to prevent proxy timeouts during streaming
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: {
+            ...Object.fromEntries(response.headers),
+            'Connection': 'keep-alive',
+            'Keep-Alive': 'timeout=300',
+            'X-Accel-Buffering': 'no',
+            'Cache-Control': 'no-cache, no-transform',
+        },
+    });
 };

package/dist/src/controllers/form/fill/utils.js

@@ -81,3 +81,32 @@ export const fillingChunkGuard = (chunk, enableGuard = true) => {
     }
     return true;
 };
+/**
+ * 裁剪表单结构，子表单只展开一层
+ */
+export function trimFormStructure(fields) {
+    return fields.map((field) => {
+        const trimmed = {
+            description: field.description,
+            label: field.label,
+            widget: {
+                type: field.widget.type,
+                widgetName: field.widget.widgetName,
+            },
+        };
+        if (field.widget.items && Array.isArray(field.widget.items)) {
+            // 过滤掉无效 item（null/undefined 或缺少 widget）
+            trimmed.widget.items = field.widget.items
+                .filter((item) => item != null && item.widget != null)
+                .map((item) => ({
+                description: item.description,
+                label: item.label,
+                widget: {
+                    type: item.widget.type,
+                    widgetName: item.widget.widgetName,
+                },
+            }));
+        }
+        return trimmed;
+    });
+}

package/dist/src/controllers/report/query/createQuerySuggestionTransStream.js

@@ -0,0 +1,34 @@
+import {} from '@ai-sdk/provider';
+import { JSONParser } from '@streamparser/json';
+import {} from '@baishuyun/types';
+import { createJsonStreamTransformer, } from '../../../utils/createJsonStreamTransformer.js';
+import { logger } from '../../../logger/index.js';
+export const createQuerySuggestionTransformer = () => {
+    return createJsonStreamTransformer({
+        createJSONParser: createJSONParser,
+        onParseValue: handleParsedValue,
+        onParseError(error) {
+            logger.error('JSON parsing error in query transformer: ', error);
+            return '数据解析异常，请重试';
+        },
+        onErrorChunk(chunk) {
+            logger.error('Received error chunk in query transformer');
+            return '';
+        },
+    });
+};
+function createJSONParser() {
+    return new JSONParser({
+        stringBufferSize: undefined,
+        numberBufferSize: undefined,
+        separator: '',
+        paths: ['$.*'],
+        keepStack: true,
+    });
+}
+function handleParsedValue(ctx) {
+    const { parsedInfo, getResult, currentChunkId, deltaChunkEnqueuer: enqueueTextDelta, ctrl } = ctx;
+    const { value } = parsedInfo;
+    logger.debug('Parsed JSON value: ' + JSON.stringify(value));
+    enqueueTextDelta(`${JSON.stringify(value)},`, { type: 'query-suggestion-parsed-info', result: JSON.stringify(getResult()) }, currentChunkId + 2, true);
+}

package/dist/src/controllers/report/query/createQueryTransformStream.js

@@ -0,0 +1,87 @@
+import {} from '@ai-sdk/provider';
+import { JSONParser } from '@streamparser/json';
+import {} from '@baishuyun/types';
+import { createJsonStreamTransformer, } from '../../../utils/createJsonStreamTransformer.js';
+import { isTargetElement } from './utils.js';
+import { logger } from '../../../logger/index.js';
+import { fieldHandlers } from './handler-registry.js';
+export const createQueryResultTransformer = () => {
+    return createJsonStreamTransformer({
+        createJSONParser: createJSONParser,
+        onParseValue: handleParsedValue,
+        onParseError(error) {
+            logger.error('JSON parsing error in query transformer: ', error);
+            return '数据解析异常，请重试';
+        },
+        onErrorChunk(chunk) {
+            logger.error('Received error chunk in query transformer');
+            return '';
+        },
+    });
+};
+function createJSONParser() {
+    return new JSONParser({
+        stringBufferSize: undefined,
+        numberBufferSize: undefined,
+        separator: '',
+        paths: [
+            '$', // 保留完整结果推送
+            '$.title',
+            '$.source',
+            '$.name',
+            '$.type',
+            '$.userID',
+            '$.forms',
+            '$.fields.*',
+            '$.xFields.*',
+            '$.yFields.*',
+            '$.metrics.*',
+            '$.formulas.*',
+            '$.filter.rel',
+            '$.filter.cond.*',
+            '$.limit',
+        ],
+        keepStack: true,
+    });
+}
+function handleParsedValue(ctx) {
+    const { parsedInfo, getResult, currentChunkId, deltaChunkEnqueuer: enqueueTextDelta, ctrl } = ctx;
+    const { value } = parsedInfo;
+    logger.debug('Parsed JSON value: ' + JSON.stringify(value));
+    // Phase 0: 报表标题 —— 初始化结果并发送 text-start, 必须为起始字段
+    if (isTargetElement('$.title', parsedInfo)) {
+        handleTitle(ctx);
+    }
+    // Phase 4: 按注册的 handler 分发字段处理
+    for (const { path, handler } of fieldHandlers) {
+        if (isTargetElement(path, parsedInfo)) {
+            handler(ctx, value);
+            break;
+        }
+    }
+    // Phase 5: 向下游推送增量结果
+    enqueueTextDelta(`${JSON.stringify(value)},`, { type: 'query-stream-parsed-info', result: JSON.stringify(getResult()) }, currentChunkId + 2, true);
+}
+// ===================== Phase Handlers =====================
+function handleAggregateName(ctx) {
+    const { parsedInfo, getResult, currentChunkId, deltaChunkEnqueuer: enqueueTextDelta } = ctx;
+    const value = parsedInfo.value;
+    ctx.setPartialResult({
+        title: value,
+        source: 'aggregate',
+        type: 'data_table',
+    });
+    logger.debug('Parsed aggregate table title: ' + value);
+    enqueueTextDelta(`${JSON.stringify(value)},`, { type: 'query-stream-parsed-info', result: JSON.stringify(getResult()) }, currentChunkId + 1, false);
+}
+function handleTitle(ctx) {
+    const { parsedInfo, currentChunkId, ctrl } = ctx;
+    ctx.clearResult();
+    ctrl.enqueue({
+        type: 'text-start',
+        id: currentChunkId + 2,
+    });
+    ctx.setPartialResult({
+        title: parsedInfo.value,
+    });
+}

package/dist/src/controllers/report/query/handler-helpers.js

@@ -0,0 +1,31 @@
+import {} from '@baishuyun/types';
+import {} from '../../../utils/createJsonStreamTransformer.js';
+// ===================== Handler Helpers =====================
+/** 创建一个将值推入指定数组字段的 handler */
+export function pushToArray(field) {
+    return (ctx, value) => {
+        const result = ctx.getResult();
+        if (!result[field]) {
+            ctx.setPartialResult({ [field]: [] });
+        }
+        ctx.getResult()[field].push(value);
+    };
+}
+/** 创建一个将值推入数组字段、并附加 tag/form 元信息的 handler */
+export function pushToArrayWithMeta(field) {
+    return (ctx, value) => {
+        const result = ctx.getResult();
+        if (!result[field]) {
+            ctx.setPartialResult({ [field]: [] });
+        }
+        value.tag = `f_${Date.now()}`;
+        value.form = result.formIds ? result.formIds[0] : '';
+        ctx.getResult()[field].push(value);
+    };
+}
+/** 确保 filter 对象已初始化 */
+export function ensureFilter(ctx) {
+    if (!ctx.getResult().filter) {
+        ctx.setPartialResult({ filter: { rel: 'and', conds: [] } });
+    }
+}

package/dist/src/controllers/report/query/handler-registry.js

@@ -0,0 +1,48 @@
+import {} from '@baishuyun/types';
+import { ensureFilter, pushToArray, pushToArrayWithMeta } from './handler-helpers.js';
+export const fieldHandlers = [
+    {
+        path: '$.source',
+        handler: (ctx, value) => ctx.setPartialResult({ source: value }),
+    },
+    {
+        path: '$.userID',
+        handler: (ctx, value) => ctx.setPartialResult({ userID: value }),
+    },
+    {
+        path: '$.limit',
+        handler: (ctx, value) => ctx.setPartialResult({ limit: value }),
+    },
+    {
+        path: '$.forms',
+        handler: (ctx, value) => ctx.setPartialResult({ formIds: [value] }),
+    },
+    {
+        path: '$.type',
+        handler: (ctx, value) => ctx.setPartialResult({ type: value }),
+    },
+    {
+        path: '$.filter.rel',
+        handler: (ctx, value) => {
+            ensureFilter(ctx);
+            ctx.setPartialResult({
+                filter: { ...ctx.getResult().filter, rel: value },
+            });
+        },
+    },
+    {
+        path: '$.filter.cond.*',
+        handler: (ctx, value) => {
+            ensureFilter(ctx);
+            const filter = ctx.getResult().filter;
+            ctx.setPartialResult({
+                filter: { ...filter, conds: [...(filter.conds || []), value] },
+            });
+        },
+    },
+    { path: '$.fields.*', handler: pushToArray('fields') },
+    { path: '$.formulas.*', handler: pushToArray('formulas') },
+    { path: '$.metrics.*', handler: pushToArrayWithMeta('metrics') },
+    { path: '$.xFields.*', handler: pushToArrayWithMeta('xFields') },
+    { path: '$.yFields.*', handler: pushToArrayWithMeta('yFields') },
+];

package/dist/src/controllers/report/query/model.js

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

package/dist/src/controllers/report/query/query.controller.js

@@ -0,0 +1,54 @@
+import {} from 'hono';
+import { convertToModelMessages, streamText, generateId } from 'ai';
+import { createReportQueryModel } from './model.js';
+import { buildExtraMsgParts } from './utils.js';
+export const queryReport = async (c) => {
+    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 = requestBody.messages;
+    const extraText = buildExtraMsgParts({
+        appId: requestBody.appId,
+        userId: uid,
+        textOnly: true,
+    });
+    const lastUserTextPartOfMessage = messages
+        .slice()
+        .reverse()
+        .find((msg) => msg.role === 'user')
+        ?.parts.findLast((part) => part.type === 'text');
+    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': Date.now().toString(), // uid,
+        },
+    });
+    const response = stream.toUIMessageStreamResponse({
+        originalMessages: messages, // 建议添加，便于消息 ID 管理
+    });
+    // Add SSE keep-alive headers to prevent proxy timeouts during streaming
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: {
+            ...Object.fromEntries(response.headers),
+            'Connection': 'keep-alive',
+            'Keep-Alive': 'timeout=300',
+            'X-Accel-Buffering': 'no',
+            'Cache-Control': 'no-cache, no-transform',
+        },
+    });
+};

package/dist/src/controllers/report/query/suggest.controller.js

@@ -0,0 +1,39 @@
+import {} from 'hono';
+import { convertToModelMessages, streamText, generateId } from 'ai';
+import { createReportQueryModel } from './model.js';
+export const queryReportSuggest = async (c) => {
+    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 = requestBody.messages;
+    const forms = requestBody.forms || [];
+    const modelMessages = convertToModelMessages([
+        {
+            role: 'user',
+            parts: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(forms),
+                },
+            ],
+        },
+    ]);
+    console.log('Final messages for query suggestion: ', 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/dist/src/controllers/report/query/types.js

@@ -0,0 +1,2 @@
+import {} from '@baishuyun/types';
+import {} from '../../../utils/createJsonStreamTransformer.js';

package/dist/src/controllers/report/query/utils.js

@@ -0,0 +1,63 @@
+export const buildExtraMsgParts = ({ appId, userId, textOnly, }) => {
+    if (textOnly) {
+        return `appID为${appId}；用户ID为${userId}；`;
+    }
+    return [
+        {
+            type: 'text',
+            text: `appID为${appId}；`,
+        },
+        {
+            type: 'text',
+            text: `用户ID为${userId}；`,
+        },
+    ];
+};
+export const queryChunkGuard = (chunk) => {
+    if (chunk.type !== 'text-delta' || !('delta' in chunk)) {
+        return false;
+    }
+    return true;
+};
+/**
+ * 通用路径匹配器：判断当前解析到的元素是否命中指定的 JSONParser 路径。
+ *
+ * 支持两种路径形式：
+ * - 精确路径：`$.title`、`$.filter.rel` — 匹配特定 key
+ * - 通配路径：`$.fields.*`、`$.filter.cond.*` — 匹配数组元素
+ *
+ * path 格式与 `JSONParser` 的 `paths` 配置完全一致，无需额外转换。
+ *
+ * @example
+ * isTargetElement('$.title', parsedInfo)
+ * isTargetElement('$.filter.rel', parsedInfo)
+ * isTargetElement('$.fields.*', parsedInfo)
+ * isTargetElement('$.filter.cond.*', parsedInfo)
+ */
+export const isTargetElement = (path, parsedInfo) => {
+    const { key, stack, parent } = parsedInfo;
+    // 去掉 '$.' 前缀，按 '.' 分割
+    const segments = path.replace(/^\$\./, '').split('.');
+    const endsWithWildcard = segments[segments.length - 1] === '*';
+    if (endsWithWildcard) {
+        // ---- 通配路径：匹配数组中的元素 ----
+        const parentKeys = segments.slice(0, -1);
+        // 当前 key 必须为数组索引，parent 必须为数组
+        if (typeof key !== 'number' || !Array.isArray(parent))
+            return false;
+        // stack 深度 = root(1) + parentKeys
+        if (stack.length !== parentKeys.length + 1)
+            return false;
+        // 从 stack[1] 开始逐段匹配（跳过 root）
+        return parentKeys.every((seg, i) => stack[i + 1]?.key === seg);
+    }
+    // ---- 精确路径：匹配特定 key ----
+    const leafKey = segments[segments.length - 1];
+    if (key !== leafKey)
+        return false;
+    const parentKeys = segments.slice(0, -1);
+    // stack 深度 = root(1) + parentKeys（叶子节点自身不在 stack 中）
+    if (stack.length !== parentKeys.length + 1)
+        return false;
+    return parentKeys.every((seg, i) => stack[i + 1]?.key === seg);
+};

package/dist/src/routes/report/report.route.js

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

package/dist/src/utils/createJsonStreamTransformer.js

@@ -0,0 +1,198 @@
+import {} from '@ai-sdk/provider';
+import { createTextInfoEnqueuer } from '@baishuyun/coze-provider';
+import { JSONParser } from '@streamparser/json';
+import { logger } from '../logger/index.js';
+/**
+ * 创建一个 TransformStream，将 AI 流式响应中的 JSON 片段解析为结构化数据。
+ *
+ * 使用者只需关心：
+ * 1. `createJSONParser` — 决定 JSON 解析的路径 / 选项
+ * 2. `onParseValue`     — 处理每个解析出的值
+ * 3. 错误处理（均可选）
+ */
+export const createJsonStreamTransformer = (options) => {
+    const processor = new JsonStreamProcessor(options);
+    return new TransformStream({
+        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: '发生错误，请刷新重试',
+};
+class JsonStreamProcessor {
+    // -- 配置 --
+    options;
+    // -- 运行时状态 --
+    parser = null;
+    result = {};
+    currentChunkId = '';
+    parseCompleted = null;
+    resolveParseCompleted = null;
+    terminated = false;
+    constructor(options) {
+        this.options = options;
+    }
+    // ===================== 生命周期 =====================
+    /** TransformStream start：创建 parser、绑定回调 */
+    start(controller) {
+        this.parser = this.options.createJSONParser();
+        this.parseCompleted = this.createCompletionPromise();
+        this.bindParserCallbacks(controller);
+    }
+    /** TransformStream transform：逐 chunk 处理 */
+    transform(chunk, controller) {
+        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) {
+        try {
+            if (this.parser) {
+                this.parser.end();
+                if (this.parseCompleted)
+                    await this.parseCompleted;
+                logger.debug('Parser stopped gracefully');
+            }
+            // Graceful close: don't call terminate() which abruptly closes the stream
+            // The stream will close naturally when all chunks are processed
+        }
+        catch (error) {
+            controller.error(`Cleanup error: ${error}`);
+        }
+    }
+    // ===================== Parser 回调 =====================
+    bindParserCallbacks(controller) {
+        if (!this.parser)
+            return;
+        const enqueue = createTextInfoEnqueuer(controller);
+        this.parser.onValue = (parsedInfo) => {
+            // 超时错误特殊处理
+            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({
+                parsedInfo,
+                deltaChunkEnqueuer: enqueue,
+                currentChunkId: this.currentChunkId,
+                ctrl: controller,
+                getResult: () => this.result,
+                clearResult: this.clearResult.bind(this),
+                setPartialResult: (partial) => {
+                    this.result = { ...this.result, ...partial };
+                },
+            });
+        };
+        this.parser.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 回调结束 */
+    createCompletionPromise() {
+        return new Promise((resolve) => {
+            this.resolveParseCompleted = () => {
+                resolve();
+                logger.debug('Parsing completion promise resolved');
+            };
+        });
+    }
+    clearResult() {
+        this.result = {};
+    }
+    /** 标记解析完成，重置状态 */
+    completeParsing() {
+        this.resolveParseCompleted?.();
+        this.parser = null;
+        this.result = {};
+        this.currentChunkId = '';
+        this.parseCompleted = null;
+        this.resolveParseCompleted = null;
+    }
+    /** 安全地终止流并清理状态 */
+    terminateStream(controller) {
+        this.completeParsing();
+        this.terminated = true;
+        // Use error() instead of terminate() to signal an error condition
+        // This allows the stream to be properly handled by upstream consumers
+        try {
+            controller.error(new Error('Stream terminated due to error'));
+        }
+        catch (e) {
+            // Controller may already be closed, ignore
+        }
+    }
+    /** 向下游推送 agent-error 并终止流 */
+    enqueueError(controller, error) {
+        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) {
+    return chunk.type === 'text-delta' && 'delta' in chunk;
+}
+function isChunkWithDelta(chunk) {
+    return 'id' in chunk && 'delta' in chunk;
+}
+/** 去掉 AI 返回的代码围栏标记 (```) 和 json 前缀 */
+function stripCodeFence(delta) {
+    return delta.replace(BACKTICK_RE, '').replace(JSON_PREFIX, '');
+}
+function isTimeoutError(value) {
+    return value?.error === true && value?.errorMessage === 'timeout';
+}

package/ecosystem.config.cjs

@@ -8,8 +8,8 @@ module.exports = {
       watch: false, // 生产环境关闭文件监听（避免容器内文件变动触发重启）
       max_memory_restart: '2G', // 内存超过 1G 自动重启（防止内存泄漏）
 
-      listen_timeout: 10000,
-      kill_timeout: 5000,
+      listen_timeout: 120000,  // 2 minutes for long streaming operations
+      kill_timeout: 30000,     // 30 seconds for graceful shutdown
 
       env: {
         // 开发环境变量

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baishuyun/chat-backend",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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.14",
-    "@baishuyun/types": "1.0.14"
+    "@baishuyun/coze-provider": "0.0.16",
+    "@baishuyun/types": "1.0.16"
   },
   "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.14"
+    "@baishuyun/typescript-config": "0.0.16"
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development tsx watch src/index.ts",

package/src/config/hono.config.ts

@@ -16,6 +16,20 @@ app.use('web/api/*', cors());
 // Logging middleware
 app.use(logMiddleware);
 
+// SSE keep-alive middleware - adds headers to prevent proxy timeouts during streaming
+app.use('web/api/*', async (c, next) => {
+  await next();
+
+  // Add keep-alive headers to streaming responses (SSE/text-streaming)
+  const contentType = c.res.headers.get('content-type');
+  if (contentType?.includes('text/plain') || contentType?.includes('text/event-stream')) {
+    c.header('Connection', 'keep-alive');
+    c.header('Keep-Alive', 'timeout=300'); // 5 minutes
+    c.header('X-Accel-Buffering', 'no');   // Disable nginx buffering
+    c.header('Cache-Control', 'no-cache, no-transform');
+  }
+});
+
 // 全局错误处理中间件（捕获所有路由/中间件异常）
 app.onError((err, c) => {
   // 记录错误日志（error 级别，包含异常堆栈）

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

@@ -1,4 +1,4 @@
-import { convertToModelMessages, streamText } from "ai";
+import { convertToModelMessages, streamText, type TextUIPart } from "ai";
 import { type Context } from "hono";
 import { createModel } from "./model.js";
 import {
@@ -22,13 +22,34 @@ export const buildForm = async (c: Context) => {
   }
 
   const isBuildStage = requestBody.stage === "build";
+  const formName = requestBody.name || "未命名表单";
+
+  const allMessages = [...requestBody.messages];
+  if (isBuildStage) {
+    allMessages.push({
+      role: "user",
+      parts: [
+        {
+          type: "text",
+          text: `确认搭建：${formName}`,
+        },
+      ],
+    });
+  }
+
+  // clear empty text parts to avoid unnecessary streaming
+  allMessages.forEach((message) => {
+    message.parts = message.parts.filter(
+      (part: TextUIPart) => part.type === "text" && part.text.trim() !== ""
+    );
+  });
 
   const stream = streamText({
     model: createModel([
       () => createFieldsJsonTransformStream(isBuildStage),
       () => new SuggestionTransformStream(isBuildStage),
     ]),
-    messages: convertToModelMessages(requestBody.messages),
+    messages: convertToModelMessages(allMessages),
     includeRawChunks: true,
     headers: {
       "x-user-stage": requestBody.stage,

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

@@ -32,6 +32,7 @@ function createJSONParser(): JSONParser {
     paths: [
       '$', // 保留完整结果推送
       '$.title',
+      '$.source',
       '$.name',
       '$.type',
       '$.userID',
@@ -55,14 +56,13 @@ function handleParsedValue(ctx: IParserCtx<IQueryResult>): void {
 
   logger.debug('Parsed JSON value: ' + JSON.stringify(value));
 
-  // TODO: 使用约定的字段判断类型
-  // Phase 1: aggregate 类型 —— name 字段触发，独立处理后直接返回
+  // aggregate 类型 —— name 字段触发，独立处理后直接返回
   if (isTargetElement('$.name', parsedInfo)) {
     handleAggregateName(ctx);
     return;
   }
 
-  // Phase 2: 报表标题 —— 初始化结果并发送 text-start
+  // Phase 0: 报表标题 —— 初始化结果并发送 text-start, 必须为起始字段
   if (isTargetElement('$.title', parsedInfo)) {
     handleTitle(ctx);
   }
@@ -95,8 +95,9 @@ function handleAggregateName(ctx: IParserCtx<IQueryResult>): void {
 
   ctx.setPartialResult({
     title: value as string,
-    isAggregate: true,
+    source: 'aggregate',
     type: 'data_table',
+    isAggregate: true,
   });
 
   logger.debug('Parsed aggregate table title: ' + value);

package/src/controllers/report/query/handler-registry.ts

@@ -1,8 +1,12 @@
-import { type IDashWidgetType, type IQueryFilter } from '@baishuyun/types';
+import { type IDashWidgetType, type IQueryFilter, type QuerySourceType } from '@baishuyun/types';
 import type { PathHandler } from './types.js';
 import { ensureFilter, pushToArray, pushToArrayWithMeta } from './handler-helpers.js';
 
 export const fieldHandlers: PathHandler[] = [
+  {
+    path: '$.source',
+    handler: (ctx, value) => ctx.setPartialResult({ source: value as QuerySourceType }),
+  },
   {
     path: '$.userID',
     handler: (ctx, value) => ctx.setPartialResult({ userID: value as number }),

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

@@ -40,7 +40,7 @@ export const queryReport = async (c: Context) => {
     messages: modelMessages,
     includeRawChunks: true,
     headers: {
-      'x-user-id': uid,
+      'x-user-id': Date.now().toString(), // uid,
     },
   });