@openclaw-china/qqbot 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -4,6 +4,22 @@ declare const QQBotConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     appId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
     clientSecret: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+    asr: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        appId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+        secretId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+        secretKey: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        appId?: string | undefined;
+        secretId?: string | undefined;
+        secretKey?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        appId?: unknown;
+        secretId?: unknown;
+        secretKey?: unknown;
+    }>>;
     markdownSupport: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["open", "pairing", "allowlist"]>>>;
     groupPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["open", "allowlist", "disabled"]>>>;
@@ -28,12 +44,24 @@ declare const QQBotConfigSchema: z.ZodObject<{
     mediaTimeoutMs: number;
     appId?: string | undefined;
     clientSecret?: string | undefined;
+    asr?: {
+        enabled: boolean;
+        appId?: string | undefined;
+        secretId?: string | undefined;
+        secretKey?: string | undefined;
+    } | undefined;
     allowFrom?: string[] | undefined;
     groupAllowFrom?: string[] | undefined;
 }, {
     enabled?: boolean | undefined;
     appId?: unknown;
     clientSecret?: unknown;
+    asr?: {
+        enabled?: boolean | undefined;
+        appId?: unknown;
+        secretId?: unknown;
+        secretKey?: unknown;
+    } | undefined;
     markdownSupport?: boolean | undefined;
     dmPolicy?: "open" | "pairing" | "allowlist" | undefined;
     groupPolicy?: "open" | "allowlist" | "disabled" | undefined;
@@ -126,6 +154,24 @@ declare const qqbotPlugin: {
                 clientSecret: {
                     type: string;
                 };
+                asr: {
+                    type: string;
+                    additionalProperties: boolean;
+                    properties: {
+                        enabled: {
+                            type: string;
+                        };
+                        appId: {
+                            type: string;
+                        };
+                        secretId: {
+                            type: string;
+                        };
+                        secretKey: {
+                            type: string;
+                        };
+                    };
+                };
                 markdownSupport: {
                     type: string;
                 };
@@ -406,6 +452,24 @@ declare const plugin: {
             clientSecret: {
                 type: string;
             };
+            asr: {
+                type: string;
+                additionalProperties: boolean;
+                properties: {
+                    enabled: {
+                        type: string;
+                    };
+                    appId: {
+                        type: string;
+                    };
+                    secretId: {
+                        type: string;
+                    };
+                    secretKey: {
+                        type: string;
+                    };
+                };
+            };
             markdownSupport: {
                 type: string;
             };

package/dist/index.js

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import * as fsPromises from 'fs/promises';
+import { createHmac } from 'crypto';
 import WebSocket from 'ws';
 
 var __defProp = Object.defineProperty;
@@ -4064,6 +4065,12 @@ var QQBotConfigSchema = external_exports.object({
   enabled: external_exports.boolean().optional().default(true),
   appId: optionalCoercedString,
   clientSecret: optionalCoercedString,
+  asr: external_exports.object({
+    enabled: external_exports.boolean().optional().default(false),
+    appId: optionalCoercedString,
+    secretId: optionalCoercedString,
+    secretKey: optionalCoercedString
+  }).optional(),
   markdownSupport: external_exports.boolean().optional().default(false),
   dmPolicy: external_exports.enum(["open", "pairing", "allowlist"]).optional().default("open"),
   groupPolicy: external_exports.enum(["open", "allowlist", "disabled"]).optional().default("open"),
@@ -4083,6 +4090,16 @@ function resolveQQBotCredentials(config) {
   if (!config?.appId || !config?.clientSecret) return void 0;
   return { appId: config.appId, clientSecret: config.clientSecret };
 }
+function resolveQQBotASRCredentials(config) {
+  const asr = config?.asr;
+  if (!asr?.enabled) return void 0;
+  if (!asr.appId || !asr.secretId || !asr.secretKey) return void 0;
+  return {
+    appId: asr.appId,
+    secretId: asr.secretId,
+    secretKey: asr.secretKey
+  };
+}
 
 // ../../packages/shared/src/logger/logger.ts
 function createLogger(prefix, opts) {
@@ -5085,6 +5102,163 @@ function appendCronHiddenPrompt(text) {
 ${CRON_HIDDEN_PROMPT}`;
 }
 
+// ../../packages/shared/src/asr/errors.ts
+var ASRError = class extends Error {
+  constructor(message, kind, provider, retryable = false) {
+    super(message);
+    this.kind = kind;
+    this.provider = provider;
+    this.retryable = retryable;
+    this.name = "ASRError";
+  }
+};
+var ASRTimeoutError = class extends ASRError {
+  constructor(provider, timeoutMs) {
+    super(`ASR request timeout after ${timeoutMs}ms`, "timeout", provider, true);
+    this.timeoutMs = timeoutMs;
+    this.name = "ASRTimeoutError";
+  }
+};
+var ASRAuthError = class extends ASRError {
+  constructor(provider, message, status) {
+    super(message, "auth", provider, false);
+    this.status = status;
+    this.name = "ASRAuthError";
+  }
+};
+var ASRRequestError = class extends ASRError {
+  constructor(provider, message, status) {
+    super(message, "request", provider, true);
+    this.status = status;
+    this.name = "ASRRequestError";
+  }
+};
+var ASRResponseParseError = class extends ASRError {
+  constructor(provider, bodySnippet) {
+    super("ASR response is not valid JSON", "response_parse", provider, false);
+    this.bodySnippet = bodySnippet;
+    this.name = "ASRResponseParseError";
+  }
+};
+var ASRServiceError = class extends ASRError {
+  constructor(provider, message, serviceCode) {
+    super(message, "service", provider, false);
+    this.serviceCode = serviceCode;
+    this.name = "ASRServiceError";
+  }
+};
+var ASREmptyResultError = class extends ASRError {
+  constructor(provider) {
+    super("ASR returned empty transcript", "empty_result", provider, false);
+    this.name = "ASREmptyResultError";
+  }
+};
+
+// ../../packages/shared/src/asr/tencent-flash.ts
+var ASR_FLASH_HOST = "asr.cloud.tencent.com";
+var ASR_FLASH_PATH_PREFIX = "/asr/flash/v1";
+var ASR_FLASH_URL_PREFIX = `https://${ASR_FLASH_HOST}${ASR_FLASH_PATH_PREFIX}`;
+var ASR_PROVIDER = "tencent-flash";
+function encodeQueryValue(value) {
+  return encodeURIComponent(value).replace(/%20/g, "+").replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function buildSignedQuery(params) {
+  return Object.entries(params).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeQueryValue(value)}`).join("&");
+}
+function extractTranscript(payload) {
+  const items = Array.isArray(payload.flash_result) ? payload.flash_result : [];
+  const lines = [];
+  for (const item of items) {
+    if (typeof item?.text === "string" && item.text.trim()) {
+      lines.push(item.text.trim());
+      continue;
+    }
+    const sentenceList = Array.isArray(item?.sentence_list) ? item.sentence_list : [];
+    for (const sentence of sentenceList) {
+      if (typeof sentence?.text === "string" && sentence.text.trim()) {
+        lines.push(sentence.text.trim());
+      }
+    }
+  }
+  return lines.join("\n").trim();
+}
+async function transcribeTencentFlash(params) {
+  const { audio, config } = params;
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const engineType = config.engineType ?? "16k_zh";
+  const voiceFormat = config.voiceFormat ?? "silk";
+  const query = buildSignedQuery({
+    engine_type: engineType,
+    secretid: config.secretId,
+    timestamp,
+    voice_format: voiceFormat
+  });
+  const signText = `POST${ASR_FLASH_HOST}${ASR_FLASH_PATH_PREFIX}/${config.appId}?${query}`;
+  const authorization = createHmac("sha1", config.secretKey).update(signText).digest("base64");
+  const url = `${ASR_FLASH_URL_PREFIX}/${config.appId}?${query}`;
+  const timeoutMs = config.timeoutMs ?? 3e4;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: authorization,
+        "Content-Type": "application/octet-stream"
+      },
+      body: audio,
+      signal: controller.signal
+    });
+    const bodyText = await response.text();
+    let payload;
+    try {
+      payload = JSON.parse(bodyText);
+    } catch {
+      throw new ASRResponseParseError(ASR_PROVIDER, bodyText.slice(0, 300));
+    }
+    if (!response.ok) {
+      const message = payload.message ?? `HTTP ${response.status}`;
+      if (response.status === 401 || response.status === 403) {
+        throw new ASRAuthError(
+          ASR_PROVIDER,
+          `Tencent Flash ASR authentication failed: ${message}`,
+          response.status
+        );
+      }
+      throw new ASRRequestError(
+        ASR_PROVIDER,
+        `Tencent Flash ASR request failed: ${message}`,
+        response.status
+      );
+    }
+    if (payload.code !== 0) {
+      throw new ASRServiceError(
+        ASR_PROVIDER,
+        `Tencent Flash ASR failed: ${payload.message ?? "unknown error"} (code=${payload.code})`,
+        payload.code
+      );
+    }
+    const transcript = extractTranscript(payload);
+    if (!transcript) {
+      throw new ASREmptyResultError(ASR_PROVIDER);
+    }
+    return transcript;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ASRTimeoutError(ASR_PROVIDER, timeoutMs);
+    }
+    if (error instanceof ASRResponseParseError || error instanceof ASRAuthError || error instanceof ASRRequestError || error instanceof ASRServiceError || error instanceof ASREmptyResultError || error instanceof ASRTimeoutError) {
+      throw error;
+    }
+    throw new ASRRequestError(
+      ASR_PROVIDER,
+      `Tencent Flash ASR request failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
 // src/client.ts
 var API_BASE = "https://api.sgroup.qq.com";
 var TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
@@ -5192,7 +5366,8 @@ async function sendGroupMessage(params) {
     messageId: params.messageId,
     markdown: params.markdown
   });
-  return apiPost(params.accessToken, `/v2/groups/${params.groupOpenid}/messages`, body, {
+  const groupOpenidLower = params.groupOpenid.toLowerCase();
+  return apiPost(params.accessToken, `/v2/groups/${groupOpenidLower}/messages`, body, {
     timeout: 15e3
   });
 }
@@ -5201,7 +5376,8 @@ async function sendChannelMessage(params) {
   if (params.messageId) {
     body.msg_id = params.messageId;
   }
-  return apiPost(params.accessToken, `/channels/${params.channelId}/messages`, body, {
+  const channelIdLower = params.channelId.toLowerCase();
+  return apiPost(params.accessToken, `/channels/${channelIdLower}/messages`, body, {
     timeout: 15e3
   });
 }
@@ -5624,6 +5800,9 @@ function parseTextWithAttachments(payload) {
     attachments
   };
 }
+var VOICE_ASR_FALLBACK_TEXT = "\u5F53\u524D\u8BED\u97F3\u529F\u80FD\u672A\u542F\u52A8\u6216\u8BC6\u522B\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+var VOICE_EXTENSIONS = [".silk", ".amr", ".mp3", ".wav", ".ogg", ".m4a", ".aac", ".speex"];
+var VOICE_ASR_ERROR_MAX_LENGTH = 500;
 function isHttpUrl2(value) {
   return /^https?:\/\//i.test(value);
 }
@@ -5641,20 +5820,58 @@ function isImageAttachment(att) {
     return false;
   }
 }
+function isVoiceAttachment(att) {
+  const contentType = att.contentType?.trim().toLowerCase() ?? "";
+  if (contentType === "voice" || contentType.startsWith("audio/")) {
+    return true;
+  }
+  const lowerName = att.filename?.trim().toLowerCase() ?? "";
+  if (VOICE_EXTENSIONS.some((ext) => lowerName.endsWith(ext))) {
+    return true;
+  }
+  try {
+    const pathname = new URL(att.url).pathname.toLowerCase();
+    return VOICE_EXTENSIONS.some((ext) => pathname.endsWith(ext));
+  } catch {
+    return false;
+  }
+}
 function scheduleTempCleanup(filePath) {
   const timer = setTimeout(() => {
     void cleanupFileSafe(filePath);
   }, 20 * 60 * 1e3);
   timer.unref?.();
 }
+function trimTextForReply(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}...`;
+}
+function buildVoiceASRFallbackReply(errorMessage) {
+  const detail = errorMessage?.trim();
+  if (!detail) return VOICE_ASR_FALLBACK_TEXT;
+  return `${VOICE_ASR_FALLBACK_TEXT}
+
+\u63A5\u53E3\u9519\u8BEF\uFF1A${trimTextForReply(detail, VOICE_ASR_ERROR_MAX_LENGTH)}`;
+}
 async function resolveInboundAttachmentsForAgent(params) {
   const { attachments, qqCfg, logger } = params;
   const list = attachments ?? [];
-  if (list.length === 0) return [];
+  if (list.length === 0) {
+    return {
+      attachments: [],
+      hasVoiceAttachment: false,
+      hasVoiceTranscript: false,
+      asrErrorMessage: void 0
+    };
+  }
   const timeout = qqCfg.mediaTimeoutMs ?? 3e4;
   const maxFileSizeMB = qqCfg.maxFileSizeMB ?? 100;
   const maxSize = Math.floor(maxFileSizeMB * 1024 * 1024);
+  const asrCredentials = resolveQQBotASRCredentials(qqCfg);
   const resolved = [];
+  let hasVoiceAttachment = false;
+  let hasVoiceTranscript = false;
+  let asrErrorMessage;
   for (const att of list) {
     const next = { attachment: att };
     if (isImageAttachment(att) && isHttpUrl2(att.url)) {
@@ -5672,15 +5889,66 @@ async function resolveInboundAttachmentsForAgent(params) {
         logger.warn(`failed to download inbound attachment: ${String(err)}`);
       }
     }
+    if (isVoiceAttachment(att)) {
+      hasVoiceAttachment = true;
+      if (!qqCfg.asr?.enabled) {
+        logger.info("voice attachment received but ASR is disabled");
+      } else if (!asrCredentials) {
+        logger.warn("voice ASR enabled but credentials are missing or invalid");
+      } else if (!isHttpUrl2(att.url)) {
+        logger.warn("voice ASR skipped: attachment URL is not an HTTP URL");
+      } else {
+        try {
+          const media = await fetchMediaFromUrl(att.url, {
+            timeout,
+            maxSize
+          });
+          const transcript = await transcribeTencentFlash({
+            audio: media.buffer,
+            config: {
+              appId: asrCredentials.appId,
+              secretId: asrCredentials.secretId,
+              secretKey: asrCredentials.secretKey,
+              timeoutMs: timeout
+            }
+          });
+          if (transcript.trim()) {
+            next.voiceTranscript = transcript.trim();
+            hasVoiceTranscript = true;
+            logger.info(
+              `[voice-asr] transcript: ${next.voiceTranscript}${att.filename ? ` (file: ${att.filename})` : ""}`
+            );
+          }
+        } catch (err) {
+          if (err instanceof ASRError) {
+            logger.warn(
+              `voice ASR failed: kind=${err.kind} provider=${err.provider} retryable=${err.retryable} message=${err.message}`
+            );
+            asrErrorMessage ??= err.message.trim() || void 0;
+          } else {
+            logger.warn(`voice ASR failed: ${String(err)}`);
+          }
+        }
+      }
+    }
     resolved.push(next);
   }
-  return resolved;
+  return {
+    attachments: resolved,
+    hasVoiceAttachment,
+    hasVoiceTranscript,
+    asrErrorMessage
+  };
 }
 function buildInboundContentWithAttachments(params) {
   const { content, attachments } = params;
   const list = attachments ?? [];
   if (list.length === 0) return content;
   const imageRefs = list.map((item) => item.localImagePath).filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => `[Image: source: ${value}]`);
+  const voiceTranscripts = list.filter((item) => typeof item.voiceTranscript === "string" && item.voiceTranscript.trim()).map((item, index) => {
+    const filename = item.attachment.filename?.trim() || `voice-${index + 1}`;
+    return `- ${filename}: ${item.voiceTranscript}`;
+  });
   const lines = list.map((item, index) => {
     const att = item.attachment;
     const filename = att.filename?.trim() ? att.filename.trim() : `attachment-${index + 1}`;
@@ -5692,9 +5960,30 @@ function buildInboundContentWithAttachments(params) {
   const parts = [];
   if (content) parts.push(content);
   if (imageRefs.length > 0) parts.push(imageRefs.join("\n"));
+  if (voiceTranscripts.length > 0) {
+    parts.push(["[QQ voice transcripts]", ...voiceTranscripts].join("\n"));
+  }
   parts.push(block);
   return parts.join("\n\n");
 }
+function resolveInboundLogContent(params) {
+  const text = params.content.trim();
+  if (text) return text;
+  const attachments = params.attachments ?? [];
+  if (attachments.some((att) => isVoiceAttachment(att))) {
+    return "\u3010\u8BED\u97F3\u3011";
+  }
+  if (attachments.some((att) => isImageAttachment(att))) {
+    return "\u3010\u56FE\u7247\u3011";
+  }
+  if (attachments.length > 0) {
+    return "\u3010\u9644\u4EF6\u3011";
+  }
+  return "\u3010\u7A7A\u6D88\u606F\u3011";
+}
+function sanitizeInboundLogText(text) {
+  return text.replace(/\r?\n/g, "\\n");
+}
 function parseC2CMessage(data) {
   const payload = data;
   const { text, attachments } = parseTextWithAttachments(payload);
@@ -5796,7 +6085,7 @@ function resolveInbound(eventType, data) {
 }
 function resolveChatTarget(event) {
   if (event.type === "group") {
-    const group = event.groupOpenid ?? "";
+    const group = (event.groupOpenid ?? "").toLowerCase();
     return {
       to: `group:${group}`,
       peerId: `group:${group}`,
@@ -5804,7 +6093,7 @@ function resolveChatTarget(event) {
     };
   }
   if (event.type === "channel") {
-    const channel = event.channelId ?? "";
+    const channel = (event.channelId ?? "").toLowerCase();
     return {
       to: `channel:${channel}`,
       peerId: `channel:${channel}`,
@@ -5819,10 +6108,10 @@ function resolveChatTarget(event) {
 }
 function resolveEnvelopeFrom(event) {
   if (event.type === "group") {
-    return `group:${event.groupOpenid ?? "unknown"}`;
+    return `group:${(event.groupOpenid ?? "unknown").toLowerCase()}`;
   }
   if (event.type === "channel") {
-    return `channel:${event.channelId ?? "unknown"}`;
+    return `channel:${(event.channelId ?? "unknown").toLowerCase()}`;
   }
   return event.senderName?.trim() || event.senderId;
 }
@@ -5950,11 +6239,24 @@ async function dispatchToAgent(params) {
   );
   const envelopeOptions = replyApi.resolveEnvelopeFormatOptions?.(cfg);
   const previousTimestamp = storePath && sessionApi?.readSessionUpdatedAt ? sessionApi.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey }) : null;
-  const resolvedAttachments = await resolveInboundAttachmentsForAgent({
+  const resolvedAttachmentResult = await resolveInboundAttachmentsForAgent({
     attachments: inbound.attachments,
     qqCfg,
     logger
   });
+  if (qqCfg.asr?.enabled && resolvedAttachmentResult.hasVoiceAttachment && !resolvedAttachmentResult.hasVoiceTranscript) {
+    const fallback = await qqbotOutbound.sendText({
+      cfg: { channels: { qqbot: qqCfg } },
+      to: target.to,
+      text: buildVoiceASRFallbackReply(resolvedAttachmentResult.asrErrorMessage),
+      replyToId: inbound.messageId
+    });
+    if (fallback.error) {
+      logger.error(`sendText ASR fallback failed: ${fallback.error}`);
+    }
+    return;
+  }
+  const resolvedAttachments = resolvedAttachmentResult.attachments;
   const localImageCount = resolvedAttachments.filter((item) => Boolean(item.localImagePath)).length;
   if (localImageCount > 0) {
     logger.info(`prepared ${localImageCount} local image attachment(s) for agent`);
@@ -6213,10 +6515,17 @@ async function handleQQBotDispatch(params) {
     logger.info("qqbot disabled, ignoring inbound message");
     return;
   }
+  const content = inbound.content.trim();
+  const inboundLogContent = sanitizeInboundLogText(
+    resolveInboundLogContent({
+      content,
+      attachments: inbound.attachments
+    })
+  );
+  logger.info(`[inbound-user] senderId=${inbound.senderId} content=${inboundLogContent}`);
   if (!shouldHandleMessage(inbound, qqCfg, logger)) {
     return;
   }
-  const content = inbound.content.trim();
   const attachmentCount = inbound.attachments?.length ?? 0;
   if (attachmentCount > 0) {
     logger.info(`inbound message includes ${attachmentCount} attachment(s)`);
@@ -6593,6 +6902,16 @@ var qqbotPlugin = {
         enabled: { type: "boolean" },
         appId: { type: "string" },
         clientSecret: { type: "string" },
+        asr: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            enabled: { type: "boolean" },
+            appId: { type: "string" },
+            secretId: { type: "string" },
+            secretKey: { type: "string" }
+          }
+        },
         markdownSupport: { type: "boolean" },
         dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
@@ -6709,6 +7028,16 @@ var plugin = {
       enabled: { type: "boolean" },
       appId: { type: "string" },
       clientSecret: { type: "string" },
+      asr: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          enabled: { type: "boolean" },
+          appId: { type: "string" },
+          secretId: { type: "string" },
+          secretKey: { type: "string" }
+        }
+      },
       markdownSupport: { type: "boolean" },
       dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
       groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },