@baishuyun/chat-backend 0.0.18 → 0.0.20

package/dist/src/services/asr/asr-websocket.js

@@ -0,0 +1,183 @@
+import WebSocket from 'ws';
+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';
+/**
+ * 处理浏览器 ASR WebSocket 连接
+ * 作为浏览器与火山引擎 ASR 之间的双向代理
+ */
+export function handleASRConnection(clientWs, req) {
+    const asrConfig = config.get('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 = [];
+    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 = {
+        '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) => {
+        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) => {
+        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;
+        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/dist/src/services/asr/volc-protocol.js

@@ -0,0 +1,143 @@
+/**
+ * 火山引擎 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, flags, serialization) {
+    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, flags, serialization, payload) {
+    const header = build4ByteHeader(msgType, flags, serialization);
+    const payloadSize = Buffer.alloc(4);
+    payloadSize.writeUInt32BE(payload.length, 0);
+    return Buffer.concat([header, payloadSize, payload]);
+}
+/**
+ * 解析 4 字节协议头
+ */
+export function parseHeader(buffer) {
+    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, offset) {
+    return buffer.readUInt32BE(offset);
+}
+/**
+ * 创建 FullClientRequest（初始化请求）
+ *
+ * Payload JSON 格式：
+ * {
+ *   user: { uid: string },
+ *   audio: { format, rate, bits, channel, codec, language },
+ *   request: { model_name, enable_itn, enable_punc, ... }
+ * }
+ */
+export function createFullClientRequest() {
+    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, isLast = false) {
+    const flags = isLast ? 0b0010 : 0b0000;
+    return buildMessage(MSG_TYPE_AUDIO_ONLY_REQUEST, flags, SERIALIZATION_NONE, audioData);
+}
+/**
+ * 解析 JSON payload
+ */
+export function parseJsonPayload(payloadBuffer) {
+    try {
+        return JSON.parse(payloadBuffer.toString('utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 解析 ErrorResponse
+ *
+ * 格式：header(4B) + errorCode(4B) + errorMsgSize(4B) + errorMsg
+ */
+export function parseErrorPayload(buffer, bodyOffset) {
+    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 };
+}

package/dist/src/services/fetchCozeInfo.js

@@ -2,7 +2,7 @@ import config from 'config';
 import { logger } from '../logger/index.js';
 export const fetchCozeInfo = async (bsTeamId) => {
     const agentHost = config.get('agent.host');
-    const apiUrl = `http://${agentHost}/api/by_teamid/tokens`;
+    const apiUrl = `https://${agentHost}/api/by_teamid/tokens`;
     const res = await fetch(apiUrl, {
         method: 'POST',
         headers: {

package/dist/src/utils/createFakeUIMessageStreamResponse.js

@@ -0,0 +1,25 @@
+import { createUIMessageStream, createUIMessageStreamResponse, generateId } from 'ai';
+import { createSpecialPartMeta } from './createSpecialPartMeta.js';
+/**
+ * 创建一个与 `streamText().toUIMessageStreamResponse()` 格式一致的假流式响应，
+ * 用于在无法调用真实模型时向客户端推送一条指定的文本消息。
+ */
+export const createFakeUIMessageStreamResponse = (text) => {
+    const stream = createUIMessageStream({
+        execute: ({ writer }) => {
+            const messageId = generateId();
+            const textId = generateId();
+            writer.write({ type: 'start', messageId });
+            writer.write({ type: 'text-start', id: textId });
+            writer.write({
+                type: 'text-delta',
+                id: textId,
+                delta: text,
+                providerMetadata: createSpecialPartMeta('error-bot-id-required'),
+            });
+            writer.write({ type: 'text-end', id: textId });
+            writer.write({ type: 'finish', finishReason: 'stop' });
+        },
+    });
+    return createUIMessageStreamResponse({ stream });
+};

package/dist/src/utils/createJsonStreamTransformer.js

@@ -35,6 +35,7 @@ class JsonStreamProcessor {
     parseCompleted = null;
     resolveParseCompleted = null;
     terminated = false;
+    passthroughMode = false; // 当启用且遇到非 JSON chunk 时，切换到透传模式
     constructor(options) {
         this.options = options;
     }
@@ -51,6 +52,10 @@ class JsonStreamProcessor {
             logger.warn('JSON parser not initialized or stream already terminated');
             return;
         }
+        if (this.passthroughMode) {
+            controller.enqueue(chunk);
+            return;
+        }
         try {
             // 1) error chunk → 通知下游后终止
             if (chunk.type === 'error') {
@@ -71,6 +76,11 @@ class JsonStreamProcessor {
             }
         }
         catch (error) {
+            if (this.options.bypassParseError) {
+                this.passthroughMode = true;
+                controller.enqueue(chunk);
+                return;
+            }
             this.enqueueError(controller, error);
         }
     }
@@ -120,6 +130,10 @@ class JsonStreamProcessor {
             });
         };
         this.parser.onError = (err) => {
+            if (this.options.bypassParseError) {
+                this.passthroughMode = true;
+                return;
+            }
             if (!this.terminated) {
                 const msg = this.options.onParseError
                     ? this.options.onParseError(err)
@@ -130,8 +144,9 @@ class JsonStreamProcessor {
             }
         };
         this.parser.onEnd = () => {
-            logger.debug('Parsing completed');
-            enqueue(' ', JSON.stringify({ appendConfirm: 'save-fields' }));
+            if (!this.options.bypassParseError) {
+                enqueue(' ', JSON.stringify({ appendConfirm: 'save-fields' }));
+            }
             this.completeParsing();
         };
     }

package/dist/src/utils/createSpecialPartMeta.js

@@ -0,0 +1,5 @@
+export const createSpecialPartMeta = (type, content) => {
+    return {
+        raw: { data: { specialPart: true, type: 'error-bot-id-required' } },
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baishuyun/chat-backend",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,21 +22,23 @@
     "lru-cache": "^11.2.7",
     "parse-sse": "^0.1.0",
     "pino": "^10.1.0",
+    "ws": "^8.18.0",
     "zod": "^4.1.13",
-    "@baishuyun/coze-provider": "0.1.0",
-    "@baishuyun/types": "1.1.0",
-    "@baishuyun/agents": "0.1.0"
+    "@baishuyun/agents": "1.0.0",
+    "@baishuyun/types": "2.0.0",
+    "@baishuyun/coze-provider": "1.0.0"
   },
   "devDependencies": {
     "@types/config": "^3.3.5",
     "@types/dotenv": "^8.2.3",
     "@types/node": "^20.11.17",
+    "@types/ws": "^8.5.13",
     "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.1.0"
+    "@baishuyun/typescript-config": "1.0.0"
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development tsx watch src/index.ts",

package/src/app/main.ts

@@ -26,3 +26,15 @@ app.get('/web/api/health', (c) => {
     service: 'hono-app',
   });
 });
+
+// 挂载 ASR WebSocket Server
+import { WebSocketServer } from 'ws';
+import { server } from '../config/hono.config.js';
+import { handleASRConnection } from '../services/asr/asr-websocket.js';
+
+const wss = new WebSocketServer({
+  server: server as any,
+  path: '/web/api/asr',
+});
+
+wss.on('connection', handleASRConnection);

package/src/config/hono.config.ts

@@ -47,7 +47,7 @@ app.onError((err, c) => {
   return c.json({ message: 'Internal Server Error' }, 500);
 });
 
-serve(
+const server = serve(
   {
     fetch: app.fetch,
     hostname: config.get<string>('app.host') || '',
@@ -58,4 +58,5 @@ serve(
   }
 );
 
+export { server };
 export default app;

package/src/const/error_code.ts

@@ -0,0 +1,3 @@
+export const ERROR_CODE = {
+  BOT_ID_MISSING: 10001,
+};

package/src/controllers/agent/bots.controller.ts

@@ -6,7 +6,7 @@ import type { ICozeInfoOfTokenExchange } from '../../types/coze.js';
 
 export const listBots = async (c: Context) => {
   const agentHost = config.get<string>('agent.host');
-  const apiBots = `http://${agentHost}/v1/bots`;
+  const apiBots = `https://${agentHost}/v1/bots`;
   const cozeInfo = c.get('X-Coze-Info') as ICozeInfoOfTokenExchange;
 
   logger.debug(`Fetching bots from ${apiBots} with cozeToken: ${cozeInfo.cozeToken}`);

package/src/controllers/common/connect.controll.ts

@@ -2,6 +2,7 @@ import { convertToModelMessages, streamText } from 'ai';
 import type { Context } from 'hono';
 import { createBaseModel } from './model.js';
 import type { ICozeInfoOfTokenExchange } from '../../types/coze.js';
+import { logger } from '../../logger/index.js';
 
 export const connectToAgent = async (c: Context) => {
   let requestBody;
@@ -18,13 +19,15 @@ export const connectToAgent = async (c: Context) => {
 
   const botId = c.req.header('X-Bot-Id') || '';
 
+  logger.debug('enter common controller');
+
   const stream = streamText({
-    model: createBaseModel(botId, cozeInfo.cozeToken),
+    model: createBaseModel(botId, cozeInfo?.cozeToken),
     messages: convertToModelMessages(messages),
     includeRawChunks: true,
     headers: {
       'x-user-var': requestBody.userVar,
-      'x-user-id': cozeInfo.userId,
+      'x-user-id': cozeInfo?.userId,
     },
   });
 

package/src/controllers/common/model.ts

@@ -1,11 +1,13 @@
 import { createCoze } from '@baishuyun/coze-provider';
 import config from 'config';
+import { createAgentCallingListener } from './transformer-factory/agent-calling-listener.js';
 
 export const createBaseModel = (botId: string, token?: string) => {
   const coze = createCoze({
     apiKey: token || config.get<string>('agent.common.apiKey'),
     baseURL: config.get<string>('agent.common.baseUrl'),
     botId: botId,
+    extraStreamTransformers: [createAgentCallingListener],
   });
 
   return coze.chat('chat');

package/src/controllers/common/transformer-factory/agent-calling-listener.ts

@@ -0,0 +1,69 @@
+import {
+  createJsonStreamTransformer,
+  type IParserCtx,
+} from '../../../utils/createJsonStreamTransformer.js';
+import { JSONParser } from '@streamparser/json';
+import { isTargetElement } from '../../report/query/utils.js';
+
+function createJSONParser(): JSONParser {
+  return new JSONParser({
+    stringBufferSize: undefined,
+    numberBufferSize: undefined,
+    separator: '',
+    paths: ['$.type', '$.prompt', '$.agent'],
+    keepStack: true,
+  });
+}
+
+export interface IAgentCallingCtx {
+  type: string;
+  prompt: string;
+  agent: string;
+}
+
+type PathHandler = {
+  path: string;
+  handler: (ctx: IParserCtx<IAgentCallingCtx>, value: unknown) => void;
+};
+
+export const fieldHandlers: PathHandler[] = [
+  {
+    path: '$.type',
+    handler: (ctx, value) => ctx.setPartialResult({ type: value as string }),
+  },
+  {
+    path: '$.prompt',
+    handler: (ctx, value) => ctx.setPartialResult({ prompt: value as string }),
+  },
+  {
+    path: '$.agent',
+    handler: (ctx, value) => ctx.setPartialResult({ agent: value as string }),
+  },
+];
+
+function handleParsedValue(ctx: IParserCtx<IAgentCallingCtx>): void {
+  const { parsedInfo, getResult, currentChunkId, deltaChunkEnqueuer: enqueueTextDelta, ctrl } = ctx;
+  const { value } = parsedInfo;
+
+  for (const { path, handler } of fieldHandlers) {
+    if (isTargetElement(path, parsedInfo)) {
+      handler(ctx, value);
+      break;
+    }
+  }
+
+  enqueueTextDelta(
+    `${JSON.stringify(value)},`,
+    { type: 'agent-calling', result: JSON.stringify(getResult()) },
+    currentChunkId,
+    true
+  );
+}
+
+export const createAgentCallingListener = () => {
+  return createJsonStreamTransformer({
+    bypassParseError: true,
+    createJSONParser,
+    onParseValue: handleParsedValue,
+  });
+};

package/src/controllers/form/attachment-upload.controller.ts

@@ -1,27 +1,27 @@
-import { type Context } from "hono";
-import config from "config";
-import { logger } from "../../logger/index.js";
-import { parseImg } from "./fill/utils.js";
+import { type Context } from 'hono';
+import config from 'config';
+import { logger } from '../../logger/index.js';
+import { parseImg } from './fill/utils.js';
 
 export const uploadAttachment = async (c: Context) => {
   const formData = await c.req.formData();
-  const file = formData.get("file"); // as FormData | null;
+  const file = formData.get('file'); // as FormData | null;
   // 校验文件是否存在
   if (!file || !(file instanceof Blob)) {
-    return c.json({ error: "请上传有效的文件" }, 400);
+    return c.json({ error: '请上传有效的文件' }, 400);
   }
 
   const forwardFormData = new FormData();
-  forwardFormData.append("file", file);
+  forwardFormData.append('file', file);
 
-  const apiKey = config.get<string>("agent.apiAuthKey");
-  const host = config.get<string>("agent.host");
-  const api = `http://${host}/v1/files/upload`;
+  const apiKey = config.get<string>('agent.apiAuthKey');
+  const host = config.get<string>('agent.host');
+  const api = `https://${host}/v1/files/upload`;
 
   logger.debug(c.body);
 
   const response = await fetch(api, {
-    method: "POST",
+    method: 'POST',
     body: formData,
     headers: {
       // Add any auth headers
@@ -30,9 +30,7 @@ export const uploadAttachment = async (c: Context) => {
   });
 
   if (!response.ok) {
-    const errorData = await response
-      .json()
-      .catch(() => ({ message: "上传失败" }));
+    const errorData = await response.json().catch(() => ({ message: '上传失败' }));
     return c.json({
       error: `目标接口返回错误: ${errorData.message}`,
       status: response.status,
@@ -44,8 +42,11 @@ export const uploadAttachment = async (c: Context) => {
 
   const orcResult = await parseImg(file);
 
+  // replace file url protol to https
+  const secureUrl = url.replace('http://', 'https://');
+
   return c.json({
-    url,
+    url: secureUrl,
     name: uri,
     contentType: file.type,
     parsedData: orcResult,