@wu529778790/open-im 1.6.1-beta.13 → 1.6.1-beta.15

package/dist/channels/capabilities.js

@@ -17,7 +17,7 @@ export const CHANNEL_CAPABILITIES = {
     },
     qq: {
         inbound: { text: "native", image: "fallback", file: "fallback", voice: "fallback", video: "fallback" },
-        outbound: { streamEdit: "native", streamPush: "fallback", image: "fallback", card: "fallback", typing: "fallback" },
+        outbound: { streamEdit: "none", streamPush: "none", image: "fallback", card: "fallback", typing: "fallback" },
     },
     wechat: {
         inbound: { text: "native", image: "fallback", file: "fallback", voice: "fallback", video: "fallback" },

package/dist/channels/capabilities.test.js

@@ -8,6 +8,8 @@ describe("channel capabilities", () => {
         expect(CHANNEL_CAPABILITIES.qq.inbound.image).toBe("fallback");
         expect(CHANNEL_CAPABILITIES.qq.inbound.voice).toBe("fallback");
         expect(CHANNEL_CAPABILITIES.qq.inbound.video).toBe("fallback");
+        expect(CHANNEL_CAPABILITIES.qq.outbound.streamEdit).toBe("none");
+        expect(CHANNEL_CAPABILITIES.qq.outbound.streamPush).toBe("none");
         expect(CHANNEL_CAPABILITIES.wechat.inbound.image).toBe("fallback");
         expect(CHANNEL_CAPABILITIES.wework.inbound.video).toBe("fallback");
         expect(CHANNEL_CAPABILITIES.wework.outbound.image).toBe("native");

package/dist/codex/cli-runner.d.ts

@@ -31,4 +31,6 @@ export interface CodexRunOptions {
 export interface CodexRunHandle {
     abort: () => void;
 }
+export declare function extractPromptImagePaths(prompt: string): string[];
+export declare function buildCodexArgs(prompt: string, sessionId: string | undefined, workDir: string, options?: CodexRunOptions): string[];
 export declare function runCodex(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: CodexRunCallbacks, options?: CodexRunOptions): CodexRunHandle;

package/dist/codex/cli-runner.js

@@ -2,7 +2,7 @@
  * Codex CLI runner for `codex exec --json` JSONL output.
  */
 import { execFileSync, spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { createLogger } from '../logger.js';
@@ -10,6 +10,17 @@ const log = createLogger('CodexCli');
 const windowsCodexLaunchCache = new Map();
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+const SUPPORTED_IMAGE_EXTENSIONS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.bmp',
+    '.tif',
+    '.tiff',
+    '.avif',
+]);
 function getIdleTimeoutMs(totalTimeoutMs) {
     const raw = process.env.CODEX_IDLE_TIMEOUT_MS;
     const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
@@ -31,11 +42,42 @@ function parseCodexEvent(line) {
         return null;
     }
 }
-function buildCodexArgs(_prompt, sessionId, workDir, options) {
+function isSupportedImagePath(filePath) {
+    const normalized = filePath.trim();
+    if (!normalized || !existsSync(normalized))
+        return false;
+    const lower = normalized.toLowerCase();
+    return Array.from(SUPPORTED_IMAGE_EXTENSIONS).some((ext) => lower.endsWith(ext));
+}
+export function extractPromptImagePaths(prompt) {
+    const imagePaths = new Set();
+    const lines = prompt.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const singleMatch = /^Saved local file path:\s*(.+)$/i.exec(line);
+        if (singleMatch) {
+            const candidate = singleMatch[1].trim();
+            if (isSupportedImagePath(candidate))
+                imagePaths.add(candidate);
+            continue;
+        }
+        const batchMatch = /^\d+\.\s+(?:.+:\s+)?(.+?)\s+\((image)\)$/i.exec(line);
+        if (batchMatch) {
+            const candidate = batchMatch[1].trim();
+            if (isSupportedImagePath(candidate))
+                imagePaths.add(candidate);
+        }
+    }
+    return Array.from(imagePaths);
+}
+export function buildCodexArgs(prompt, sessionId, workDir, options) {
     const commonOptions = ['--json', '--skip-git-repo-check'];
     const newSessionOptions = [...commonOptions, '--cd', workDir];
     const resumeOptions = [...commonOptions];
     const canResume = Boolean(sessionId) && options?.permissionMode !== 'plan';
+    const imagePaths = extractPromptImagePaths(prompt);
     if (options?.skipPermissions) {
         newSessionOptions.push('--dangerously-bypass-approvals-and-sandbox');
         resumeOptions.push('--dangerously-bypass-approvals-and-sandbox');
@@ -51,6 +93,10 @@ function buildCodexArgs(_prompt, sessionId, workDir, options) {
         newSessionOptions.push('--model', options.model);
         resumeOptions.push('--model', options.model);
     }
+    for (const imagePath of imagePaths) {
+        newSessionOptions.push('--image', imagePath);
+        resumeOptions.push('--image', imagePath);
+    }
     if (sessionId && !canResume) {
         log.warn('Codex plan mode does not support resume; starting a new read-only session');
     }

package/dist/codex/cli-runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codex/cli-runner.test.js

@@ -0,0 +1,53 @@
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { afterEach, describe, expect, it } from 'vitest';
+import { buildCodexArgs, extractPromptImagePaths } from './cli-runner.js';
+const tempDirs = [];
+function createTempImage(name) {
+    const dir = mkdtempSync(join(tmpdir(), 'open-im-codex-test-'));
+    tempDirs.push(dir);
+    const path = join(dir, name);
+    writeFileSync(path, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+    return path;
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('extractPromptImagePaths', () => {
+    it('extracts a single saved image path from a media prompt', () => {
+        const imagePath = createTempImage('single.png');
+        const prompt = [
+            'The user sent a DingTalk image message.',
+            `Saved local file path: ${imagePath}`,
+            'Use the Read tool to inspect the saved file and describe the relevant visual contents before answering.',
+        ].join('\n\n');
+        expect(extractPromptImagePaths(prompt)).toEqual([imagePath]);
+    });
+    it('extracts image items from batch media prompts and ignores non-images', () => {
+        const imagePath = createTempImage('batch.png');
+        const prompt = [
+            'Saved local file paths:',
+            `1. photo: ${imagePath} (image)`,
+            '2. notes.txt (file)',
+        ].join('\n');
+        expect(extractPromptImagePaths(prompt)).toEqual([imagePath]);
+    });
+});
+describe('buildCodexArgs', () => {
+    it('adds image attachments for new sessions', () => {
+        const imagePath = createTempImage('new-session.png');
+        const args = buildCodexArgs(`Saved local file path: ${imagePath}`, undefined, 'D:\\coding\\open-im', {});
+        expect(args).toContain('--image');
+        expect(args).toContain(imagePath);
+    });
+    it('adds image attachments for resumed sessions', () => {
+        const imagePath = createTempImage('resume-session.png');
+        const args = buildCodexArgs(`Saved local file path: ${imagePath}`, 'session-123', 'D:\\coding\\open-im', {});
+        expect(args.slice(0, 2)).toEqual(['exec', 'resume']);
+        expect(args).toContain('--image');
+        expect(args).toContain(imagePath);
+    });
+});

package/dist/dingtalk/client.d.ts

@@ -8,9 +8,15 @@ export interface DingTalkStreamingTarget {
     senderId?: string;
     robotCode?: string;
 }
+export interface DingTalkDownloadedMessageFile {
+    buffer: Buffer;
+    contentType?: string;
+    filename?: string;
+}
 export declare function shouldSuppressDingTalkSocketWarn(args: unknown[]): boolean;
 export declare function registerSessionWebhook(chatId: string, sessionWebhook: string): void;
 export declare function sendText(chatId: string, content: string): Promise<unknown>;
+export declare function downloadRobotMessageFile(downloadCode: string, robotCode: string): Promise<DingTalkDownloadedMessageFile>;
 export declare function sendMarkdown(chatId: string, title: string, text: string): Promise<unknown>;
 export declare function ackMessage(messageId: string, result?: unknown): void;
 export declare function initDingTalk(cfg: Config, eventHandler: (data: DWClientDownStream) => Promise<void>): Promise<void>;

package/dist/dingtalk/client.js

@@ -78,6 +78,68 @@ export async function sendText(chatId, content) {
         text: { content },
     });
 }
+export async function downloadRobotMessageFile(downloadCode, robotCode) {
+    const accessToken = await getClient().getAccessToken();
+    const response = await fetch(`${DINGTALK_OPENAPI_BASE}/v1.0/robot/messageFiles/download`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-acs-dingtalk-access-token': String(accessToken),
+        },
+        body: JSON.stringify({ downloadCode, robotCode }),
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`DingTalk message file download failed: ${response.status} ${text}`);
+    }
+    const contentType = response.headers.get('content-type') ?? undefined;
+    const contentDisposition = response.headers.get('content-disposition') ?? '';
+    const filenameMatch = /filename\*=UTF-8''([^;]+)|filename="?([^\";]+)"?/i.exec(contentDisposition);
+    const filename = filenameMatch?.[1] ?? filenameMatch?.[2];
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (contentType?.includes('application/json')) {
+        let parsed;
+        try {
+            parsed = JSON.parse(buffer.toString('utf8'));
+        }
+        catch {
+            throw new Error(`DingTalk message file download returned JSON payload that could not be parsed`);
+        }
+        const errorCode = parsed.code ?? parsed.errcode ?? parsed.errorcode;
+        if (errorCode !== undefined && errorCode !== 0 && errorCode !== '0') {
+            const message = typeof parsed.message === 'string'
+                ? parsed.message
+                : typeof parsed.errmsg === 'string'
+                    ? parsed.errmsg
+                    : JSON.stringify(parsed);
+            throw new Error(`DingTalk message file download business error: ${String(errorCode)} ${message}`);
+        }
+        const downloadUrl = typeof parsed.downloadUrl === 'string'
+            ? parsed.downloadUrl
+            : typeof parsed.download_url === 'string'
+                ? parsed.download_url
+                : typeof parsed.url === 'string'
+                    ? parsed.url
+                    : undefined;
+        if (!downloadUrl) {
+            throw new Error(`DingTalk message file download returned JSON without binary payload or download URL`);
+        }
+        const redirected = await fetch(downloadUrl, {
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!redirected.ok) {
+            const text = await redirected.text();
+            throw new Error(`DingTalk redirected file download failed: ${redirected.status} ${text}`);
+        }
+        return {
+            buffer: Buffer.from(await redirected.arrayBuffer()),
+            contentType: redirected.headers.get('content-type') ?? undefined,
+            filename,
+        };
+    }
+    return { buffer, contentType, filename };
+}
 export async function sendMarkdown(chatId, title, text) {
     return sendByWebhook(chatId, {
         msgtype: 'markdown',

package/dist/dingtalk/event-handler.js

@@ -1,7 +1,7 @@
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
 import { configureDingTalkMessageSender, sendThinkingMessage, updateMessage, sendFinalMessages, sendErrorMessage, sendTextReply, sendImageReply, startTypingLoop, sendPermissionCard, sendModeCard, sendDirectorySelection, } from './message-sender.js';
-import { ackMessage, registerSessionWebhook } from './client.js';
+import { ackMessage, downloadRobotMessageFile, registerSessionWebhook } from './client.js';
 import { registerPermissionSender } from '../hook/permission-server.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
@@ -14,7 +14,7 @@ import { buildUnsupportedInboundMessage } from '../channels/capabilities.js';
 import { buildMediaMetadataPrompt } from '../shared/media-prompt.js';
 import { buildSavedMediaPrompt } from '../shared/media-analysis-prompt.js';
 import { buildMediaContext } from '../shared/media-context.js';
-import { downloadMediaFromUrl } from '../shared/media-storage.js';
+import { downloadMediaFromUrl, inferExtensionFromBuffer, inferExtensionFromContentType, saveBufferMedia, } from '../shared/media-storage.js';
 const log = createLogger('DingTalkHandler');
 const DINGTALK_THROTTLE_MS = 1000;
 function parseRobotMessage(data) {
@@ -73,7 +73,7 @@ function buildDingTalkMediaContext(text, payload) {
         Duration: duration,
     }, text);
 }
-async function buildMediaPrompt(message, kind) {
+async function buildMediaPrompt(message, kind, robotCodeFallback) {
     const payload = extractMediaPayload(message, kind);
     if (!payload)
         return null;
@@ -85,6 +85,12 @@ async function buildMediaPrompt(message, kind) {
         payload.download_url,
         payload.picUrl,
     ].find((value) => typeof value === 'string' && value.length > 0);
+    const downloadCode = [
+        payload.downloadCode,
+        payload.download_code,
+        payload.pictureDownloadCode,
+        payload.picture_download_code,
+    ].find((value) => typeof value === 'string' && value.length > 0);
     let localPath;
     if (remoteUrl) {
         try {
@@ -97,6 +103,25 @@ async function buildMediaPrompt(message, kind) {
             localPath = undefined;
         }
     }
+    if (!localPath && downloadCode) {
+        try {
+            const robotCode = (typeof message.robotCode === 'string' && message.robotCode.length > 0
+                ? message.robotCode
+                : robotCodeFallback) ?? '';
+            if (robotCode) {
+                const downloaded = await downloadRobotMessageFile(downloadCode, robotCode);
+                const extension = inferExtensionFromContentType(downloaded.contentType ?? '') ||
+                    inferExtensionFromBuffer(downloaded.buffer) ||
+                    (kind === 'image' ? '.jpg' : '.bin');
+                const basenameHint = downloaded.filename ??
+                    (typeof payload.fileName === 'string' ? payload.fileName : undefined);
+                localPath = await saveBufferMedia(downloaded.buffer, extension, basenameHint);
+            }
+        }
+        catch {
+            localPath = undefined;
+        }
+    }
     if (localPath) {
         return buildSavedMediaPrompt({
             source: 'DingTalk',
@@ -221,7 +246,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
         };
         if (message.msgtype !== 'text') {
             const kind = toInboundKind(message.msgtype);
-            const prompt = await buildMediaPrompt(message, kind);
+            const prompt = await buildMediaPrompt(message, kind, config.dingtalkClientId);
             if (!prompt) {
                 await sendTextReply(chatId, buildUnsupportedInboundMessage('dingtalk', kind));
                 ackMessage(callbackId, { ignored: message.msgtype });

package/dist/qq/message-sender.d.ts

@@ -1,8 +1,8 @@
 export declare function sendTextReply(chatId: string, text: string): Promise<void>;
 export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
 export declare function sendThinkingMessage(chatId: string, replyToMessageId?: string, _toolId?: string): Promise<string>;
-export declare function updateMessage(chatId: string, messageId: string, content: string, status: "thinking" | "streaming" | "done" | "error", note?: string, toolId?: string): Promise<void>;
-export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
+export declare function updateMessage(_chatId: string, _messageId: string, _content: string, _status: "thinking" | "streaming" | "done" | "error", _note?: string, _toolId?: string): Promise<void>;
+export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, _note: string, toolId?: string): Promise<void>;
 export declare function sendErrorMessage(chatId: string, messageId: string, error: string, toolId?: string): Promise<void>;
 export declare function sendDirectorySelection(chatId: string, currentDir: string): Promise<void>;
 export declare function sendModeKeyboard(chatId: string, _userId: string, currentMode: string): Promise<void>;

package/dist/qq/message-sender.js

@@ -3,12 +3,10 @@ import { splitLongContent } from "../shared/utils.js";
 import { buildImageFallbackMessage } from "../channels/capabilities.js";
 import { getQQBot } from "./client.js";
 import { buildMessageTitle, OPEN_IM_SYSTEM_TITLE } from "../shared/message-title.js";
-import { buildTextNote } from "../shared/message-note.js";
 import { buildDirectoryMessage, buildModeMessage } from "../shared/system-messages.js";
 const log = createLogger("QQSender");
 const MAX_QQ_MESSAGE_LENGTH = 1500;
-const STREAM_CHUNK_LENGTH = 1200;
-const streamStates = new Map();
+const pendingReplies = new Map();
 function parseChatTarget(chatId) {
     if (chatId.startsWith("group:")) {
         return { kind: "group", id: chatId.slice("group:".length) };
@@ -32,81 +30,6 @@ async function sendRaw(chatId, text, replyToMessageId) {
     }
     return bot.sendPrivateMessage(target.id, text, replyToMessageId);
 }
-function getOrCreateStreamState(messageId, chatId, replyToMessageId) {
-    const existing = streamStates.get(messageId);
-    if (existing)
-        return existing;
-    const state = {
-        chatId,
-        replyToMessageId,
-        lastSentLength: 0,
-        sentStreamChunk: false,
-        pendingText: "",
-    };
-    streamStates.set(messageId, state);
-    return state;
-}
-function buildStreamChunk(toolId, content, note, withHeader = false) {
-    const header = withHeader ? buildMessageTitle(toolId, "streaming") : "";
-    const noteBlock = note ? `\n\n${buildTextNote(note)}` : "";
-    return `${header}${header ? "\n" : ""}${content}${noteBlock}`.trim();
-}
-function findPreferredSplit(text, limit) {
-    const normalizedLimit = Math.min(text.length, limit);
-    const boundaries = ["\n\n", "\n", "。", "，", "；", ". ", "! ", "? ", ", ", " "];
-    const minimumUsefulSplit = Math.min(80, Math.floor(normalizedLimit / 3));
-    for (const boundary of boundaries) {
-        const index = text.lastIndexOf(boundary, normalizedLimit);
-        if (index >= minimumUsefulSplit) {
-            return index + boundary.length;
-        }
-    }
-    if (text.length >= minimumUsefulSplit) {
-        return normalizedLimit;
-    }
-    return 0;
-}
-function resetStreamState(state) {
-    state.lastSentLength = 0;
-    state.lastToolNote = undefined;
-    state.pendingText = "";
-    state.sentStreamChunk = false;
-}
-async function sendIncrementalContent(state, toolId, content, note, flushAll = false) {
-    if (!flushAll && content.length < state.lastSentLength) {
-        resetStreamState(state);
-    }
-    const delta = content.slice(state.lastSentLength);
-    const hasNewNote = !!note && note !== state.lastToolNote;
-    if (!delta && !hasNewNote)
-        return;
-    if (delta) {
-        state.pendingText += delta;
-        let noteSent = false;
-        while (state.pendingText.length > 0) {
-            const splitAt = flushAll
-                ? Math.min(state.pendingText.length, STREAM_CHUNK_LENGTH)
-                : findPreferredSplit(state.pendingText, STREAM_CHUNK_LENGTH);
-            if (splitAt <= 0)
-                break;
-            const part = state.pendingText.slice(0, splitAt).trim();
-            state.pendingText = state.pendingText.slice(splitAt).trimStart();
-            if (!part)
-                continue;
-            const text = buildStreamChunk(toolId, part, state.pendingText.length === 0 && hasNewNote ? note : undefined, !state.sentStreamChunk);
-            await sendRaw(state.chatId, text, state.replyToMessageId);
-            if (state.pendingText.length === 0 && hasNewNote)
-                noteSent = true;
-            state.sentStreamChunk = true;
-        }
-        state.lastSentLength = content.length;
-        if (noteSent)
-            state.lastToolNote = note;
-        return;
-    }
-    await sendRaw(state.chatId, `[${toolId}] ${note}`, state.replyToMessageId);
-    state.lastToolNote = note;
-}
 export async function sendTextReply(chatId, text) {
     try {
         const formatted = `${buildMessageTitle(OPEN_IM_SYSTEM_TITLE, "done")}\n\n${text}`;
@@ -122,36 +45,24 @@ export async function sendImageReply(chatId, imagePath) {
     await sendTextReply(chatId, buildImageFallbackMessage("qq", imagePath));
 }
 export async function sendThinkingMessage(chatId, replyToMessageId, _toolId = "claude") {
-    const messageId = `${Date.now()}`;
-    getOrCreateStreamState(messageId, chatId, replyToMessageId);
+    const messageId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    pendingReplies.set(messageId, { replyToMessageId });
     return messageId;
 }
-export async function updateMessage(chatId, messageId, content, status, note, toolId = "claude") {
-    if (status !== "streaming" && status !== "thinking")
-        return;
-    const state = getOrCreateStreamState(messageId, chatId);
-    await sendIncrementalContent(state, toolId, content, note);
+export async function updateMessage(_chatId, _messageId, _content, _status, _note, _toolId = "claude") {
+    // QQ 官方机器人接口不支持单条消息流式更新，这里显式忽略中间增量，只发送最终结果。
 }
-export async function sendFinalMessages(chatId, messageId, fullContent, note, toolId = "claude") {
-    const state = getOrCreateStreamState(messageId, chatId);
-    if (state.sentStreamChunk && fullContent.length === state.lastSentLength) {
-        streamStates.delete(messageId);
-        return;
-    }
-    await sendIncrementalContent(state, toolId, fullContent, note || undefined, true);
-    if (!state.sentStreamChunk) {
-        const completionText = note
-            ? buildStreamChunk(toolId, fullContent, note, true)
-            : `${buildMessageTitle(toolId, "done")}\n${fullContent}`;
-        for (const part of splitLongContent(completionText, MAX_QQ_MESSAGE_LENGTH)) {
-            await sendRaw(chatId, part, state.replyToMessageId);
-        }
+export async function sendFinalMessages(chatId, messageId, fullContent, _note, toolId = "claude") {
+    const replyToMessageId = pendingReplies.get(messageId)?.replyToMessageId;
+    pendingReplies.delete(messageId);
+    const completionText = `${buildMessageTitle(toolId, "done")}\n${fullContent}`;
+    for (const part of splitLongContent(completionText, MAX_QQ_MESSAGE_LENGTH)) {
+        await sendRaw(chatId, part, replyToMessageId);
     }
-    streamStates.delete(messageId);
 }
 export async function sendErrorMessage(chatId, messageId, error, toolId = "claude") {
-    const replyToMessageId = streamStates.get(messageId)?.replyToMessageId;
-    streamStates.delete(messageId);
+    const replyToMessageId = pendingReplies.get(messageId)?.replyToMessageId;
+    pendingReplies.delete(messageId);
     await sendRaw(chatId, `${buildMessageTitle(toolId, "error")}\n${error}`, replyToMessageId);
 }
 export async function sendDirectorySelection(chatId, currentDir) {

package/dist/qq/message-sender.test.js

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 const sendPrivateMessageMock = vi.fn();
 const sendGroupMessageMock = vi.fn();
 const sendChannelMessageMock = vi.fn();
@@ -11,10 +11,17 @@ vi.mock("./client.js", () => ({
 }));
 describe("QQ message sender", () => {
     beforeEach(() => {
+        vi.useFakeTimers();
         vi.resetModules();
         sendPrivateMessageMock.mockReset();
         sendGroupMessageMock.mockReset();
         sendChannelMessageMock.mockReset();
+        sendPrivateMessageMock.mockResolvedValue(undefined);
+        sendGroupMessageMock.mockResolvedValue(undefined);
+        sendChannelMessageMock.mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
     });
     it("routes image replies through the fallback text sender", async () => {
         const sender = await import("./message-sender.js");
@@ -24,21 +31,16 @@ describe("QQ message sender", () => {
         expect(sendGroupMessageMock.mock.calls[0][1]).toContain("open-im");
         expect(sendGroupMessageMock.mock.calls[0][1]).toContain("C:\\images\\out.png");
     });
-    it("does not send a second completion message after streaming the full reply", async () => {
+    it("ignores intermediate stream updates and sends only the final reply", async () => {
         const sender = await import("./message-sender.js");
         const messageId = await sender.sendThinkingMessage("private:user-1", "reply-1", "codex");
-        await sender.updateMessage("private:user-1", messageId, "第一段回复", "streaming", undefined, "codex");
-        await sender.sendFinalMessages("private:user-1", messageId, "第一段回复", "耗时 1.2s", "codex");
+        await sender.updateMessage("private:user-1", messageId, "第一段", "streaming", undefined, "codex");
+        await sender.updateMessage("private:user-1", messageId, "第一段\n第二段", "streaming", "耗时 1.2s", "codex");
+        await sender.sendFinalMessages("private:user-1", messageId, "最终答案", "耗时 1.2s", "codex");
         expect(sendPrivateMessageMock).toHaveBeenCalledTimes(1);
-        expect(sendPrivateMessageMock.mock.calls[0][1]).toContain("第一段回复");
-        expect(sendPrivateMessageMock.mock.calls[0][1]).not.toContain("耗时 1.2s");
-    });
-    it("resets the stream when content switches from a longer draft to a shorter answer", async () => {
-        const sender = await import("./message-sender.js");
-        const messageId = await sender.sendThinkingMessage("private:user-1", undefined, "codex");
-        await sender.updateMessage("private:user-1", messageId, "这是比较长的前置内容，用来模拟思考流。", "streaming", undefined, "codex");
-        await sender.updateMessage("private:user-1", messageId, "短答案", "streaming", undefined, "codex");
-        expect(sendPrivateMessageMock).toHaveBeenCalledTimes(2);
-        expect(sendPrivateMessageMock.mock.calls[1][1]).toContain("短答案");
+        expect(sendPrivateMessageMock.mock.calls[0][0]).toBe("user-1");
+        expect(sendPrivateMessageMock.mock.calls[0][1]).toContain("最终答案");
+        expect(sendPrivateMessageMock.mock.calls[0][1]).not.toContain("第一段");
+        expect(sendPrivateMessageMock.mock.calls[0][2]).toBe("reply-1");
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.6.1-beta.13",
+  "version": "1.6.1-beta.15",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",