@rikaidev/yomi 0.4.2 → 0.6.0

package/dist/mcp/handlers/conversations.js

@@ -1,3 +1,5 @@
+import { isSquareChatMid } from '../../line/client/square-service/client.js';
+import { sanitizeMessagePreview } from '../../line/core/message-preview.js';
 import { decryptLineMessage } from '../../line/core/message-query-service.js';
 import { getExcludedChatIds } from '../../search/scope.js';
 import { createCliLogger } from '../../util/log.js';
@@ -6,6 +8,16 @@ import { resolveConversationNames, resolveSenderNames } from '../names.js';
 import { createPhiAccumulator, maskInto, phiNote } from '../phi-guard.js';
 import { jsonResult, toolError, toonText } from './shared.js';
 const log = createCliLogger('Yomi');
+function messageTimestamp(message) {
+    return Number(message?.deliveredTime || message?.createdTime || 0);
+}
+function latestMessage(messages) {
+    if (!Array.isArray(messages) || messages.length === 0)
+        return null;
+    return messages.reduce((latest, candidate) => messageTimestamp(candidate) >= messageTimestamp(latest)
+        ? candidate
+        : latest);
+}
 /**
  * Handle `list_conversations` — list LINE conversations (chats, groups, rooms)
  * with unread counts, a last-message preview, and a resolved display name.
@@ -15,6 +27,13 @@ const log = createCliLogger('Yomi');
  * @returns MCP tool result.
  */
 export async function handleListConversations(service, args) {
+    try {
+        await service.client.syncLongPoll(50, 1000);
+        if (service.sessionState?.saveSyncRevisions) {
+            await service.sessionState.saveSyncRevisions(Number(service.client.revision || 0), Number(service.client.globalRevision || 0), Number(service.client.individualRevision || 0));
+        }
+    }
+    catch { }
     const result = await service.client.getMessageBoxes({
         lastMessagesPerMessageBoxCount: 1,
         messageBoxCountLimit: args.limit ?? 20,
@@ -30,17 +49,63 @@ export async function handleListConversations(service, args) {
     // decrypted.
     const acc = createPhiAccumulator();
     const conversations = await Promise.all(boxes.map(async (box) => {
-        const lastMessage = box.lastMessages?.[box.lastMessages.length - 1] || null;
+        let lastMessage = latestMessage(box.lastMessages);
+        const cursorTime = Number(box.lastDeliveredMessageId?.deliveredTime || 0);
+        if (box.id &&
+            (!lastMessage || messageTimestamp(lastMessage) < cursorTime)) {
+            try {
+                const recent = await service.getRecentMessages(box.id, 1);
+                const candidate = latestMessage(recent);
+                if (candidate &&
+                    messageTimestamp(candidate) >= messageTimestamp(lastMessage)) {
+                    lastMessage = candidate;
+                }
+            }
+            catch { }
+        }
         const decryptedLastMessage = lastMessage
             ? await decryptLineMessage(service.e2eeManager, lastMessage, box.id)
             : null;
+        const previewText = sanitizeMessagePreview(decryptedLastMessage?.text ?? lastMessage?.text);
         return {
             id: box.id,
-            lastMessagePreview: maskInto(acc, decryptedLastMessage?.text ?? null),
+            lastMessagePreview: maskInto(acc, previewText || (lastMessage?.text ? '[加密訊息]' : null)),
             name: names.get(box.id) ?? null,
             unreadCount: box.unreadCount ?? 0,
         };
     }));
+    try {
+        const squareChats = await service.client.getJoinedSquareChats(args.limit ?? 20);
+        for (const chat of squareChats) {
+            let last = chat.lastMessage;
+            let senderName = chat.lastSenderName;
+            if (!last) {
+                const recent = await service.client.getSquareChatMessages(chat.id, 1);
+                const normalized = recent.at(-1);
+                if (normalized) {
+                    last = {
+                        4: normalized.id,
+                        5: normalized.createdTime,
+                        10: normalized.text,
+                        15: normalized.contentType,
+                    };
+                    senderName = normalized.fromName;
+                }
+            }
+            const preview = sanitizeMessagePreview(last?.[10]);
+            conversations.push({
+                id: chat.id,
+                lastMessagePreview: maskInto(acc, preview || (last ? '[社群訊息]' : null)),
+                name: maskInto(acc, chat.name),
+                unreadCount: chat.unreadCount,
+                ...(senderName ? { lastSenderName: maskInto(acc, senderName) } : {}),
+            });
+        }
+    }
+    catch {
+        // OpenChat availability differs by LINE account/region. TalkService
+        // conversations remain authoritative when SquareService is unavailable.
+    }
     const content = [
         { type: 'text', text: toonText(conversations) },
     ];
@@ -77,6 +142,27 @@ export async function handleGetChatMessages(service, args) {
     if (!args.chatId) {
         return toolError('chatId is required.');
     }
+    if (isSquareChatMid(args.chatId)) {
+        const squareMessages = await service.client.getSquareChatMessages(args.chatId, args.count ?? 50);
+        const acc = createPhiAccumulator();
+        const shaped = squareMessages.map((message) => ({
+            createdTime: message.createdTime,
+            deliveredTime: message.createdTime,
+            from: message.fromMid,
+            fromName: maskInto(acc, message.fromName),
+            id: message.id,
+            mediaType: resolveLineMediaType(Number(message.contentType)),
+            mentions: message.contentMetadata?.MENTION ?? null,
+            text: maskInto(acc, sanitizeMessagePreview(message.text) || '[社群訊息]'),
+            e2eeDecrypted: null,
+            service: 'SQUARE',
+        }));
+        const content = [{ type: 'text', text: toonText(shaped) }];
+        const note = phiNote(acc);
+        if (note)
+            content.push(note);
+        return { content };
+    }
     const fetched = args.before
         ? await service.getPreviousMessages(args.chatId, args.count ?? 50, args.before)
         : await service.getRecentMessages(args.chatId, args.count ?? 50);
@@ -104,7 +190,8 @@ export async function handleGetChatMessages(service, args) {
         // be observed against a live mentioning message before anyone builds
         // the outbound (send-a-mention) side.
         mentions: message.contentMetadata?.MENTION ?? null,
-        text: maskInto(acc, message.text),
+        text: maskInto(acc, sanitizeMessagePreview(message.text) ||
+            (message.text ? '[加密訊息]' : null)),
         e2eeDecrypted: message.e2eeDecrypted ?? null,
         // Emitted ONLY when the message decrypted but could not be authenticated
         // (LINE E2EE v1 — AES-CBC, no tag, no AAD), so its presence is a signal
@@ -175,7 +262,7 @@ export async function handleGetUnreadDigest(service, args) {
                 mediaType: resolveLineMediaDescriptor(m) !== null
                     ? resolveLineMediaType(Number(m.contentType))
                     : null,
-                text: maskInto(acc, m.text),
+                text: maskInto(acc, sanitizeMessagePreview(m.text) || (m.text ? '[加密訊息]' : null)),
             })),
         };
     }));

package/dist/mcp/handlers/login.js

@@ -44,7 +44,7 @@ function elicitPinAcknowledgement(server, pin, onDeclined) {
  * Handle `login` on a LEGACY-era connection whose client supports form
  * elicitation — drive the passwordless flow entirely through pushed
  * elicitation requests, with no out-of-band channel required. A pre-flight
- * form confirms the 允許自其他裝置登入 prerequisite (and collects
+ * form confirms the allow-login-from-other-devices prerequisite (and collects
  * phone/region when missing) BEFORE any PIN is issued; the PIN is then
  * surfaced through a second elicitation fired without blocking
  * `runPwlessLogin`, which keeps running while the human acts on their phone.

package/dist/mcp/handlers/message-actions.js

@@ -4,7 +4,7 @@ const log = createCliLogger('Yomi');
 /**
  * Handle `react_message` — REALLY adds a predefined reaction to a real LINE
  * message now (TalkService react). Visible to the conversation. `reactionType`:
- * 2=LIKE 👍, 3=LOVE ❤️, 4=LAUGH 😆, 5=SURPRISE 😮, 6=SAD 😢, 7=ANGRY 😡
+ * Protocol emoji mapping: 2=LIKE 👍, 3=LOVE ❤️, 4=LAUGH 😆, 5=SURPRISE 😮, 6=SAD 😢, 7=ANGRY 😡
  * (default 2).
  *
  * @param service - Resumed LineProtocolService.

package/dist/mcp/handlers/search.js

@@ -17,7 +17,7 @@
  * result that either method ranks highly surfaces near the top. This is
  * deliberately not "semantic OR keyword": pure semantic over a partially-
  * embedded index silently drops exact matches that live in un-embedded
- * messages (the "search 台東 misses the chat that literally says 台東" bug),
+ * messages (the "search for a place name misses the exact same place name" bug),
  * and pure keyword misses paraphrases. Which methods actually contributed
  * is always reported via the `mode` field (`hybrid` | `semantic` |
  * `keyword`), never hidden.

package/dist/mcp/handlers/send.js

@@ -226,6 +226,11 @@ export async function handleSendFile(service, args) {
  * person's mid in contentMetadata. `displayName` is resolved from the mid when
  * the caller omits it. One send per call; honest error on failure.
  *
+ * The recipient reads this string, so it is always the contact's own profile
+ * name (contact-query field 22) and never the name a shared cache holds. That
+ * cache exists to show the user the name they gave a friend locally, which is
+ * a private label and must not travel to a third party.
+ *
  * @param service - Resumed LineProtocolService.
  * @param args - Tool arguments.
  * @returns MCP tool result.
@@ -240,19 +245,11 @@ export async function handleSendContact(service, args) {
     let displayName = args.displayName ?? '';
     if (!displayName) {
         try {
-            displayName = service.resolveName(args.contactMid) || '';
+            const contact = await service.getContact(args.contactMid);
+            displayName = contact?.displayName ?? '';
         }
         catch {
-            displayName = '';
-        }
-        if (!displayName) {
-            try {
-                const contact = await service.getContact(args.contactMid);
-                displayName = contact?.displayName ?? '';
-            }
-            catch {
-                // Leave empty — LINE resolves the name from the mid on the recipient side.
-            }
+            // Leave empty — LINE resolves the name from the mid on the recipient side.
         }
     }
     const result = await service.sendContact(args.chatId, args.contactMid, displayName);

package/dist/mcp/handlers/shared.js

@@ -6,7 +6,7 @@ import { encode } from '@toon-format/toon';
  * under src/mcp/handlers/ can import these without a circular dependency.
  */
 // Yomi logs in on its own (via the `login`/`login_complete` tools, or
-// `npx @rikaidev/yomi login`); it does not depend on inboxd for anything.
+// `npx @rikaidev/yomi login`); session is shared with Yomi Desktop.
 export const NO_CREDENTIALS_MESSAGE = 'No persisted LINE session. Call the `login` tool, or run `npx @rikaidev/yomi login` in a terminal.';
 // Shown when LINE invalidated a previously working session — distinct from
 // "never logged in" so the model tells the user the right story: the MCP

package/dist/mcp/integrator.js

@@ -0,0 +1,168 @@
+/**
+ * Universal 1-Click MCP Integrator for Claude Desktop, Claude Cowork, Codex, Cursor, Windsurf, VS Code (Cline/Roo).
+ * Also automatically generates and registers Yomi Skills for AI Agent assistants.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export function getClientTargets() {
+    const home = homedir();
+    return [
+        {
+            id: 'claude-desktop',
+            name: 'Claude Desktop & Cowork',
+            configPath: join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+            configType: 'mcpServers',
+            requiresApp: '/Applications/Claude.app',
+        },
+        {
+            id: 'codex-desktop',
+            name: 'Codex Desktop & CLI',
+            configPath: join(home, '.codex', 'mcp.json'),
+            configType: 'mcpServers',
+        },
+        {
+            id: 'cursor',
+            name: 'Cursor IDE',
+            configPath: join(home, '.cursor', 'mcp.json'),
+            configType: 'mcpServers',
+            requiresApp: '/Applications/Cursor.app',
+        },
+        {
+            id: 'windsurf',
+            name: 'Windsurf (Codeium)',
+            configPath: join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+            configType: 'mcpServers',
+            requiresApp: '/Applications/Windsurf.app',
+        },
+        {
+            id: 'cline',
+            name: 'VS Code (Cline)',
+            configPath: join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+            configType: 'mcpServers',
+        },
+        {
+            id: 'roo-code',
+            name: 'VS Code (Roo Code)',
+            configPath: join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings', 'cline_mcp_settings.json'),
+            configType: 'mcpServers',
+        },
+        {
+            id: 'claude-cli',
+            name: 'Claude Code CLI',
+            configPath: join(home, '.claude.json'),
+            configType: 'mcpServers',
+        },
+    ];
+}
+export function getYomiMcpDefinition() {
+    const home = homedir();
+    const npxPath = existsSync('/opt/homebrew/bin/npx')
+        ? '/opt/homebrew/bin/npx'
+        : existsSync('/usr/local/bin/npx')
+            ? '/usr/local/bin/npx'
+            : 'npx';
+    return {
+        command: npxPath,
+        args: ['-y', '@rikaidev/yomi'],
+        env: {
+            PATH: `${home}/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`,
+        },
+    };
+}
+export function installYomiAgentSkill() {
+    const home = homedir();
+    const skillContent = `---
+name: yomi-line-manager
+description: Manage and interact with user's LINE account via Yomi E2EE MCP Server. Query messages, summarize chats, search history, find contacts, and draft replies.
+---
+
+# Yomi LINE Copilot Skill
+
+You have real-time access to the user's LINE account through the Yomi Letter-Sealing E2EE MCP Server.
+
+## Capabilities
+1. \`get_recent_messages\`: Retrieve recent decrypted messages.
+2. \`search_messages\`: Full-text search across conversations.
+3. \`list_contacts\`: Retrieve friends and group information.
+4. \`send_message\`: Send messages to chats with confirmation.
+
+## Guidelines
+- Summarize conversations concisely and highlight action items or mentions needing attention.
+- When drafting a reply, ask the user for confirmation before executing \`send_message\`.
+`;
+    const skillDirs = [
+        join(home, '.claude', 'skills', 'yomi-line-manager'),
+        join(home, '.gemini', 'antigravity-cli', 'builtin', 'skills', 'yomi-line-manager'),
+        join(home, '.codex', 'skills', 'yomi-line-manager'),
+    ];
+    let installedPath = '';
+    for (const dir of skillDirs) {
+        try {
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true, mode: 0o755 });
+            }
+            const skillFile = join(dir, 'SKILL.md');
+            writeFileSync(skillFile, skillContent, { mode: 0o644 });
+            installedPath = skillFile;
+        }
+        catch {
+            // Ignore directory write failures for optional tools
+        }
+    }
+    return { success: true, path: installedPath };
+}
+export function integrateClient(target) {
+    try {
+        const dir = dirname(target.configPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true, mode: 0o755 });
+        }
+        let config = {};
+        if (existsSync(target.configPath)) {
+            try {
+                const raw = readFileSync(target.configPath, 'utf8');
+                config = JSON.parse(raw);
+            }
+            catch {
+                config = {};
+            }
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+            config.mcpServers = {};
+        }
+        config.mcpServers.yomi = getYomiMcpDefinition();
+        writeFileSync(target.configPath, JSON.stringify(config, null, 2), {
+            mode: 0o600,
+        });
+        return {
+            success: true,
+            message: `Integrated Yomi MCP into ${target.name}`,
+            path: target.configPath,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: `Failed to configure ${target.name}: ${err.message}`,
+            path: target.configPath,
+        };
+    }
+}
+export function integrateAllClients() {
+    const skillResult = installYomiAgentSkill();
+    const targets = getClientTargets();
+    const results = targets.map((t) => {
+        const res = integrateClient(t);
+        return {
+            id: t.id,
+            name: t.name,
+            ...res,
+        };
+    });
+    return {
+        results,
+        totalSuccess: results.filter((r) => r.success).length,
+        skillInstalled: skillResult.success,
+    };
+}

package/dist/mcp/media.js

@@ -13,7 +13,8 @@
  * missing, or the message's content type is not a downloadable media type,
  * callers get an honest error naming the reason.
  */
-import { downloadLineObsMediaObject } from '../line/client/obs-media-client.js';
+import { downloadLineMessageData, downloadLineObsMediaObject, } from '../line/client/obs-media-client.js';
+import { isSquareChatMid } from '../line/client/square-service/client.js';
 import { CONTENT_TYPE } from '../line/core/constants.js';
 import { decryptLineMediaBytes } from '../line/core/media-decrypt.js';
 /** LINE content types this server can download and decrypt via the OBS path. */
@@ -57,6 +58,51 @@ const MIME_BY_EXTENSION = {
     webp: 'image/webp',
     zip: 'application/zip',
 };
+const TRUSTED_PUBLIC_MEDIA_HOST_SUFFIXES = [
+    'line-scdn.net',
+    'line-apps.com',
+    'cdn.hinet.net',
+];
+export function resolvePublicMediaUrl(message, preview) {
+    const metadata = message?.contentMetadata ?? {};
+    if (metadata.PUBLIC !== 'true')
+        return null;
+    const raw = preview
+        ? metadata.PREVIEW_URL || metadata.DOWNLOAD_URL
+        : metadata.DOWNLOAD_URL || metadata.PREVIEW_URL;
+    if (typeof raw !== 'string' || !raw)
+        return null;
+    try {
+        const url = new URL(raw);
+        const hostname = url.hostname.toLowerCase();
+        if (url.protocol !== 'https:' ||
+            !TRUSTED_PUBLIC_MEDIA_HOST_SUFFIXES.some((suffix) => hostname === suffix || hostname.endsWith(`.${suffix}`))) {
+            return null;
+        }
+        return url;
+    }
+    catch {
+        return null;
+    }
+}
+async function downloadPublicMedia(url) {
+    const response = await fetch(url, { redirect: 'error' });
+    if (!response.ok) {
+        throw new Error(`Public LINE media download failed (${response.status})`);
+    }
+    const length = Number(response.headers.get('content-length') ?? 0);
+    if (Number.isFinite(length) && length > 25 * 1024 * 1024) {
+        throw new Error('Public LINE media exceeds 25 MB');
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length === 0 || bytes.length > 25 * 1024 * 1024) {
+        throw new Error('Public LINE media returned invalid bytes');
+    }
+    return {
+        bytes,
+        mimeType: response.headers.get('content-type')?.split(';')[0] || null,
+    };
+}
 /**
  * Resolve the short media-kind label for a LINE content type.
  *
@@ -98,6 +144,16 @@ function resolveMimeType(extension, contentType) {
     }
     return DEFAULT_MIME_BY_CONTENT_TYPE[contentType] || null;
 }
+/**
+ * Resolve a legacy message's filename extension without requiring an OBS
+ * descriptor.  Older Talk messages expose MEDIA_CONTENT_INFO but omit OID/SID.
+ */
+function resolveMediaInfoExtension(message) {
+    const info = parseJson(message?.contentMetadata?.MEDIA_CONTENT_INFO, {});
+    return typeof info.extension === 'string' && info.extension.trim()
+        ? info.extension.trim()
+        : null;
+}
 /**
  * Build a LINE media descriptor from a decrypted message.
  *
@@ -115,10 +171,18 @@ export function resolveLineMediaDescriptor(message) {
     }
     const dataPayload = parseJson(message?.text, {});
     const mediaInfo = parseJson(contentMetadata.MEDIA_CONTENT_INFO, {});
+    const fileName = dataPayload.fileName ||
+        (typeof contentMetadata.FILE_NAME === 'string' &&
+            contentMetadata.FILE_NAME) ||
+        (typeof contentMetadata.FILE_NAME_ORIGINAL === 'string' &&
+            contentMetadata.FILE_NAME_ORIGINAL) ||
+        (typeof contentMetadata.name === 'string' && contentMetadata.name) ||
+        null;
+    const extension = mediaInfo.extension || (fileName ? fileName.split('.').pop() : null) || null;
     return {
-        fileName: dataPayload.fileName || null,
+        fileName,
         keyMaterial: dataPayload.keyMaterial || null,
-        mimeType: resolveMimeType(mediaInfo.extension || null, Number(message?.contentType || 0)),
+        mimeType: resolveMimeType(extension, Number(message?.contentType || 0)),
         oid: String(contentMetadata.OID),
         sid: String(contentMetadata.SID),
     };
@@ -155,6 +219,38 @@ class UnsupportedMediaTypeError extends LineMediaAccessError {
  * @returns Decrypted media bytes, resolved MIME type, filename, and content type.
  */
 export async function fetchLineMessageMedia(service, chatId, messageId, preview) {
+    if (isSquareChatMid(chatId)) {
+        const mainMessages = await service.client.getSquareChatMessages(chatId, 100);
+        let message = mainMessages.find((candidate) => candidate.id === messageId);
+        if (!message) {
+            for (const root of mainMessages.filter((candidate) => candidate.isThreadRoot && candidate.threadMid)) {
+                const replies = await service.client.getSquareChatMessages(chatId, 100, root.threadMid);
+                message = replies.find((candidate) => candidate.id === messageId);
+                if (message)
+                    break;
+            }
+        }
+        if (!message) {
+            throw new MissingDecryptMaterialError(`Square message ${messageId} not found in ${chatId}`);
+        }
+        const contentType = Number(message.contentType);
+        if (!DOWNLOADABLE_CONTENT_TYPES.has(contentType)) {
+            throw new UnsupportedMediaTypeError(contentType, messageId);
+        }
+        const downloaded = await downloadLineMessageData(service.client, {
+            messageId,
+            preview,
+            square: true,
+        });
+        return {
+            bytes: downloaded.bytes,
+            contentType,
+            fileName: message.contentMetadata?.FILE_NAME || null,
+            mimeType: downloaded.mimeType ||
+                DEFAULT_MIME_BY_CONTENT_TYPE[contentType] ||
+                'application/octet-stream',
+        };
+    }
     const messages = await service.getRecentMessages(chatId, 100);
     const message = messages.find((candidate) => candidate.id === messageId);
     if (!message) {
@@ -164,9 +260,44 @@ export async function fetchLineMessageMedia(service, chatId, messageId, preview)
     if (!DOWNLOADABLE_CONTENT_TYPES.has(contentType)) {
         throw new UnsupportedMediaTypeError(contentType, messageId);
     }
+    const publicMediaUrl = resolvePublicMediaUrl(message, preview);
+    if (publicMediaUrl) {
+        const downloaded = await downloadPublicMedia(publicMediaUrl);
+        const extension = publicMediaUrl.pathname.split('.').pop() ?? null;
+        return {
+            bytes: downloaded.bytes,
+            contentType,
+            fileName: null,
+            mimeType: downloaded.mimeType ||
+                resolveMimeType(extension, contentType) ||
+                'application/octet-stream',
+        };
+    }
     const descriptor = resolveLineMediaDescriptor(message);
     if (!descriptor) {
-        throw new MissingDecryptMaterialError(`message ${messageId} is missing OBS object metadata (OID/SID)`);
+        // Older/non-E2EE Talk messages carry MEDIA_CONTENT_INFO but omit OID/SID.
+        // Their object is addressed by message id at OBS /r/talk/m/{id}; the
+        // similarly named TalkService methods are not real `/S4` methods and
+        // return Invalid method name.  Keep the request at the OBS layer.
+        const downloaded = await downloadLineMessageData(service.client, {
+            messageId,
+            preview,
+        });
+        const contentMetadata = message?.contentMetadata || {};
+        const fileName = (typeof contentMetadata.FILE_NAME === 'string' &&
+            contentMetadata.FILE_NAME) ||
+            (typeof contentMetadata.FILE_NAME_ORIGINAL === 'string' &&
+                contentMetadata.FILE_NAME_ORIGINAL) ||
+            (typeof contentMetadata.name === 'string' && contentMetadata.name) ||
+            null;
+        return {
+            bytes: downloaded.bytes,
+            contentType,
+            fileName,
+            mimeType: downloaded.mimeType ||
+                resolveMimeType(resolveMediaInfoExtension(message), contentType) ||
+                'application/octet-stream',
+        };
     }
     const encryptedBytes = await downloadLineObsMediaObject(service.client, {
         messageId,