@baishuyun/chat-backend 0.0.4 → 0.0.7

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

@@ -1,11 +1,12 @@
-import config from "config";
-import { logger } from "../../../logger/index.js";
+import {} from '@baishuyun/types';
+import config from 'config';
+import { logger } from '../../../logger/index.js';
 export const isSubFormField = (parsedInfo) => {
     if (!parsedInfo || !parsedInfo.stack?.length) {
         return false;
     }
     const lastStackItem = parsedInfo.stack[parsedInfo.stack.length - 1];
-    return lastStackItem?.key === "value";
+    return lastStackItem?.key === 'value';
 };
 export const getLastStackItem = (parsedInfo) => {
     if (!parsedInfo || !parsedInfo.stack?.length) {
@@ -18,22 +19,22 @@ export const getLastSubFormField = (parsedInfo) => {
         return null;
     }
     const targetStackItem = parsedInfo.stack.findLast((s) => {
-        return s.value?.fieldType === "subform";
+        return s.value?.fieldType === 'subform';
     });
     return targetStackItem;
 };
 export const parseImg = async (file) => {
-    const isImg = file.type.startsWith("image/");
+    const isImg = file.type.startsWith('image/');
     if (!isImg) {
         return null;
     }
-    const ocrApiKey = config.get("agent.form.fill.ocrApiKey");
-    const ocrEndpoint = "https://api.ocr.space/parse/image";
+    const ocrApiKey = config.get('agent.form.fill.ocrApiKey');
+    const ocrEndpoint = 'https://api.ocr.space/parse/image';
     const formData = new FormData();
-    formData.append("language", "chs");
-    formData.append("file", file);
+    formData.append('language', 'chs');
+    formData.append('file', file);
     const response = await fetch(ocrEndpoint, {
-        method: "POST",
+        method: 'POST',
         body: formData,
         headers: {
             // Add any auth headers
@@ -43,14 +44,40 @@ export const parseImg = async (file) => {
     const result = await response.json();
     console.log(result);
     if (result.IsErroredOnProcessing) {
-        logger.error("image ocr parse error");
+        logger.error('image ocr parse error');
         return null;
     }
     if (!result.ParsedResults || !result.ParsedResults.length) {
-        logger.debug("image ocr parse no result");
+        logger.debug('image ocr parse no result');
         return null;
     }
     // join all parsed text
     const parsedTexts = result.ParsedResults.map((pr) => pr.ParsedText);
-    return parsedTexts.join("\n");
+    return parsedTexts.join('\n');
+};
+export const mode2part = (mode, count = 10) => {
+    const modeMap = {
+        AI: {
+            type: 'text',
+            text: '智能填写当前表单数据',
+        },
+        batch: {
+            type: 'text',
+            text: `为表单批量填写示例数据`,
+        },
+        normal: {
+            type: 'text',
+            text: '解析输入作为当前表单的数据',
+        },
+    };
+    return modeMap[mode];
+};
+export const fillingChunkGuard = (chunk, enableGuard = true) => {
+    if (!enableGuard) {
+        return false;
+    }
+    if (chunk.type !== 'text-delta' || !('delta' in chunk)) {
+        return false;
+    }
+    return true;
 };

package/ecosystem.config.cjs

@@ -0,0 +1,23 @@
+module.exports = {
+  apps: [
+    {
+      name: 'chat-sdk-backend', // 进程名称
+      script: './dist/src/index.js', // 启动入口文件
+      instances: 'max', // 启动多进程（利用多核CPU，可选）
+      autorestart: true, // 异常时自动重启（核心）
+      watch: false, // 生产环境关闭文件监听（避免容器内文件变动触发重启）
+      max_memory_restart: '2G', // 内存超过 1G 自动重启（防止内存泄漏）
+      env: {
+        // 开发环境变量
+        NODE_ENV: 'development',
+      },
+      env_production: {
+        // 生产环境变量
+        NODE_ENV: 'production',
+      },
+      log_date_format: 'YYYY-MM-DD HH:mm:ss', // 日志时间格式
+      error_file: './logs/err.log', // 错误日志路径
+      out_file: './logs/out.log', // 输出日志路径
+    },
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baishuyun/chat-backend",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "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.5",
-    "@baishuyun/types": "1.0.5"
+    "@baishuyun/coze-provider": "0.0.7",
+    "@baishuyun/types": "1.0.7"
   },
   "devDependencies": {
     "@types/config": "^3.3.5",
@@ -31,13 +31,16 @@
     "@types/node": "^20.11.17",
     "cross-env": "^10.1.0",
     "pino-pretty": "^13.1.3",
+    "pm2": "^6.0.14",
     "tsx": "^4.7.1",
     "typescript": "^5.8.3",
-    "@baishuyun/typescript-config": "0.0.5"
+    "@baishuyun/typescript-config": "0.0.7"
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development tsx watch src/index.ts",
     "build": "tsc",
-    "start": "cross-env NODE_ENV=production NODE_CONFIG_DIR=./dist/config node dist/src/index.js"
+    "start": "cross-env NODE_ENV=production NODE_CONFIG_DIR=./dist/config pm2-runtime ecosystem.config.cjs --env production",
+    "pm2start": "cross-env NODE_ENV=production NODE_CONFIG_DIR=./dist/config pm2 ecosystem.config.cjs --env production",
+    "pm2": "pm2"
   }
 }

package/src/app/main.ts

@@ -9,9 +9,9 @@ import app from '../config/hono.config.js';
 import { createFormRouter } from '../routes/form/form.route.js';
 
 // 挂载子路由
-app.route('api/form', createFormRouter());
+app.route('web/api/form', createFormRouter());
 
 // add test route
-app.get('/api/test', (c) => {
+app.get('web/api/test', (c) => {
   return c.json({ message: 'Test route is working!' });
 });

package/src/config/hono.config.ts

@@ -1,9 +1,9 @@
-import { Hono } from "hono";
-import { serve } from "@hono/node-server";
-import config from "config";
-import { cors } from "hono/cors";
-import { logMiddleware } from "../logger/log-middleware.js";
-import { logger } from "../logger/index.js";
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import config from 'config';
+import { cors } from 'hono/cors';
+import { logMiddleware } from '../logger/log-middleware.js';
+import { logger } from '../logger/index.js';
 
 /**
  * 公共配置层，跨域、日志等中间件配置
@@ -11,7 +11,7 @@ import { logger } from "../logger/index.js";
 const app = new Hono();
 
 // Enable CORS for all routes starting with /api/
-app.use("/api/*", cors());
+app.use('web/api/*', cors());
 
 // Logging middleware
 app.use(logMiddleware);
@@ -26,22 +26,22 @@ app.onError((err, c) => {
       path: c.req.path,
       status: 500, // 默认 500 错误
     },
-    "Request failed with unhandled error",
+    'Request failed with unhandled error'
   ); // 错误描述
 
   // 返回统一的 JSON 错误响应
-  return c.json({ message: "Internal Server Error" }, 500);
+  return c.json({ message: 'Internal Server Error' }, 500);
 });
 
 serve(
   {
     fetch: app.fetch,
-    hostname: config.get<string>("app.host") || "",
-    port: config.get<number>("app.port") || 3001,
+    hostname: config.get<string>('app.host') || '',
+    port: config.get<number>('app.port') || 3001,
   },
   (info) => {
     logger.info(`Server is running on http://localhost:${info.port}`);
-  },
+  }
 );
 
 export default app;

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

@@ -25,14 +25,15 @@ export const buildForm = async (c: Context) => {
 
   const stream = streamText({
     model: createModel([
-      createFieldsJsonTransformStream(isBuildStage),
-      new SuggestionTransformStream(isBuildStage),
+      () => createFieldsJsonTransformStream(isBuildStage),
+      () => new SuggestionTransformStream(isBuildStage),
     ]),
     messages: convertToModelMessages(requestBody.messages),
     includeRawChunks: true,
     headers: {
       "x-user-stage": requestBody.stage,
       "x-user-id": Date.now().toString(),
+      "x-user-token": c.req.header("authorization") || "",
     },
   });
 

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

@@ -3,7 +3,7 @@ import { createCoze } from "@baishuyun/coze-provider";
 import config from "config";
 
 export const createModel = (
-  extraStreamTransformers: TransformStream<LanguageModelV2StreamPart, any>[],
+  extraStreamTransformers: (() => TransformStream<LanguageModelV2StreamPart, any>)[]
 ) => {
   const coze = createCoze({
     apiKey: config.get<string>("agent.form.build.apiKey"),

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

@@ -0,0 +1,202 @@
+import { type Context } from 'hono';
+import {
+  convertToModelMessages,
+  streamText,
+  createUIMessageStream,
+  createUIMessageStreamResponse,
+  type UIMessage,
+  type TextUIPart,
+  generateId,
+  type ModelMessage,
+} from 'ai';
+import { logger } from '../../../logger/index.js';
+import { createBatchFillingModel } from './model.js';
+import { mode2part } from './utils.js';
+import type { FormFillingMode } from '@baishuyun/types';
+
+const getModelMessagesFromUserMessages = ({
+  continueMessageId,
+  currentMsg,
+  formStructure,
+  mode,
+  messages,
+}: {
+  formStructure: Array<any>;
+  mode: FormFillingMode;
+  messages: UIMessage[];
+
+  continueMessageId?: string;
+  currentMsg?: string;
+}): ModelMessage[] => {
+  // init fill
+  if (continueMessageId && currentMsg) {
+    return convertToModelMessages([
+      {
+        role: 'user',
+        parts: [
+          {
+            type: 'text',
+            text: `formStructure: ${JSON.stringify(formStructure)}`,
+          },
+          mode2part(mode),
+          {
+            type: 'text',
+            text: currentMsg,
+          },
+        ],
+      },
+    ]);
+  }
+
+  let lastUserMsg: UIMessage | undefined = messages.findLast((m) => m.role === 'user') || {
+    id: generateId(),
+    role: 'user',
+    parts: [],
+  };
+
+  lastUserMsg.parts.push({
+    type: 'text',
+    text: `formStructure: ${JSON.stringify(formStructure)}`,
+  });
+
+  lastUserMsg.parts.push(mode2part(mode));
+
+  return convertToModelMessages([lastUserMsg]);
+};
+
+/**
+ * 表单填写
+ * @param c
+ * @returns
+ */
+export const batchFillForm = async (c: Context) => {
+  let requestBody;
+
+  try {
+    const json = await c.req.json();
+    requestBody = json;
+  } catch (_) {
+    return c.json({ error: 'Invalid JSON' }, 400);
+  }
+
+  const formStructure = requestBody.formStructure;
+  const mode = requestBody.mode;
+  const continueMessageId = requestBody.continueMessageId; // 新增：继续生成的消息 ID
+  const userMessages: UIMessage[] = requestBody.messages;
+
+  // clear empty user text part  message
+  const messages = userMessages.filter((msg) => {
+    if (msg.role !== 'user') {
+      return true;
+    }
+
+    const firstPart = msg.parts[0] as TextUIPart | undefined;
+    if (!firstPart) {
+      return false;
+    }
+
+    if (firstPart.type === 'text' && firstPart.text.trim() === '') {
+      return false;
+    }
+
+    return true;
+  });
+
+  // 如果是继续生成模式
+  if (continueMessageId) {
+    return handleContinueGeneration(c, {
+      messages,
+      formStructure,
+      continueMessageId,
+      msg: requestBody.msg,
+      mode,
+      stage: requestBody.stage,
+    });
+  }
+
+  const modelMessages = getModelMessagesFromUserMessages({
+    messages,
+    mode,
+    formStructure,
+  });
+
+  // 正常创建新流
+  const stream = streamText({
+    model: createBatchFillingModel(),
+    messages: modelMessages,
+    includeRawChunks: true,
+    headers: {
+      'x-user-stage': requestBody.stage,
+      'x-user-token': c.req.header('authorization') || '',
+      'x-user-var': JSON.stringify({
+        mode: requestBody.mode,
+      }),
+    },
+  });
+
+  return stream.toUIMessageStreamResponse({
+    originalMessages: messages, // 建议添加，便于消息 ID 管理
+  });
+};
+
+/**
+ * 处理继续生成（扩展同一消息）
+ */
+async function handleContinueGeneration(
+  c: Context,
+  {
+    messages,
+    continueMessageId,
+    mode,
+    msg,
+    formStructure,
+    stage,
+  }: {
+    messages: UIMessage[];
+    formStructure: Array<any>;
+    continueMessageId: string;
+    mode: FormFillingMode;
+    msg: string;
+    stage: string;
+  }
+) {
+  const stream = createUIMessageStream({
+    execute: async ({ writer }) => {
+      writer.write({
+        type: 'start',
+        messageId: continueMessageId,
+      });
+
+      // 构建模型消息
+      const modelMessages = getModelMessagesFromUserMessages({
+        messages,
+        continueMessageId,
+        currentMsg: msg,
+        mode,
+        formStructure,
+      });
+
+      logger.debug(`continue modelMessages ${JSON.stringify(modelMessages)}`);
+
+      const result = streamText({
+        model: createBatchFillingModel(),
+        messages: modelMessages,
+        includeRawChunks: true,
+        headers: {
+          'x-user-stage': stage,
+          'x-user-var': JSON.stringify({
+            mode,
+          }),
+        },
+      });
+
+      writer.merge(
+        result.toUIMessageStream({
+          sendStart: false,
+        })
+      );
+    },
+  });
+
+  return createUIMessageStreamResponse({ stream });
+}

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

@@ -0,0 +1,156 @@
+import { type LanguageModelV2StreamPart } from '@ai-sdk/provider';
+import { JSONParser } from '@streamparser/json';
+import { createTextInfoEnqueuer } from '@baishuyun/coze-provider';
+import { getLastSubFormField } from './utils.js';
+import { fillingChunkGuard as chunkGuard } from './utils.js';
+import { logger } from '../../../logger/index.js';
+
+export const createBatchFillingResultTransformer = (enableJsonParser: boolean) => {
+  let parser: JSONParser;
+  let id: string;
+  // 解析完成标记：用于等待解析器内部队列处理完毕
+  let parseCompleted: Promise<void>;
+  let resolveParseCompleted: () => void;
+
+  const transformer = {
+    flush: async (controller: TransformStreamDefaultController<any>) => {
+      try {
+        if (parser) {
+          await parseCompleted;
+          logger.debug('stop parser');
+        }
+        controller.terminate(); // 信号通知下游可读流已关闭
+      } catch (e) {
+        controller.error('stop error' + e);
+        // controller.terminate(); // 信号通知下游可读流已关闭
+      }
+    },
+
+    transform: (
+      chunk: LanguageModelV2StreamPart,
+      controller: TransformStreamDefaultController<LanguageModelV2StreamPart>
+    ) => {
+      if (!parser) {
+        logger.warn('json parser not init');
+        return;
+      }
+
+      const enqueueTextDelta = createTextInfoEnqueuer(controller);
+
+      try {
+        if (chunkGuard(chunk)) {
+          if ('id' in chunk && 'delta' in chunk) {
+            id = chunk.id;
+
+            const regExp = /`?`?`?/;
+
+            let delta = chunk.delta.replace(regExp, '');
+            parser.write(delta.replace('json', ''));
+          }
+        } else {
+          // logger.debug(`bypass chunk in batch filling transformer: ${JSON.stringify(chunk)}`);
+          controller.enqueue(chunk);
+        }
+      } catch (e) {
+        logger.debug('exception in transform while processing filling chunk');
+        controller.error(e);
+        enqueueTextDelta('error', {
+          type: 'agent-error',
+          error: '解析异常，请刷新重试',
+        });
+
+        resolveParseCompleted?.();
+        controller.terminate(); // 信号通知下游可读流已关闭
+      }
+    },
+
+    start: (controller: TransformStreamDefaultController<any>) => {
+      parser = new JSONParser({
+        paths: ['$.*', '$.*.value.*.*'],
+      });
+
+      parseCompleted = new Promise((resolve) => {
+        resolveParseCompleted = resolve;
+      });
+
+      const enqueueTextDelta = enableJsonParser
+        ? createTextInfoEnqueuer(controller)
+        : (content: string) => {};
+
+      parser.onValue = (parsedInfo: any) => {
+        const value = parsedInfo.value;
+
+        if (value.error && value.errorMessage === 'timeout') {
+          enqueueTextDelta(JSON.stringify(value), {
+            type: 'agent-error',
+            error: '操作超时，请刷新重试',
+          });
+
+          resolveParseCompleted?.();
+          controller.terminate(); // 信号通知下游可读流已关闭
+          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}`);
+        enqueueTextDelta(
+          `${JSON.stringify(value)},`,
+          {
+            type: 'mcp-fields-json',
+            field: value,
+          },
+          id,
+          true
+        );
+      };
+
+      let errorLogged = false;
+      parser.onError = (err: any) => {
+        if (!errorLogged) {
+          console.error('JsonWidgetStream: JSON Parsing Error:', err);
+          errorLogged = true;
+        }
+
+        enqueueTextDelta('error', {
+          type: 'agent-error',
+          error: '操作超时，请刷新重试',
+        });
+
+        resolveParseCompleted?.();
+        controller.terminate(); // 信号通知下游可读流已关闭
+      };
+
+      parser.onEnd = () => {
+        enqueueTextDelta(
+          ' ',
+          JSON.stringify({
+            appendConfirm: 'save-fields',
+          })
+        );
+
+        logger.debug('mark as end');
+        resolveParseCompleted?.();
+      };
+    },
+  };
+
+  return new TransformStream<LanguageModelV2StreamPart, any>(transformer);
+};