fix(qqbot): chunk c2c byte-source media uploads

zhangguiping-xydt · zhangguiping-xydt · commit bb99be49207f · 2026-06-14T01:54:59.000+08:00
diff --git a/extensions/qqbot/src/engine/messaging/sender.test.ts b/extensions/qqbot/src/engine/messaging/sender.test.ts
@@ -1,8 +1,12 @@
 // Qqbot tests cover unified sender behavior.
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { ChunkedMediaApi } from "../api/media-chunked.js";
 import { MediaApi } from "../api/media.js";
 import { MediaFileType, type MessageResponse, type UploadMediaResponse } from "../types.js";
+import type { RawMediaSource } from "./media-source.js";
 import { registerAccount, sendMedia } from "./sender.js";
 
 const fetchWithSsrFGuardMock = vi.hoisted(() => vi.fn());
@@ -43,6 +47,16 @@ const logger = {
   debug: vi.fn(),
 };
 
+const tempDirs: string[] = [];
+
+async function createLocalMediaFile(name: string, bytes: Buffer): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "qqbot-sender-test-"));
+  tempDirs.push(dir);
+  const filePath = join(dir, name);
+  await writeFile(filePath, bytes);
+  return filePath;
+}
+
 function mockGuardedDownload(): void {
   fetchWithSsrFGuardMock.mockResolvedValueOnce({
     response: new Response(MEDIA_BYTES),
@@ -62,6 +76,10 @@ describe("qqbot unified sender media upload dispatch", () => {
     logger.debug.mockReset();
   });
 
+  afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+  });
+
   it.each([
     {
       label: "image",
@@ -134,4 +152,82 @@ describe("qqbot unified sender media upload dispatch", () => {
       });
     },
   );
+
+  it.each([
+    {
+      label: "base64",
+      source: async (): Promise<RawMediaSource> => ({ base64: MEDIA_BYTES.toString("base64") }),
+      expectedSource: { kind: "buffer" as const, buffer: Buffer.from(MEDIA_BYTES) },
+    },
+    {
+      label: "buffer",
+      source: async (): Promise<RawMediaSource> => ({
+        buffer: Buffer.from(MEDIA_BYTES),
+        fileName: "buffer-proof.png",
+      }),
+      expectedSource: {
+        kind: "buffer" as const,
+        buffer: Buffer.from(MEDIA_BYTES),
+        fileName: "buffer-proof.png",
+      },
+    },
+    {
+      label: "localPath",
+      source: async (): Promise<RawMediaSource> => ({
+        localPath: await createLocalMediaFile("local-proof.png", MEDIA_BYTES),
+      }),
+      expectedSource: { kind: "localPath" as const },
+    },
+  ])(
+    "uploads C2C image $label byte sources through chunked upload instead of one-shot file_data",
+    async ({ source, expectedSource }) => {
+      const uploadMediaSpy = vi
+        .spyOn(MediaApi.prototype, "uploadMedia")
+        .mockResolvedValue(UPLOAD_RESPONSE);
+      const uploadChunkedSpy = vi
+        .spyOn(ChunkedMediaApi.prototype, "uploadChunked")
+        .mockResolvedValue(UPLOAD_RESPONSE);
+      vi.spyOn(MediaApi.prototype, "sendMediaMessage").mockResolvedValue(MESSAGE_RESPONSE);
+      const appId = `sender-test-${expectedSource.kind}`;
+      const creds = { appId, clientSecret: "client-secret" };
+      registerAccount(appId, { logger });
+
+      const result = await sendMedia({
+        target: { type: "c2c", id: "user-openid" },
+        creds,
+        kind: "image",
+        source: await source(),
+        content: "caption",
+      });
+
+      expect(result).toBe(MESSAGE_RESPONSE);
+      expect(uploadMediaSpy).not.toHaveBeenCalled();
+      expect(uploadChunkedSpy).toHaveBeenCalledOnce();
+      expect(uploadChunkedSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          scope: "c2c",
+          targetId: "user-openid",
+          fileType: MediaFileType.IMAGE,
+          creds,
+        }),
+      );
+      const chunkedSource = uploadChunkedSpy.mock.calls[0]?.[0]?.source;
+      expect(chunkedSource?.kind).toBe(expectedSource.kind);
+      if (expectedSource.kind === "buffer") {
+        expect(chunkedSource).toMatchObject({
+          kind: "buffer",
+          fileName: expectedSource.fileName,
+        });
+        expect(chunkedSource?.kind === "buffer" ? chunkedSource.buffer : undefined).toEqual(
+          expectedSource.buffer,
+        );
+      }
+      if (expectedSource.kind === "localPath") {
+        expect(chunkedSource).toMatchObject({
+          kind: "localPath",
+          size: MEDIA_BYTES.length,
+        });
+      }
+    },
+  );
 });
diff --git a/extensions/qqbot/src/engine/messaging/sender.ts b/extensions/qqbot/src/engine/messaging/sender.ts
@@ -634,6 +634,10 @@ async function sendMediaInternal(
   }
 }
 
+function requiresC2CChunkedUpload(scope: ChatScope, fileType: MediaFileType): boolean {
+  return scope === "c2c" && (fileType === MediaFileType.IMAGE || fileType === MediaFileType.FILE);
+}
+
 async function dispatchUpload(
   ctx: AccountContext,
   scope: ChatScope,
@@ -648,10 +652,7 @@ async function dispatchUpload(
       const buffer = await downloadDirectUploadUrl(source.url, {
         maxBytes: getMaxUploadSize(fileType),
       });
-      if (
-        scope === "c2c" &&
-        (fileType === MediaFileType.IMAGE || fileType === MediaFileType.FILE)
-      ) {
+      if (requiresC2CChunkedUpload(scope, fileType)) {
         return ctx.chunkedMediaApi.uploadChunked({
           scope,
           targetId,
@@ -677,12 +678,22 @@ async function dispatchUpload(
       });
     }
     case "base64":
+      if (requiresC2CChunkedUpload(scope, fileType)) {
+        return ctx.chunkedMediaApi.uploadChunked({
+          scope,
+          targetId,
+          fileType,
+          source: { kind: "buffer", buffer: Buffer.from(source.data, "base64"), fileName },
+          creds,
+          fileName,
+        });
+      }
       return ctx.mediaApi.uploadMedia(scope, targetId, fileType, creds, {
         fileData: source.data,
         fileName,
       });
     case "localPath":
-      if (source.size >= LARGE_FILE_THRESHOLD) {
+      if (requiresC2CChunkedUpload(scope, fileType) || source.size >= LARGE_FILE_THRESHOLD) {
         return ctx.chunkedMediaApi.uploadChunked({
           scope,
           targetId,
@@ -703,7 +714,10 @@ async function dispatchUpload(
         fileName,
       });
     case "buffer":
-      if (source.buffer.length >= LARGE_FILE_THRESHOLD) {
+      if (
+        requiresC2CChunkedUpload(scope, fileType) ||
+        source.buffer.length >= LARGE_FILE_THRESHOLD
+      ) {
         return ctx.chunkedMediaApi.uploadChunked({
           scope,
           targetId,
