openclaw-threema 0.6.3 → 0.6.5

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.6.5 (2026-05-04)
+
+### Added
+- **Voice-Reply Function**: Threema plugin now supports sending voice notes (audio messages).
+  - New `sendVoiceNote(toId, audioBuffer, mimeType, caption)` method on ThreemaClient for E2E encrypted voice messages.
+  - When agent reply contains `audioAsVoice: true` with a `mediaUrl` (e.g., TTS or Whisper output), the plugin automatically sends it as a voice message instead of text.
+  - Audio detection works in both text-inbound and file-inbound reply pipelines.
+  - Fallback to text mode when audio file not found or when E2E mode is disabled (voice notes require E2E).
+  - Supports multiple audio MIME types: audio/aac, audio/mpeg, audio/wav, audio/ogg, audio/m4a, audio/webm.
+  - Error handling: logs errors and gracefully falls back to text delivery if voice send fails.
+
+## 0.6.4 (2026-05-04)
+
+### Fixed
+- v0.6.3 introduced a regression where file inbounds always fell back to
+  the legacy `enqueueSystemEvent` path. The new pipeline branch was
+  trying to call a non-existent `channelRuntime.reply.resolveDirectSession-
+  Key`. The text path doesn't use that helper at all; it uses
+  `channelRuntime.routing.resolveAgentRoute` + `buildAgentSessionKey`.
+  This release applies the same approach to the file path, so file
+  inbounds finally land in the live Threema DM session.
+- Symptom: `Threema file inbound pipeline error: channelRuntime.reply.
+  resolveDirectSessionKey is not a function` followed by
+  `dispatched via enqueueSystemEvent (fallback)` for every file message.
+
 ## 0.6.3 (2026-05-04)
 
 ### Fixed

package/dist/index.js

@@ -327,6 +327,79 @@ class ThreemaClient {
         const decrypted = nacl.secretbox.open(encryptedBlob, nonce, key);
         return decrypted || null;
     }
+    /**
+     * Send a voice note message (audio file with voice message rendering type).
+     * Type 0x17 file message with j=1 (media rendering) and audio MIME type.
+     * Suitable for Whisper transcriptions or agent-generated TTS audio.
+     */
+    async sendVoiceNote(to, audioBuffer, mimeType = "audio/aac", caption) {
+        if (!this.privateKey) {
+            throw new Error("E2E mode requires privateKey configuration");
+        }
+        const recipientPubKey = await this.getPublicKey(to);
+        // Generate random symmetric key for file encryption
+        const fileKey = nacl.randomBytes(32);
+        // Threema FILE_NONCE: 23 zero bytes + 0x01
+        const fileNonce = new Uint8Array(24);
+        fileNonce[23] = 0x01;
+        // Encrypt the audio with secretbox
+        const encryptedAudio = nacl.secretbox(new Uint8Array(audioBuffer), fileNonce, fileKey);
+        // Upload encrypted blob
+        const blobId = await this.uploadBlob(encryptedAudio);
+        // Create file message JSON for voice note
+        // j=1 marks it as media (voice message bubble in UI)
+        const fileMsg = {
+            b: blobId,
+            k: bytesToHex(fileKey),
+            m: mimeType,
+            n: `voice.${this.getMimeExtension(mimeType)}`,
+            s: audioBuffer.length,
+            j: 1, // 1 = render as media (voice message bubble)
+            i: 1, // deprecated but needed for older clients
+        };
+        if (caption) {
+            fileMsg.d = caption;
+        }
+        const fileMsgJson = JSON.stringify(fileMsg);
+        const fileMsgBytes = decodeUTF8(fileMsgJson);
+        // Create E2E payload (type 0x17 = file message)
+        const payload = buildE2EPayload(0x17, fileMsgBytes);
+        // Generate nonce and encrypt with NaCl box
+        const nonce = nacl.randomBytes(24);
+        const box = nacl.box(payload, nonce, recipientPubKey, this.privateKey);
+        const params = new URLSearchParams({
+            from: this.gatewayId,
+            to,
+            nonce: bytesToHex(nonce),
+            box: bytesToHex(box),
+            secret: this.secretKey,
+        });
+        const url = `${THREEMA_API_BASE}/send_e2e`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: params.toString(),
+        });
+        if (!res.ok) {
+            // Don't log response body (may contain secrets)
+            throw new Error(`Threema E2E API error ${res.status}`);
+        }
+        return res.text();
+    }
+    /**
+     * Get file extension for MIME type
+     */
+    getMimeExtension(mimeType) {
+        const mimeMap = {
+            "audio/aac": "aac",
+            "audio/mpeg": "mp3",
+            "audio/wav": "wav",
+            "audio/ogg": "ogg",
+            "audio/m4a": "m4a",
+            "audio/webm": "webm",
+        };
+        return mimeMap[mimeType.toLowerCase()] || "m4a";
+    }
     /**
      * Send a text message (Basic mode - server-side encryption)
      */
@@ -1554,40 +1627,89 @@ export default function register(api) {
                                     cfg: currentCfg,
                                     dispatcherOptions: {
                                         deliver: async (payload) => {
-                                            const text = payload.text ?? payload.body;
-                                            if (!text)
-                                                return;
-                                            // Chunk long replies if needed
-                                            const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
-                                            if (text.length <= limit) {
-                                                if (replyClient.isE2EEnabled) {
-                                                    await replyClient.sendE2E(from, text);
+                                            // Check if reply contains audio that should be sent as voice note
+                                            const isAudioAsVoice = payload.audioAsVoice === true && payload.mediaUrl;
+                                            if (isAudioAsVoice && payload.mediaUrl) {
+                                                // Send as voice note
+                                                try {
+                                                    if (replyClient.isE2EEnabled) {
+                                                        // Load audio from mediaUrl and send via sendVoiceNote
+                                                        const audioPath = payload.mediaUrl;
+                                                        if (fs.existsSync(audioPath)) {
+                                                            const audioBuffer = fs.readFileSync(audioPath);
+                                                            const mimeType = payload.mediaMimeType ?? "audio/aac";
+                                                            const caption = payload.text ?? payload.body ?? undefined;
+                                                            await replyClient.sendVoiceNote(from, audioBuffer, mimeType, caption);
+                                                        }
+                                                        else {
+                                                            api.logger?.warn?.(`Threema: audio file not found at ${audioPath}, falling back to text`);
+                                                            // Fallback to text if audio file not found
+                                                            const text = payload.text ?? payload.body;
+                                                            if (text) {
+                                                                await replyClient.sendE2E(from, text);
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        // Voice notes only work in E2E mode; fallback to text in basic mode
+                                                        api.logger?.info?.(`Threema: voice notes require E2E mode, sending text instead`);
+                                                        const text = payload.text ?? payload.body;
+                                                        if (text) {
+                                                            await replyClient.sendSimple(from, text);
+                                                        }
+                                                    }
                                                 }
-                                                else {
-                                                    await replyClient.sendSimple(from, text);
+                                                catch (audioErr) {
+                                                    api.logger?.error?.(`Threema: error sending voice note: ${audioErr.message}`);
+                                                    // Fallback to text on error
+                                                    const text = payload.text ?? payload.body;
+                                                    if (text) {
+                                                        if (replyClient.isE2EEnabled) {
+                                                            await replyClient.sendE2E(from, text);
+                                                        }
+                                                        else {
+                                                            await replyClient.sendSimple(from, text);
+                                                        }
+                                                    }
                                                 }
                                             }
                                             else {
-                                                // Split into chunks at newline boundaries
-                                                const chunks = [];
-                                                let remaining = text;
-                                                while (remaining.length > 0) {
-                                                    if (remaining.length <= limit) {
-                                                        chunks.push(remaining);
-                                                        break;
-                                                    }
-                                                    let splitIdx = remaining.lastIndexOf("\n", limit);
-                                                    if (splitIdx <= 0)
-                                                        splitIdx = limit;
-                                                    chunks.push(remaining.slice(0, splitIdx));
-                                                    remaining = remaining.slice(splitIdx).replace(/^\n/, "");
-                                                }
-                                                for (const chunk of chunks) {
+                                                // Send as text (existing logic)
+                                                const text = payload.text ?? payload.body;
+                                                if (!text)
+                                                    return;
+                                                // Chunk long replies if needed
+                                                const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
+                                                if (text.length <= limit) {
                                                     if (replyClient.isE2EEnabled) {
-                                                        await replyClient.sendE2E(from, chunk);
+                                                        await replyClient.sendE2E(from, text);
                                                     }
                                                     else {
-                                                        await replyClient.sendSimple(from, chunk);
+                                                        await replyClient.sendSimple(from, text);
+                                                    }
+                                                }
+                                                else {
+                                                    // Split into chunks at newline boundaries
+                                                    const chunks = [];
+                                                    let remaining = text;
+                                                    while (remaining.length > 0) {
+                                                        if (remaining.length <= limit) {
+                                                            chunks.push(remaining);
+                                                            break;
+                                                        }
+                                                        let splitIdx = remaining.lastIndexOf("\n", limit);
+                                                        if (splitIdx <= 0)
+                                                            splitIdx = limit;
+                                                        chunks.push(remaining.slice(0, splitIdx));
+                                                        remaining = remaining.slice(splitIdx).replace(/^\n/, "");
+                                                    }
+                                                    for (const chunk of chunks) {
+                                                        if (replyClient.isE2EEnabled) {
+                                                            await replyClient.sendE2E(from, chunk);
+                                                        }
+                                                        else {
+                                                            await replyClient.sendSimple(from, chunk);
+                                                        }
                                                     }
                                                 }
                                             }
@@ -1677,11 +1799,22 @@ export default function register(api) {
                         // session, runs the agent in-context, and lets us reply via
                         // dispatchReplyWithBufferedBlockDispatcher just like text.
                         const channelRuntime = runtime?.channel;
-                        if (channelRuntime?.reply?.finalizeInboundContext
+                        if (channelRuntime?.routing?.resolveAgentRoute
+                            && channelRuntime?.routing?.buildAgentSessionKey
+                            && channelRuntime?.reply?.finalizeInboundContext
                             && channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
                             try {
                                 const currentCfg = runtime.config.loadConfig();
-                                const sessionKey = channelRuntime.reply.resolveDirectSessionKey({
+                                // Resolve the same agent route + session key the text path uses
+                                // so file inbounds end up in the live Threema DM session.
+                                const route = channelRuntime.routing.resolveAgentRoute({
+                                    cfg: currentCfg,
+                                    channel: "threema",
+                                    accountId: "default",
+                                    peer: { kind: "direct", id: from },
+                                });
+                                const sessionKey = channelRuntime.routing.buildAgentSessionKey({
+                                    agentId: route.agentId,
                                     channel: "threema",
                                     accountId: "default",
                                     peer: { kind: "direct", id: from },
@@ -1719,38 +1852,87 @@ export default function register(api) {
                                     cfg: currentCfg,
                                     dispatcherOptions: {
                                         deliver: async (payload) => {
-                                            const text = payload.text ?? payload.body;
-                                            if (!text)
-                                                return;
-                                            const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
-                                            if (text.length <= limit) {
-                                                if (replyClient.isE2EEnabled) {
-                                                    await replyClient.sendE2E(from, text);
+                                            // Check if reply contains audio that should be sent as voice note
+                                            const isAudioAsVoice = payload.audioAsVoice === true && payload.mediaUrl;
+                                            if (isAudioAsVoice && payload.mediaUrl) {
+                                                // Send as voice note
+                                                try {
+                                                    if (replyClient.isE2EEnabled) {
+                                                        // Load audio from mediaUrl and send via sendVoiceNote
+                                                        const audioPath = payload.mediaUrl;
+                                                        if (fs.existsSync(audioPath)) {
+                                                            const audioBuffer = fs.readFileSync(audioPath);
+                                                            const mimeType = payload.mediaMimeType ?? "audio/aac";
+                                                            const caption = payload.text ?? payload.body ?? undefined;
+                                                            await replyClient.sendVoiceNote(from, audioBuffer, mimeType, caption);
+                                                        }
+                                                        else {
+                                                            api.logger?.warn?.(`Threema: audio file not found at ${audioPath}, falling back to text`);
+                                                            // Fallback to text if audio file not found
+                                                            const text = payload.text ?? payload.body;
+                                                            if (text) {
+                                                                await replyClient.sendE2E(from, text);
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        // Voice notes only work in E2E mode; fallback to text in basic mode
+                                                        api.logger?.info?.(`Threema: voice notes require E2E mode, sending text instead`);
+                                                        const text = payload.text ?? payload.body;
+                                                        if (text) {
+                                                            await replyClient.sendSimple(from, text);
+                                                        }
+                                                    }
                                                 }
-                                                else {
-                                                    await replyClient.sendSimple(from, text);
+                                                catch (audioErr) {
+                                                    api.logger?.error?.(`Threema: error sending voice note: ${audioErr.message}`);
+                                                    // Fallback to text on error
+                                                    const text = payload.text ?? payload.body;
+                                                    if (text) {
+                                                        if (replyClient.isE2EEnabled) {
+                                                            await replyClient.sendE2E(from, text);
+                                                        }
+                                                        else {
+                                                            await replyClient.sendSimple(from, text);
+                                                        }
+                                                    }
                                                 }
                                             }
                                             else {
-                                                const chunks = [];
-                                                let remaining = text;
-                                                while (remaining.length > 0) {
-                                                    if (remaining.length <= limit) {
-                                                        chunks.push(remaining);
-                                                        break;
-                                                    }
-                                                    let splitIdx = remaining.lastIndexOf("\n", limit);
-                                                    if (splitIdx <= 0)
-                                                        splitIdx = limit;
-                                                    chunks.push(remaining.slice(0, splitIdx));
-                                                    remaining = remaining.slice(splitIdx).replace(/^\n/, "");
-                                                }
-                                                for (const chunk of chunks) {
+                                                // Send as text (existing logic)
+                                                const text = payload.text ?? payload.body;
+                                                if (!text)
+                                                    return;
+                                                const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
+                                                if (text.length <= limit) {
                                                     if (replyClient.isE2EEnabled) {
-                                                        await replyClient.sendE2E(from, chunk);
+                                                        await replyClient.sendE2E(from, text);
                                                     }
                                                     else {
-                                                        await replyClient.sendSimple(from, chunk);
+                                                        await replyClient.sendSimple(from, text);
+                                                    }
+                                                }
+                                                else {
+                                                    const chunks = [];
+                                                    let remaining = text;
+                                                    while (remaining.length > 0) {
+                                                        if (remaining.length <= limit) {
+                                                            chunks.push(remaining);
+                                                            break;
+                                                        }
+                                                        let splitIdx = remaining.lastIndexOf("\n", limit);
+                                                        if (splitIdx <= 0)
+                                                            splitIdx = limit;
+                                                        chunks.push(remaining.slice(0, splitIdx));
+                                                        remaining = remaining.slice(splitIdx).replace(/^\n/, "");
+                                                    }
+                                                    for (const chunk of chunks) {
+                                                        if (replyClient.isE2EEnabled) {
+                                                            await replyClient.sendE2E(from, chunk);
+                                                        }
+                                                        else {
+                                                            await replyClient.sendSimple(from, chunk);
+                                                        }
                                                     }
                                                 }
                                             }

package/index.ts

@@ -525,6 +525,98 @@ class ThreemaClient {
     return decrypted || null;
   }
 
+  /**
+   * Send a voice note message (audio file with voice message rendering type).
+   * Type 0x17 file message with j=1 (media rendering) and audio MIME type.
+   * Suitable for Whisper transcriptions or agent-generated TTS audio.
+   */
+  async sendVoiceNote(
+    to: string,
+    audioBuffer: Buffer,
+    mimeType: string = "audio/aac",
+    caption?: string
+  ): Promise<string> {
+    if (!this.privateKey) {
+      throw new Error("E2E mode requires privateKey configuration");
+    }
+
+    const recipientPubKey = await this.getPublicKey(to);
+
+    // Generate random symmetric key for file encryption
+    const fileKey = nacl.randomBytes(32);
+    // Threema FILE_NONCE: 23 zero bytes + 0x01
+    const fileNonce = new Uint8Array(24);
+    fileNonce[23] = 0x01;
+
+    // Encrypt the audio with secretbox
+    const encryptedAudio = nacl.secretbox(new Uint8Array(audioBuffer), fileNonce, fileKey);
+
+    // Upload encrypted blob
+    const blobId = await this.uploadBlob(encryptedAudio);
+
+    // Create file message JSON for voice note
+    // j=1 marks it as media (voice message bubble in UI)
+    const fileMsg: ThreemaFileMessage = {
+      b: blobId,
+      k: bytesToHex(fileKey),
+      m: mimeType,
+      n: `voice.${this.getMimeExtension(mimeType)}`,
+      s: audioBuffer.length,
+      j: 1,  // 1 = render as media (voice message bubble)
+      i: 1,  // deprecated but needed for older clients
+    };
+    if (caption) {
+      fileMsg.d = caption;
+    }
+
+    const fileMsgJson = JSON.stringify(fileMsg);
+    const fileMsgBytes = decodeUTF8(fileMsgJson);
+
+    // Create E2E payload (type 0x17 = file message)
+    const payload = buildE2EPayload(0x17, fileMsgBytes);
+
+    // Generate nonce and encrypt with NaCl box
+    const nonce = nacl.randomBytes(24);
+    const box = nacl.box(payload, nonce, recipientPubKey, this.privateKey);
+
+    const params = new URLSearchParams({
+      from: this.gatewayId,
+      to,
+      nonce: bytesToHex(nonce),
+      box: bytesToHex(box),
+      secret: this.secretKey,
+    });
+
+    const url = `${THREEMA_API_BASE}/send_e2e`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: params.toString(),
+    });
+
+    if (!res.ok) {
+      // Don't log response body (may contain secrets)
+      throw new Error(`Threema E2E API error ${res.status}`);
+    }
+
+    return res.text();
+  }
+
+  /**
+   * Get file extension for MIME type
+   */
+  private getMimeExtension(mimeType: string): string {
+    const mimeMap: Record<string, string> = {
+      "audio/aac": "aac",
+      "audio/mpeg": "mp3",
+      "audio/wav": "wav",
+      "audio/ogg": "ogg",
+      "audio/m4a": "m4a",
+      "audio/webm": "webm",
+    };
+    return mimeMap[mimeType.toLowerCase()] || "m4a";
+  }
+
   /**
    * Send a text message (Basic mode - server-side encryption)
    */
@@ -2000,35 +2092,80 @@ export default function register(api: any) {
                   cfg: currentCfg,
                   dispatcherOptions: {
                     deliver: async (payload: any) => {
-                      const text = payload.text ?? payload.body;
-                      if (!text) return;
-                      // Chunk long replies if needed
-                      const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
-                      if (text.length <= limit) {
-                        if (replyClient.isE2EEnabled) {
-                          await replyClient.sendE2E(from, text);
-                        } else {
-                          await replyClient.sendSimple(from, text);
-                        }
-                      } else {
-                        // Split into chunks at newline boundaries
-                        const chunks: string[] = [];
-                        let remaining = text;
-                        while (remaining.length > 0) {
-                          if (remaining.length <= limit) {
-                            chunks.push(remaining);
-                            break;
+                      // Check if reply contains audio that should be sent as voice note
+                      const isAudioAsVoice = payload.audioAsVoice === true && payload.mediaUrl;
+                      
+                      if (isAudioAsVoice && payload.mediaUrl) {
+                        // Send as voice note
+                        try {
+                          if (replyClient.isE2EEnabled) {
+                            // Load audio from mediaUrl and send via sendVoiceNote
+                            const audioPath = payload.mediaUrl;
+                            if (fs.existsSync(audioPath)) {
+                              const audioBuffer = fs.readFileSync(audioPath);
+                              const mimeType = payload.mediaMimeType ?? "audio/aac";
+                              const caption = payload.text ?? payload.body ?? undefined;
+                              await replyClient.sendVoiceNote(from, audioBuffer, mimeType, caption);
+                            } else {
+                              api.logger?.warn?.(`Threema: audio file not found at ${audioPath}, falling back to text`);
+                              // Fallback to text if audio file not found
+                              const text = payload.text ?? payload.body;
+                              if (text) {
+                                await replyClient.sendE2E(from, text);
+                              }
+                            }
+                          } else {
+                            // Voice notes only work in E2E mode; fallback to text in basic mode
+                            api.logger?.info?.(`Threema: voice notes require E2E mode, sending text instead`);
+                            const text = payload.text ?? payload.body;
+                            if (text) {
+                              await replyClient.sendSimple(from, text);
+                            }
+                          }
+                        } catch (audioErr: any) {
+                          api.logger?.error?.(`Threema: error sending voice note: ${audioErr.message}`);
+                          // Fallback to text on error
+                          const text = payload.text ?? payload.body;
+                          if (text) {
+                            if (replyClient.isE2EEnabled) {
+                              await replyClient.sendE2E(from, text);
+                            } else {
+                              await replyClient.sendSimple(from, text);
+                            }
                           }
-                          let splitIdx = remaining.lastIndexOf("\n", limit);
-                          if (splitIdx <= 0) splitIdx = limit;
-                          chunks.push(remaining.slice(0, splitIdx));
-                          remaining = remaining.slice(splitIdx).replace(/^\n/, "");
                         }
-                        for (const chunk of chunks) {
+                      } else {
+                        // Send as text (existing logic)
+                        const text = payload.text ?? payload.body;
+                        if (!text) return;
+                        // Chunk long replies if needed
+                        const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
+                        if (text.length <= limit) {
                           if (replyClient.isE2EEnabled) {
-                            await replyClient.sendE2E(from, chunk);
+                            await replyClient.sendE2E(from, text);
                           } else {
-                            await replyClient.sendSimple(from, chunk);
+                            await replyClient.sendSimple(from, text);
+                          }
+                        } else {
+                          // Split into chunks at newline boundaries
+                          const chunks: string[] = [];
+                          let remaining = text;
+                          while (remaining.length > 0) {
+                            if (remaining.length <= limit) {
+                              chunks.push(remaining);
+                              break;
+                            }
+                            let splitIdx = remaining.lastIndexOf("\n", limit);
+                            if (splitIdx <= 0) splitIdx = limit;
+                            chunks.push(remaining.slice(0, splitIdx));
+                            remaining = remaining.slice(splitIdx).replace(/^\n/, "");
+                          }
+                          for (const chunk of chunks) {
+                            if (replyClient.isE2EEnabled) {
+                              await replyClient.sendE2E(from, chunk);
+                            } else {
+                              await replyClient.sendSimple(from, chunk);
+                            }
                           }
                         }
                       }
@@ -2121,11 +2258,24 @@ export default function register(api: any) {
             // session, runs the agent in-context, and lets us reply via
             // dispatchReplyWithBufferedBlockDispatcher just like text.
             const channelRuntime = runtime?.channel;
-            if (channelRuntime?.reply?.finalizeInboundContext
+            if (channelRuntime?.routing?.resolveAgentRoute
+                && channelRuntime?.routing?.buildAgentSessionKey
+                && channelRuntime?.reply?.finalizeInboundContext
                 && channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
               try {
                 const currentCfg = runtime.config.loadConfig();
-                const sessionKey = channelRuntime.reply.resolveDirectSessionKey({
+
+                // Resolve the same agent route + session key the text path uses
+                // so file inbounds end up in the live Threema DM session.
+                const route = channelRuntime.routing.resolveAgentRoute({
+                  cfg: currentCfg,
+                  channel: "threema",
+                  accountId: "default",
+                  peer: { kind: "direct", id: from },
+                });
+
+                const sessionKey = channelRuntime.routing.buildAgentSessionKey({
+                  agentId: route.agentId,
                   channel: "threema",
                   accountId: "default",
                   peer: { kind: "direct", id: from },
@@ -2166,33 +2316,78 @@ export default function register(api: any) {
                   cfg: currentCfg,
                   dispatcherOptions: {
                     deliver: async (payload: any) => {
-                      const text = payload.text ?? payload.body;
-                      if (!text) return;
-                      const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
-                      if (text.length <= limit) {
-                        if (replyClient.isE2EEnabled) {
-                          await replyClient.sendE2E(from, text);
-                        } else {
-                          await replyClient.sendSimple(from, text);
-                        }
-                      } else {
-                        const chunks: string[] = [];
-                        let remaining = text;
-                        while (remaining.length > 0) {
-                          if (remaining.length <= limit) {
-                            chunks.push(remaining);
-                            break;
+                      // Check if reply contains audio that should be sent as voice note
+                      const isAudioAsVoice = payload.audioAsVoice === true && payload.mediaUrl;
+                      
+                      if (isAudioAsVoice && payload.mediaUrl) {
+                        // Send as voice note
+                        try {
+                          if (replyClient.isE2EEnabled) {
+                            // Load audio from mediaUrl and send via sendVoiceNote
+                            const audioPath = payload.mediaUrl;
+                            if (fs.existsSync(audioPath)) {
+                              const audioBuffer = fs.readFileSync(audioPath);
+                              const mimeType = payload.mediaMimeType ?? "audio/aac";
+                              const caption = payload.text ?? payload.body ?? undefined;
+                              await replyClient.sendVoiceNote(from, audioBuffer, mimeType, caption);
+                            } else {
+                              api.logger?.warn?.(`Threema: audio file not found at ${audioPath}, falling back to text`);
+                              // Fallback to text if audio file not found
+                              const text = payload.text ?? payload.body;
+                              if (text) {
+                                await replyClient.sendE2E(from, text);
+                              }
+                            }
+                          } else {
+                            // Voice notes only work in E2E mode; fallback to text in basic mode
+                            api.logger?.info?.(`Threema: voice notes require E2E mode, sending text instead`);
+                            const text = payload.text ?? payload.body;
+                            if (text) {
+                              await replyClient.sendSimple(from, text);
+                            }
+                          }
+                        } catch (audioErr: any) {
+                          api.logger?.error?.(`Threema: error sending voice note: ${audioErr.message}`);
+                          // Fallback to text on error
+                          const text = payload.text ?? payload.body;
+                          if (text) {
+                            if (replyClient.isE2EEnabled) {
+                              await replyClient.sendE2E(from, text);
+                            } else {
+                              await replyClient.sendSimple(from, text);
+                            }
                           }
-                          let splitIdx = remaining.lastIndexOf("\n", limit);
-                          if (splitIdx <= 0) splitIdx = limit;
-                          chunks.push(remaining.slice(0, splitIdx));
-                          remaining = remaining.slice(splitIdx).replace(/^\n/, "");
                         }
-                        for (const chunk of chunks) {
+                      } else {
+                        // Send as text (existing logic)
+                        const text = payload.text ?? payload.body;
+                        if (!text) return;
+                        const limit = getThreemaConfig(currentCfg)?.textChunkLimit ?? 3500;
+                        if (text.length <= limit) {
                           if (replyClient.isE2EEnabled) {
-                            await replyClient.sendE2E(from, chunk);
+                            await replyClient.sendE2E(from, text);
                           } else {
-                            await replyClient.sendSimple(from, chunk);
+                            await replyClient.sendSimple(from, text);
+                          }
+                        } else {
+                          const chunks: string[] = [];
+                          let remaining = text;
+                          while (remaining.length > 0) {
+                            if (remaining.length <= limit) {
+                              chunks.push(remaining);
+                              break;
+                            }
+                            let splitIdx = remaining.lastIndexOf("\n", limit);
+                            if (splitIdx <= 0) splitIdx = limit;
+                            chunks.push(remaining.slice(0, splitIdx));
+                            remaining = remaining.slice(splitIdx).replace(/^\n/, "");
+                          }
+                          for (const chunk of chunks) {
+                            if (replyClient.isE2EEnabled) {
+                              await replyClient.sendE2E(from, chunk);
+                            } else {
+                              await replyClient.sendSimple(from, chunk);
+                            }
                           }
                         }
                       }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "threema",
   "name": "Threema Gateway",
   "description": "Threema messaging channel via Threema Gateway API (E2E encrypted)",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "channels": [
     "threema"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-threema",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Threema Gateway channel plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",